WIP

Co-authored-by: Bennet <bennetbo@gmx.de>
WIP
2024-04-10 13:32:46 +02:00 · 2024-04-09 12:33:35 -06:00 · 2024-04-09 19:28:58 +02:00 · 2024-04-09 13:22:11 +02:00 · 2024-04-08 22:07:59 -07:00 · 2024-04-08 19:53:25 -07:00
635 changed files with 29576 additions and 13096 deletions
--- a/.github/ISSUE_TEMPLATE/2_crash_report.yml
+++ b/.github/ISSUE_TEMPLATE/2_crash_report.yml
@@ -23,12 +23,6 @@ body:
          description: Run the `copy system specs into clipboard` command palette action and paste the output in the field below.
      validations:
          required: true
-    - type: textarea
-      attributes:
-          label: If applicable, add mockups / screenshots to help explain present your vision of the feature
-          description: Drag issues into the text input below
-      validations:
-          required: false
    - type: textarea
      attributes:
          label: If applicable, attach your `~/Library/Logs/Zed/Zed.log` file to this issue.
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -54,6 +54,9 @@ jobs:
      - name: Check unused dependencies
        uses: bnjbvr/cargo-machete@main

+      - name: Check license generation
+        run: script/generate-licenses /tmp/zed_licenses_output
+
      - name: Ensure fresh merge
        shell: bash -euxo pipefail {0}
        run: |
--- a/.github/workflows/update_all_top_ranking_issues.yml
+++ b/.github/workflows/update_all_top_ranking_issues.yml
@@ -9,10 +9,10 @@ jobs:
    if: github.repository_owner == 'zed-industries'
    steps:
      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
        with:
-          python-version: "3.10.5"
+          python-version: "3.11"
          architecture: "x64"
          cache: "pip"
      - run: pip install -r script/update_top_ranking_issues/requirements.txt
-      - run: python script/update_top_ranking_issues/main.py 5393 --github-token ${{ secrets.GITHUB_TOKEN }} --prod
+      - run: python script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 5393
--- a/.github/workflows/update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/update_weekly_top_ranking_issues.yml
@@ -9,10 +9,10 @@ jobs:
    if: github.repository_owner == 'zed-industries'
    steps:
      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
        with:
-          python-version: "3.10.5"
+          python-version: "3.11"
          architecture: "x64"
          cache: "pip"
      - run: pip install -r script/update_top_ranking_issues/requirements.txt
-      - run: python script/update_top_ranking_issues/main.py 6952 --github-token ${{ secrets.GITHUB_TOKEN }} --prod --query-day-interval 7
+      - run: python script/update_top_ranking_issues/main.py --github-token ${{ secrets.GITHUB_TOKEN }} --issue-reference-number 6952 --query-day-interval 7
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -15,6 +15,10 @@
    "JSON": {
      "tab_size": 2,
      "formatter": "prettier"
+    },
+    "JavaScript": {
+      "tab_size": 2,
+      "formatter": "prettier"
    }
  },
  "formatter": "auto"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 members = [
    "crates/activity_indicator",
+    "crates/anthropic",
    "crates/assets",
    "crates/assistant",
    "crates/audio",
@@ -28,6 +29,7 @@ members = [
    "crates/feature_flags",
    "crates/feedback",
    "crates/file_finder",
+    "crates/file_icons",
    "crates/fs",
    "crates/fsevent",
    "crates/fuzzy",
@@ -70,6 +72,7 @@ members = [
    "crates/task",
    "crates/tasks_ui",
    "crates/search",
+    "crates/semantic_version",
    "crates/settings",
    "crates/snippet",
    "crates/sqlez",
@@ -77,6 +80,7 @@ members = [
    "crates/story",
    "crates/storybook",
    "crates/sum_tree",
+    "crates/tab_switcher",
    "crates/terminal",
    "crates/terminal_view",
    "crates/text",
@@ -95,8 +99,22 @@ members = [
    "crates/zed",
    "crates/zed_actions",

+    "extensions/astro",
+    "extensions/clojure",
+    "extensions/csharp",
+    "extensions/dart",
+    "extensions/emmet",
+    "extensions/erlang",
    "extensions/gleam",
+    "extensions/haskell",
+    "extensions/html",
+    "extensions/php",
+    "extensions/prisma",
+    "extensions/purescript",
+    "extensions/svelte",
+    "extensions/toml",
    "extensions/uiua",
+    "extensions/zig",

    "tooling/xtask",
 ]
@@ -106,6 +124,7 @@ resolver = "2"
 [workspace.dependencies]
 activity_indicator = { path = "crates/activity_indicator" }
 ai = { path = "crates/ai" }
+anthropic = { path = "crates/anthropic" }
 assets = { path = "crates/assets" }
 assistant = { path = "crates/assistant" }
 audio = { path = "crates/audio" }
@@ -133,6 +152,7 @@ extensions_ui = { path = "crates/extensions_ui" }
 feature_flags = { path = "crates/feature_flags" }
 feedback = { path = "crates/feedback" }
 file_finder = { path = "crates/file_finder" }
+file_icons = { path = "crates/file_icons" }
 fs = { path = "crates/fs" }
 fsevent = { path = "crates/fsevent" }
 fuzzy = { path = "crates/fuzzy" }
@@ -176,6 +196,7 @@ rpc = { path = "crates/rpc" }
 task = { path = "crates/task" }
 tasks_ui = { path = "crates/tasks_ui" }
 search = { path = "crates/search" }
+semantic_version = { path = "crates/semantic_version" }
 settings = { path = "crates/settings" }
 snippet = { path = "crates/snippet" }
 sqlez = { path = "crates/sqlez" }
@@ -183,6 +204,7 @@ sqlez_macros = { path = "crates/sqlez_macros" }
 story = { path = "crates/story" }
 storybook = { path = "crates/storybook" }
 sum_tree = { path = "crates/sum_tree" }
+tab_switcher = { path = "crates/tab_switcher" }
 terminal = { path = "crates/terminal" }
 terminal_view = { path = "crates/terminal_view" }
 text = { path = "crates/text" }
@@ -201,16 +223,18 @@ zed = { path = "crates/zed" }
 zed_actions = { path = "crates/zed_actions" }

 anyhow = "1.0.57"
+any_vec = "0.13"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-fs = "1.6"
 async-recursion = "1.0.0"
 async-tar = "0.4.2"
 async-trait = "0.1"
 bitflags = "2.4.2"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "61cbd6b2c224791d52b150fe535cee665cc91bb2" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "61cbd6b2c224791d52b150fe535cee665cc91bb2" }
+# todo(linux): Remove these once https://github.com/kvark/blade/pull/107 is merged and we've upgraded our renderer
+blade-graphics = { git = "https://github.com/zed-industries/blade", rev = "85981c0f4890a5fcd08da2a53cc4a0459247af44" }
+blade-macros = { git = "https://github.com/zed-industries/blade", rev = "85981c0f4890a5fcd08da2a53cc4a0459247af44" }
 blade-rwh = { package = "raw-window-handle", version = "0.5" }
-cap-std = "2.0"
+cap-std = "3.0"
 chrono = { version = "0.4", features = ["serde"] }
 clap = { version = "4.4", features = ["derive"] }
 clickhouse = { version = "0.11.6" }
@@ -272,6 +296,8 @@ tempfile = "3.9.0"
 thiserror = "1.0.29"
 tiktoken-rs = "0.5.7"
 time = { version = "0.3", features = [
+    "macros",
+    "parsing",
    "serde",
    "serde-well-known",
    "formatting",
@@ -280,25 +306,17 @@ toml = "0.8"
 tokio = { version = "1", features = ["full"] }
 tower-http = "0.4.4"
 tree-sitter = { version = "0.20", features = ["wasm"] }
-tree-sitter-astro = { git = "https://github.com/virchau13/tree-sitter-astro.git", rev = "e924787e12e8a03194f36a113290ac11d6dc10f3" }
 tree-sitter-bash = { git = "https://github.com/tree-sitter/tree-sitter-bash", rev = "7331995b19b8f8aba2d5e26deb51d2195c18bc94" }
 tree-sitter-c = "0.20.1"
-tree-sitter-clojure = { git = "https://github.com/prcastro/tree-sitter-clojure", branch = "update-ts" }
-tree-sitter-c-sharp = { git = "https://github.com/tree-sitter/tree-sitter-c-sharp", rev = "dd5e59721a5f8dae34604060833902b882023aaf" }
 tree-sitter-cpp = { git = "https://github.com/tree-sitter/tree-sitter-cpp", rev = "f44509141e7e483323d2ec178f2d2e6c0fc041c1" }
 tree-sitter-css = { git = "https://github.com/tree-sitter/tree-sitter-css", rev = "769203d0f9abe1a9a691ac2b9fe4bb4397a73c51" }
-tree-sitter-dockerfile = { git = "https://github.com/camdencheek/tree-sitter-dockerfile", rev = "33e22c33bcdbfc33d42806ee84cfd0b1248cc392" }
-tree-sitter-dart = { git = "https://github.com/agent3bood/tree-sitter-dart", rev = "48934e3bf757a9b78f17bdfaa3e2b4284656fdc7" }
 tree-sitter-elixir = { git = "https://github.com/elixir-lang/tree-sitter-elixir", rev = "a2861e88a730287a60c11ea9299c033c7d076e30" }
 tree-sitter-elm = { git = "https://github.com/elm-tooling/tree-sitter-elm", rev = "692c50c0b961364c40299e73c1306aecb5d20f40" }
 tree-sitter-embedded-template = "0.20.0"
-tree-sitter-erlang = "0.4.0"
-tree-sitter-gleam = { git = "https://github.com/gleam-lang/tree-sitter-gleam", rev = "58b7cac8fc14c92b0677c542610d8738c373fa81" }
 tree-sitter-glsl = { git = "https://github.com/theHamsta/tree-sitter-glsl", rev = "2a56fb7bc8bb03a1892b4741279dd0a8758b7fb3" }
 tree-sitter-go = { git = "https://github.com/tree-sitter/tree-sitter-go", rev = "aeb2f33b366fd78d5789ff104956ce23508b85db" }
 tree-sitter-gomod = { git = "https://github.com/camdencheek/tree-sitter-go-mod" }
 tree-sitter-gowork = { git = "https://github.com/d1y/tree-sitter-go-work" }
-tree-sitter-haskell = { git = "https://github.com/tree-sitter/tree-sitter-haskell", rev = "8a99848fc734f9c4ea523b3f2a07df133cbbcec2" }
 tree-sitter-hcl = { git = "https://github.com/MichaHoffmann/tree-sitter-hcl", rev = "v1.1.0" }
 rustc-demangle = "0.1.23"
 tree-sitter-heex = { git = "https://github.com/phoenixframework/tree-sitter-heex", rev = "2e1348c3cf2c9323e87c2744796cf3f3868aa82a" }
@@ -310,38 +328,32 @@ tree-sitter-markdown = { git = "https://github.com/MDeiml/tree-sitter-markdown",
 tree-sitter-nix = { git = "https://github.com/nix-community/tree-sitter-nix", rev = "66e3e9ce9180ae08fc57372061006ef83f0abde7" }
 tree-sitter-nu = { git = "https://github.com/nushell/tree-sitter-nu", rev = "7dd29f9616822e5fc259f5b4ae6c4ded9a71a132" }
 tree-sitter-ocaml = { git = "https://github.com/tree-sitter/tree-sitter-ocaml", rev = "4abfdc1c7af2c6c77a370aee974627be1c285b3b" }
-tree-sitter-php = "0.21.1"
-tree-sitter-prisma-io = { git = "https://github.com/victorhqc/tree-sitter-prisma" }
 tree-sitter-proto = { git = "https://github.com/rewinfrey/tree-sitter-proto", rev = "36d54f288aee112f13a67b550ad32634d0c2cb52" }
-tree-sitter-purescript = { git = "https://github.com/postsolar/tree-sitter-purescript", rev = "v0.1.0" }
 tree-sitter-python = "0.20.2"
 tree-sitter-racket = { git = "https://github.com/zed-industries/tree-sitter-racket", rev = "eb010cf2c674c6fd9a6316a84e28ef90190fe51a" }
 tree-sitter-regex = "0.20.0"
 tree-sitter-ruby = "0.20.0"
 tree-sitter-rust = "0.20.3"
 tree-sitter-scheme = { git = "https://github.com/6cdh/tree-sitter-scheme", rev = "af0fd1fa452cb2562dc7b5c8a8c55551c39273b9" }
-tree-sitter-svelte = { git = "https://github.com/Himujjal/tree-sitter-svelte", rev = "bd60db7d3d06f89b6ec3b287c9a6e9190b5564bd" }
-tree-sitter-toml = { git = "https://github.com/tree-sitter/tree-sitter-toml", rev = "342d9be207c2dba869b9967124c679b5e6fd0ebe" }
 tree-sitter-typescript = { git = "https://github.com/tree-sitter/tree-sitter-typescript", rev = "5d20856f34315b068c41edaee2ac8a100081d259" }
 tree-sitter-vue = { git = "https://github.com/zed-industries/tree-sitter-vue", rev = "6608d9d60c386f19d80af7d8132322fa11199c42" }
 tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "f545a41f57502e1b5ddf2a6668896c1b0620f930" }
-tree-sitter-zig = { git = "https://github.com/maxxnino/tree-sitter-zig", rev = "0d08703e4c3f426ec61695d7617415fff97029bd" }
 unindent = "0.1.7"
 unicase = "2.6"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4"] }
-wasmparser = "0.121"
-wasm-encoder = "0.41"
-wasmtime = { version = "18.0", default-features = false, features = [
+wasmparser = "0.201"
+wasm-encoder = "0.201"
+wasmtime = { version = "19.0.0", default-features = false, features = [
    "async",
    "demangle",
    "runtime",
    "cranelift",
    "component-model",
 ] }
-wasmtime-wasi = "18.0"
+wasmtime-wasi = "19.0.0"
 which = "6.0.0"
-wit-component = "0.20"
+wit-component = "0.201"
 sys-locale = "0.3.1"

 [workspace.dependencies.windows]
@@ -375,7 +387,7 @@ features = [
 ]

 [patch.crates-io]
-tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "4294e59279205f503eb14348dd5128bd5910c8fb" }
+tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "7f21c3b98c0749ac192da67a0d65dfe3eabc4a63" }
 # Workaround for a broken nightly build of gpui: See #7644 and revisit once 0.5.3 is released.
 pathfinder_simd = { git = "https://github.com/servo/pathfinder.git", rev = "30419d07660dc11a21e42ef4a7fa329600cff152" }

@@ -386,9 +398,11 @@ debug = "limited"
 [profile.dev.package]
 taffy = { opt-level = 3 }
 cranelift-codegen = { opt-level = 3 }
+resvg = { opt-level = 3 }
 rustybuzz = { opt-level = 3 }
 ttf-parser = { opt-level = 3 }
 wasmtime-cranelift = { opt-level = 3 }
+wasmtime = { opt-level = 3 }

 [profile.release]
 debug = "limited"
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 # syntax = docker/dockerfile:1.2

-FROM rust:1.76-bookworm as builder
+FROM rust:1.77-bookworm as builder
 WORKDIR app
 COPY . .

--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -1,4 +1,6 @@
 [
+  // todo(linux): Review the editor bindings
+  // Standard Linux bindings
  {
    "bindings": {
      "up": "menu::SelectPrev",
@@ -9,14 +11,14 @@
      "pagedown": "menu::SelectLast",
      "shift-pagedown": "menu::SelectFirst",
      "ctrl-n": "menu::SelectNext",
-      "ctrl-up": "menu::SelectFirst",
-      "ctrl-down": "menu::SelectLast",
      "enter": "menu::Confirm",
-      "shift-f10": "menu::ShowContextMenu",
      "ctrl-enter": "menu::SecondaryConfirm",
      "escape": "menu::Cancel",
+      "ctrl-escape": "menu::Cancel",
      "ctrl-c": "menu::Cancel",
-      "shift-enter": "menu::UseSelectedQuery",
+      "shift-enter": "picker::UseSelectedQuery",
+      "alt-enter": ["picker::ConfirmInput", { "secondary": false }],
+      "ctrl-alt-enter": ["picker::ConfirmInput", { "secondary": true }],
      "ctrl-shift-w": "workspace::CloseWindow",
      "shift-escape": "workspace::ToggleZoom",
      "ctrl-o": "workspace::Open",
@@ -26,9 +28,7 @@
      "ctrl-0": "zed::ResetBufferFontSize",
      "ctrl-,": "zed::OpenSettings",
      "ctrl-q": "zed::Quit",
-      "ctrl-h": "zed::Hide",
-      "alt-ctrl-h": "zed::HideOthers",
-      "ctrl-m": "zed::Minimize",
+      "alt-f9": "zed::Hide",
      "f11": "zed::ToggleFullScreen"
    }
  },
@@ -38,87 +38,107 @@
      "escape": "editor::Cancel",
      "backspace": "editor::Backspace",
      "shift-backspace": "editor::Backspace",
-      "ctrl-h": "editor::Backspace",
      "delete": "editor::Delete",
      "ctrl-d": "editor::Delete",
      "tab": "editor::Tab",
      "shift-tab": "editor::TabPrev",
      "ctrl-k": "editor::CutToEndOfLine",
      "ctrl-t": "editor::Transpose",
-      "ctrl-backspace": "editor::DeleteToBeginningOfLine",
-      "ctrl-delete": "editor::DeleteToEndOfLine",
-      "alt-backspace": "editor::DeleteToPreviousWordStart",
-      "alt-delete": "editor::DeleteToNextWordEnd",
-      "alt-h": "editor::DeleteToPreviousWordStart",
-      "alt-d": "editor::DeleteToNextWordEnd",
+      // "ctrl-backspace": "editor::DeleteToBeginningOfLine",
+      // "ctrl-delete": "editor::DeleteToEndOfLine",
+      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
+      // "ctrl-w": "editor::DeleteToPreviousWordStart",
+      "ctrl-delete": "editor::DeleteToNextWordEnd",
+      // "alt-h": "editor::DeleteToPreviousWordStart",
+      // "alt-d": "editor::DeleteToNextWordEnd",
      "ctrl-x": "editor::Cut",
      "ctrl-c": "editor::Copy",
      "ctrl-v": "editor::Paste",
      "ctrl-z": "editor::Undo",
      "ctrl-shift-z": "editor::Redo",
-      "ctrl-y": "editor::Redo",
      "up": "editor::MoveUp",
-      "ctrl-up": "editor::MoveToStartOfParagraph",
+      // "ctrl-up": "editor::MoveToStartOfParagraph", todo(linux) Should be "scroll down by 1 line"
      "pageup": "editor::PageUp",
-      "shift-pageup": "editor::MovePageUp",
+      // "shift-pageup": "editor::MovePageUp", todo(linux) should be 'select page up'
      "home": "editor::MoveToBeginningOfLine",
      "down": "editor::MoveDown",
-      "ctrl-down": "editor::MoveToEndOfParagraph",
+      // "ctrl-down": "editor::MoveToEndOfParagraph", todo(linux) should be "scroll up by 1 line"
      "pagedown": "editor::PageDown",
-      "shift-pagedown": "editor::MovePageDown",
+      // "shift-pagedown": "editor::MovePageDown", todo(linux) should be 'select page down'
      "end": "editor::MoveToEndOfLine",
      "left": "editor::MoveLeft",
      "right": "editor::MoveRight",
-      "ctrl-p": "editor::MoveUp",
-      "ctrl-n": "editor::MoveDown",
-      "ctrl-b": "editor::MoveLeft",
-      "ctrl-f": "editor::MoveRight",
-      "ctrl-shift-l": "editor::NextScreen", // todo(linux): What is this
-      "alt-left": "editor::MoveToPreviousWordStart",
-      "alt-b": "editor::MoveToPreviousWordStart",
-      "alt-right": "editor::MoveToNextWordEnd",
-      "alt-f": "editor::MoveToNextWordEnd",
-      "ctrl-e": "editor::MoveToEndOfLine",
+      "ctrl-left": "editor::MoveToPreviousWordStart",
+      // "alt-b": "editor::MoveToPreviousWordStart",
+      "ctrl-right": "editor::MoveToNextWordEnd",
+      // "alt-f": "editor::MoveToNextWordEnd",
+      // "cmd-left": "editor::MoveToBeginningOfLine",
+      // "ctrl-a": "editor::MoveToBeginningOfLine",
+      // "cmd-right": "editor::MoveToEndOfLine",
+      // "ctrl-e": "editor::MoveToEndOfLine",
      "ctrl-home": "editor::MoveToBeginning",
-      "ctrl-=end": "editor::MoveToEnd",
+      "ctrl-end": "editor::MoveToEnd",
      "shift-up": "editor::SelectUp",
      "shift-down": "editor::SelectDown",
-      "ctrl-shift-n": "editor::SelectDown",
      "shift-left": "editor::SelectLeft",
-      "ctrl-shift-b": "editor::SelectLeft",
      "shift-right": "editor::SelectRight",
-      "ctrl-shift-f": "editor::SelectRight",
-      "alt-shift-left": "editor::SelectToPreviousWordStart",
-      "alt-shift-b": "editor::SelectToPreviousWordStart",
-      "alt-shift-right": "editor::SelectToNextWordEnd",
-      "alt-shift-f": "editor::SelectToNextWordEnd",
-      "ctrl-shift-up": "editor::SelectToStartOfParagraph",
-      "ctrl-shift-down": "editor::SelectToEndOfParagraph",
+      "ctrl-shift-left": "editor::SelectToPreviousWordStart",
+      "ctrl-shift-right": "editor::SelectToNextWordEnd",
+      "ctrl-shift-up": "editor::AddSelectionAbove",
+      "ctrl-shift-down": "editor::AddSelectionBelow",
+      // "ctrl-shift-up": "editor::SelectToStartOfParagraph",
+      // "ctrl-shift-down": "editor::SelectToEndOfParagraph",
      "ctrl-shift-home": "editor::SelectToBeginning",
      "ctrl-shift-end": "editor::SelectToEnd",
      "ctrl-a": "editor::SelectAll",
      "ctrl-l": "editor::SelectLine",
      "ctrl-shift-i": "editor::Format",
+      // "cmd-shift-left": [
+      //   "editor::SelectToBeginningOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
      "shift-home": [
        "editor::SelectToBeginningOfLine",
        {
          "stop_at_soft_wraps": true
        }
      ],
+      // "ctrl-shift-a": [
+      //   "editor::SelectToBeginningOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
+      // "cmd-shift-right": [
+      //   "editor::SelectToEndOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
      "shift-end": [
        "editor::SelectToEndOfLine",
        {
          "stop_at_soft_wraps": true
        }
      ],
-      "ctrl-shift-e": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
+      // "ctrl-shift-e": [
+      //   "editor::SelectToEndOfLine",
+      //   {
+      //     "stop_at_soft_wraps": true
+      //   }
+      // ],
+      // "alt-v": [
+      //   "editor::MovePageUp",
+      //   {
+      //     "center_cursor": true
+      //   }
+      // ],
+      "ctrl-alt-space": "editor::ShowCharacterPalette",
      "ctrl-;": "editor::ToggleLineNumbers",
-      "ctrl-alt-z": "editor::RevertSelectedHunks"
+      "ctrl-k ctrl-r": "editor::RevertSelectedHunks",
+      "ctrl-alt-g b": "editor::ToggleGitBlame"
    }
  },
  {
@@ -126,30 +146,37 @@
    "bindings": {
      "enter": "editor::Newline",
      "shift-enter": "editor::Newline",
-      "ctrl-shift-enter": "editor::NewlineAbove",
-      "ctrl-enter": "editor::NewlineBelow",
+      "ctrl-shift-enter": "editor::NewlineBelow",
+      "ctrl-enter": "editor::NewlineAbove",
      "alt-z": "editor::ToggleSoftWrap",
-      "ctrl-f": [
+      "ctrl-f": "buffer_search::Deploy",
+      "ctrl-h": [
        "buffer_search::Deploy",
        {
-          "focus": true
+          "replace_enabled": true
        }
      ],
+      // "cmd-e": [
+      //   "buffer_search::Deploy",
+      //   {
+      //     "focus": false
+      //   }
+      // ],
      "ctrl->": "assistant::QuoteSelection"
    }
  },
  {
-    "context": "Editor && mode == full && copilot_suggestion",
+    "context": "Editor && mode == full && inline_completion",
    "bindings": {
-      "alt-]": "copilot::NextSuggestion",
-      "alt-[": "copilot::PreviousSuggestion",
-      "alt-right": "editor::AcceptPartialCopilotSuggestion"
+      "alt-]": "editor::NextInlineCompletion",
+      "alt-[": "editor::PreviousInlineCompletion",
+      "alt-right": "editor::AcceptPartialInlineCompletion"
    }
  },
  {
-    "context": "Editor && !copilot_suggestion",
+    "context": "Editor && !inline_completion",
    "bindings": {
-      "alt-\\": "copilot::Suggest"
+      "alt-\\": "editor::ShowInlineCompletion"
    }
  },
  {
@@ -163,8 +190,8 @@
  {
    "context": "AssistantPanel",
    "bindings": {
-      "f3": "search::SelectNextMatch",
-      "shift-f3": "search::SelectPrevMatch"
+      "ctrl-g": "search::SelectNextMatch",
+      "ctrl-shift-g": "search::SelectPrevMatch"
    }
  },
  {
@@ -185,7 +212,9 @@
      "enter": "search::SelectNextMatch",
      "shift-enter": "search::SelectPrevMatch",
      "alt-enter": "search::SelectAllMatches",
-      "alt-tab": "search::CycleMode"
+      "alt-tab": "search::CycleMode",
+      "ctrl-f": "search::FocusSearch",
+      "ctrl-h": "search::ToggleReplace"
    }
  },
  {
@@ -207,10 +236,10 @@
    "bindings": {
      "escape": "project_search::ToggleFocus",
      "alt-tab": "search::CycleMode",
+      "ctrl-shift-f": "search::FocusSearch",
      "ctrl-shift-h": "search::ToggleReplace",
-      "ctrl-alt-g": "search::ActivateRegexMode",
-      "ctrl-alt-s": "search::ActivateSemanticMode",
-      "ctrl-alt-x": "search::ActivateTextMode"
+      "alt-ctrl-g": "search::ActivateRegexMode",
+      "alt-ctrl-x": "search::ActivateTextMode"
    }
  },
  {
@@ -224,7 +253,7 @@
    "context": "ProjectSearchBar && in_replace",
    "bindings": {
      "enter": "search::ReplaceNext",
-      "ctrl-enter": "search::ReplaceAll"
+      "ctrl-alt-enter": "search::ReplaceAll"
    }
  },
  {
@@ -233,35 +262,31 @@
      "escape": "project_search::ToggleFocus",
      "alt-tab": "search::CycleMode",
      "ctrl-shift-h": "search::ToggleReplace",
-      "ctrl-alt-g": "search::ActivateRegexMode",
-      "ctrl-alt-s": "search::ActivateSemanticMode",
-      "ctrl-alt-x": "search::ActivateTextMode"
+      "alt-ctrl-g": "search::ActivateRegexMode",
+      "alt-ctrl-x": "search::ActivateTextMode"
    }
  },
  {
    "context": "Pane",
    "bindings": {
-      "ctrl-{": "pane::ActivatePrevItem",
-      "ctrl-}": "pane::ActivateNextItem",
-      "ctrl-alt-left": "pane::ActivatePrevItem",
-      "ctrl-alt-right": "pane::ActivateNextItem",
+      "ctrl-pageup": "pane::ActivatePrevItem",
+      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-w": "pane::CloseActiveItem",
-      "ctrl-alt-t": "pane::CloseInactiveItems",
-      "ctrl-alt-shift-w": "workspace::CloseInactiveTabsAndPanes",
+      "alt-ctrl-t": "pane::CloseInactiveItems",
+      "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-k u": "pane::CloseCleanItems",
-      "ctrl-k ctrl-w": "pane::CloseAllItems",
-      "ctrl-f": "project_search::ToggleFocus",
-      "f3": "search::SelectNextMatch",
-      "shift-f3": "search::SelectPrevMatch",
-      "ctrl-shift-h": "search::ToggleReplace",
+      "ctrl-k w": "pane::CloseAllItems",
+      "ctrl-shift-f": "project_search::ToggleFocus",
+      "ctrl-alt-g": "search::SelectNextMatch",
+      "ctrl-alt-shift-g": "search::SelectPrevMatch",
+      "ctrl-alt-shift-h": "search::ToggleReplace",
      "alt-enter": "search::SelectAllMatches",
-      "ctrl-alt-c": "search::ToggleCaseSensitive",
-      "ctrl-alt-w": "search::ToggleWholeWord",
-      "alt-tab": "search::CycleMode",
-      "ctrl-alt-f": "project_search::ToggleFilters",
-      "ctrl-alt-g": "search::ActivateRegexMode",
-      "ctrl-alt-s": "search::ActivateSemanticMode",
-      "ctrl-alt-x": "search::ActivateTextMode"
+      "alt-c": "search::ToggleCaseSensitive",
+      "alt-w": "search::ToggleWholeWord",
+      "alt-r": "search::CycleMode",
+      "alt-ctrl-f": "project_search::ToggleFilters",
+      "ctrl-alt-shift-r": "search::ActivateRegexMode",
+      "ctrl-alt-shift-x": "search::ActivateTextMode"
    }
  },
  // Bindings from VS Code
@@ -270,8 +295,22 @@
    "bindings": {
      "ctrl-[": "editor::Outdent",
      "ctrl-]": "editor::Indent",
-      "ctrl-alt-up": "editor::AddSelectionAbove",
-      "ctrl-alt-down": "editor::AddSelectionBelow",
+      "shift-alt-up": "editor::AddSelectionAbove",
+      "shift-alt-down": "editor::AddSelectionBelow",
+      "ctrl-shift-k": "editor::DeleteLine",
+      "alt-up": "editor::MoveLineUp",
+      "alt-down": "editor::MoveLineDown",
+      "ctrl-alt-shift-up": [
+        "editor::DuplicateLine",
+        {
+          "move_upwards": true
+        }
+      ],
+      "ctrl-alt-shift-down": "editor::DuplicateLine",
+      "ctrl-shift-left": "editor::SelectToPreviousWordStart",
+      "ctrl-shift-right": "editor::SelectToNextWordEnd",
+      "ctrl-shift-up": "editor::SelectLargerSyntaxNode", //todo(linux) tmp keybinding
+      "ctrl-shift-down": "editor::SelectSmallerSyntaxNode", //todo(linux) tmp keybinding
      "ctrl-d": [
        "editor::SelectNext",
        {
@@ -304,8 +343,6 @@
          "advance_downwards": false
        }
      ],
-      "alt-up": "editor::SelectLargerSyntaxNode",
-      "alt-down": "editor::SelectSmallerSyntaxNode",
      "ctrl-u": "editor::UndoSelection",
      "ctrl-shift-u": "editor::RedoSelection",
      "f8": "editor::GoToDiagnostic",
@@ -314,15 +351,16 @@
      "f12": "editor::GoToDefinition",
      "alt-f12": "editor::GoToDefinitionSplit",
      "ctrl-f12": "editor::GoToTypeDefinition",
-      "ctrl-alt-f12": "editor::GoToTypeDefinitionSplit",
+      "shift-f12": "editor::GoToImplementation",
+      "alt-ctrl-f12": "editor::GoToTypeDefinitionSplit",
      "alt-shift-f12": "editor::FindAllReferences",
      "ctrl-m": "editor::MoveToEnclosingBracket",
-      "ctrl-alt-[": "editor::Fold",
-      "ctrl-alt-]": "editor::UnfoldLines",
+      "ctrl-shift-[": "editor::Fold",
+      "ctrl-shift-]": "editor::UnfoldLines",
      "ctrl-space": "editor::ShowCompletions",
      "ctrl-.": "editor::ToggleCodeActions",
-      "ctrl-alt-r": "editor::RevealInFinder",
-      "ctrl-alt-c": "editor::DisplayCursorNames"
+      "alt-ctrl-r": "editor::RevealInFinder",
+      "ctrl-alt-shift-c": "editor::DisplayCursorNames"
    }
  },
  {
@@ -335,18 +373,18 @@
  {
    "context": "Pane",
    "bindings": {
-      "ctrl-1": ["pane::ActivateItem", 0],
-      "ctrl-2": ["pane::ActivateItem", 1],
-      "ctrl-3": ["pane::ActivateItem", 2],
-      "ctrl-4": ["pane::ActivateItem", 3],
-      "ctrl-5": ["pane::ActivateItem", 4],
-      "ctrl-6": ["pane::ActivateItem", 5],
-      "ctrl-7": ["pane::ActivateItem", 6],
-      "ctrl-8": ["pane::ActivateItem", 7],
-      "ctrl-9": ["pane::ActivateItem", 8],
-      "ctrl-0": "pane::ActivateLastItem",
-      "ctrl--": "pane::GoBack",
-      "ctrl-_": "pane::GoForward",
+      "alt-1": ["pane::ActivateItem", 0],
+      "alt-2": ["pane::ActivateItem", 1],
+      "alt-3": ["pane::ActivateItem", 2],
+      "alt-4": ["pane::ActivateItem", 3],
+      "alt-5": ["pane::ActivateItem", 4],
+      "alt-6": ["pane::ActivateItem", 5],
+      "alt-7": ["pane::ActivateItem", 6],
+      "alt-8": ["pane::ActivateItem", 7],
+      "alt-9": ["pane::ActivateItem", 8],
+      "alt-0": "pane::ActivateLastItem",
+      "ctrl-alt--": "pane::GoBack",
+      "ctrl-alt-_": "pane::GoForward",
      "ctrl-shift-t": "pane::ReopenClosedItem",
      "ctrl-shift-f": "project_search::ToggleFocus"
    }
@@ -361,8 +399,8 @@
      //         "create_new_window": true
      //     }
      // ]
-      "ctrl-alt-o": "projects::OpenRecent",
-      "ctrl-alt-b": "branches::OpenRecent",
+      "alt-ctrl-o": "projects::OpenRecent",
+      "alt-ctrl-shift-b": "branches::OpenRecent",
      "ctrl-~": "workspace::NewTerminal",
      "ctrl-s": "workspace::Save",
      "ctrl-k s": "workspace::SaveWithoutFormat",
@@ -370,24 +408,33 @@
      "ctrl-n": "workspace::NewFile",
      "ctrl-shift-n": "workspace::NewWindow",
      "ctrl-`": "terminal_panel::ToggleFocus",
-      "ctrl-1": ["workspace::ActivatePane", 0],
-      "ctrl-2": ["workspace::ActivatePane", 1],
-      "ctrl-3": ["workspace::ActivatePane", 2],
-      "ctrl-4": ["workspace::ActivatePane", 3],
-      "ctrl-5": ["workspace::ActivatePane", 4],
-      "ctrl-6": ["workspace::ActivatePane", 5],
-      "ctrl-7": ["workspace::ActivatePane", 6],
-      "ctrl-8": ["workspace::ActivatePane", 7],
-      "ctrl-9": ["workspace::ActivatePane", 8],
-      "ctrl-b": "workspace::ToggleLeftDock",
-      "ctrl-r": "workspace::ToggleRightDock",
+      "alt-1": ["workspace::ActivatePane", 0],
+      "alt-2": ["workspace::ActivatePane", 1],
+      "alt-3": ["workspace::ActivatePane", 2],
+      "alt-4": ["workspace::ActivatePane", 3],
+      "alt-5": ["workspace::ActivatePane", 4],
+      "alt-6": ["workspace::ActivatePane", 5],
+      "alt-7": ["workspace::ActivatePane", 6],
+      "alt-8": ["workspace::ActivatePane", 7],
+      "alt-9": ["workspace::ActivatePane", 8],
+      "ctrl-alt-b": "workspace::ToggleLeftDock",
+      "ctrl-b": "workspace::ToggleRightDock",
      "ctrl-j": "workspace::ToggleBottomDock",
      "ctrl-alt-y": "workspace::CloseAllDocks",
      "ctrl-shift-f": "pane::DeploySearch",
-      "ctrl-k ctrl-t": "theme_selector::Toggle",
+      "ctrl-shift-h": [
+        "pane::DeploySearch",
+        {
+          "replace_enabled": true
+        }
+      ],
      "ctrl-k ctrl-s": "zed::OpenKeymap",
-      "ctrl-t": "project_symbols::Toggle",
+      "ctrl-k ctrl-t": "theme_selector::Toggle",
+      "ctrl-shift-t": "project_symbols::Toggle",
      "ctrl-p": "file_finder::Toggle",
+      "ctrl-tab": "tab_switcher::Toggle",
+      "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
+      "ctrl-e": "file_finder::Toggle",
      "ctrl-shift-p": "command_palette::Toggle",
      "ctrl-shift-m": "diagnostics::Deploy",
      "ctrl-shift-e": "project_panel::ToggleFocus",
@@ -408,15 +455,12 @@
    }
  },
  // Bindings from Sublime Text
-  // todo(linux) make sure these match linux bindings or remove above comment?
  {
    "context": "Editor",
    "bindings": {
      "ctrl-shift-k": "editor::DeleteLine",
-      "ctrl-shift-d": "editor::DuplicateLine",
+      "ctrl-shift-d": "editor::DuplicateLineDown",
      "ctrl-j": "editor::JoinLines",
-      "ctrl-alt-up": "editor::MoveLineUp",
-      "ctrl-alt-down": "editor::MoveLineDown",
      "ctrl-alt-backspace": "editor::DeleteToPreviousSubwordStart",
      "ctrl-alt-h": "editor::DeleteToPreviousSubwordStart",
      "ctrl-alt-delete": "editor::DeleteToNextSubwordEnd",
@@ -432,7 +476,6 @@
    }
  },
  // Bindings from Atom
-  // todo(linux) make sure these match linux bindings or remove above comment?
  {
    "context": "Pane",
    "bindings": {
@@ -478,7 +521,7 @@
    "bindings": {
      "ctrl-alt-shift-f": "workspace::FollowNextCollaborator",
      // TODO: Move this to a dock open action
-      "ctrl-alt-c": "collab_panel::ToggleFocus",
+      "ctrl-shift-c": "collab_panel::ToggleFocus",
      "ctrl-alt-i": "zed::DebugElements",
      "ctrl-:": "editor::ToggleInlayHints"
    }
@@ -505,19 +548,19 @@
      "left": "project_panel::CollapseSelectedEntry",
      "right": "project_panel::ExpandSelectedEntry",
      "ctrl-n": "project_panel::NewFile",
-      "ctrl-alt-n": "project_panel::NewDirectory",
+      "alt-ctrl-n": "project_panel::NewDirectory",
      "ctrl-x": "project_panel::Cut",
      "ctrl-c": "project_panel::Copy",
      "ctrl-v": "project_panel::Paste",
      "ctrl-alt-c": "project_panel::CopyPath",
-      "ctrl-alt-shift-c": "project_panel::CopyRelativePath",
+      "alt-ctrl-shift-c": "project_panel::CopyRelativePath",
      "f2": "project_panel::Rename",
      "enter": "project_panel::Rename",
      "backspace": "project_panel::Delete",
      "delete": "project_panel::Delete",
      "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": true }],
      "ctrl-delete": ["project_panel::Delete", { "skip_prompt": true }],
-      "ctrl-alt-r": "project_panel::RevealInFinder",
+      "alt-ctrl-r": "project_panel::RevealInFinder",
      "alt-shift-f": "project_panel::NewSearchInDirectory"
    }
  },
@@ -558,29 +601,35 @@
      "escape": "chat_panel::CloseReplyPreview"
    }
  },
+  {
+    "context": "FileFinder",
+    "bindings": { "ctrl-shift-p": "file_finder::SelectPrev" }
+  },
+  {
+    "context": "TabSwitcher",
+    "bindings": {
+      "ctrl-shift-tab": "menu::SelectPrev",
+      "ctrl-backspace": "tab_switcher::CloseSelectedItem"
+    }
+  },
  {
    "context": "Terminal",
    "bindings": {
      "ctrl-alt-space": "terminal::ShowCharacterPalette",
-      "ctrl-shift-c": "terminal::Copy",
-      "ctrl-shift-v": "terminal::Paste",
-      "ctrl-k": "terminal::Clear",
-      // Some nice conveniences
-      "ctrl-backspace": ["terminal::SendText", "\u0015"],
-      "ctrl-right": ["terminal::SendText", "\u0005"],
-      "ctrl-left": ["terminal::SendText", "\u0001"],
-      // Terminal.app compatibility
-      "alt-left": ["terminal::SendText", "\u001bb"],
-      "alt-right": ["terminal::SendText", "\u001bf"],
-      // There are conflicting bindings for these keys in the global context.
-      // these bindings override them, remove at your own risk:
+      "shift-ctrl-c": "terminal::Copy",
+      "shift-ctrl-v": "terminal::Paste",
      "up": ["terminal::SendKeystroke", "up"],
      "pageup": ["terminal::SendKeystroke", "pageup"],
      "down": ["terminal::SendKeystroke", "down"],
      "pagedown": ["terminal::SendKeystroke", "pagedown"],
      "escape": ["terminal::SendKeystroke", "escape"],
      "enter": ["terminal::SendKeystroke", "enter"],
-      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"]
+      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
+
+      // Some nice conveniences
+      "ctrl-backspace": ["terminal::SendText", "\u0015"],
+      "ctrl-right": ["terminal::SendText", "\u0005"],
+      "ctrl-left": ["terminal::SendText", "\u0001"]
    }
  }
 ]
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -13,11 +13,15 @@
      "cmd-up": "menu::SelectFirst",
      "cmd-down": "menu::SelectLast",
      "enter": "menu::Confirm",
-      "ctrl-enter": "menu::ShowContextMenu",
+      "ctrl-enter": "menu::SecondaryConfirm",
      "cmd-enter": "menu::SecondaryConfirm",
      "escape": "menu::Cancel",
+      "cmd-escape": "menu::Cancel",
+      "ctrl-escape": "menu::Cancel",
      "ctrl-c": "menu::Cancel",
-      "shift-enter": "menu::UseSelectedQuery",
+      "shift-enter": "picker::UseSelectedQuery",
+      "alt-enter": ["picker::ConfirmInput", { "secondary": false }],
+      "cmd-alt-enter": ["picker::ConfirmInput", { "secondary": true }],
      "cmd-shift-w": "workspace::CloseWindow",
      "shift-escape": "workspace::ToggleZoom",
      "cmd-o": "workspace::Open",
@@ -154,7 +158,8 @@
      ],
      "ctrl-cmd-space": "editor::ShowCharacterPalette",
      "cmd-;": "editor::ToggleLineNumbers",
-      "cmd-alt-z": "editor::RevertSelectedHunks"
+      "cmd-alt-z": "editor::RevertSelectedHunks",
+      "cmd-alt-g b": "editor::ToggleGitBlame"
    }
  },
  {
@@ -165,10 +170,11 @@
      "cmd-shift-enter": "editor::NewlineAbove",
      "cmd-enter": "editor::NewlineBelow",
      "alt-z": "editor::ToggleSoftWrap",
-      "cmd-f": [
+      "cmd-f": "buffer_search::Deploy",
+      "cmd-alt-f": [
        "buffer_search::Deploy",
        {
-          "focus": true
+          "replace_enabled": true
        }
      ],
      "cmd-e": [
@@ -181,17 +187,17 @@
    }
  },
  {
-    "context": "Editor && mode == full && copilot_suggestion",
+    "context": "Editor && mode == full && inline_completion",
    "bindings": {
-      "alt-]": "copilot::NextSuggestion",
-      "alt-[": "copilot::PreviousSuggestion",
-      "alt-right": "editor::AcceptPartialCopilotSuggestion"
+      "alt-]": "editor::NextInlineCompletion",
+      "alt-[": "editor::PreviousInlineCompletion",
+      "alt-right": "editor::AcceptPartialInlineCompletion"
    }
  },
  {
-    "context": "Editor && !copilot_suggestion",
+    "context": "Editor && !inline_completion",
    "bindings": {
-      "alt-\\": "copilot::Suggest"
+      "alt-\\": "editor::ShowInlineCompletion"
    }
  },
  {
@@ -227,7 +233,9 @@
      "enter": "search::SelectNextMatch",
      "shift-enter": "search::SelectPrevMatch",
      "alt-enter": "search::SelectAllMatches",
-      "alt-tab": "search::CycleMode"
+      "alt-tab": "search::CycleMode",
+      "cmd-f": "search::FocusSearch",
+      "cmd-alt-f": "search::ToggleReplace"
    }
  },
  {
@@ -249,6 +257,7 @@
    "bindings": {
      "escape": "project_search::ToggleFocus",
      "alt-tab": "search::CycleMode",
+      "cmd-shift-f": "search::FocusSearch",
      "cmd-shift-h": "search::ToggleReplace",
      "alt-cmd-g": "search::ActivateRegexMode",
      "alt-cmd-x": "search::ActivateTextMode"
@@ -316,13 +325,8 @@
      "cmd-shift-k": "editor::DeleteLine",
      "alt-up": "editor::MoveLineUp",
      "alt-down": "editor::MoveLineDown",
-      "alt-shift-up": [
-        "editor::DuplicateLine",
-        {
-          "move_upwards": true
-        }
-      ],
-      "alt-shift-down": "editor::DuplicateLine",
+      "alt-shift-up": "editor::DuplicateLineUp",
+      "alt-shift-down": "editor::DuplicateLineDown",
      "ctrl-shift-right": "editor::SelectLargerSyntaxNode",
      "ctrl-shift-left": "editor::SelectSmallerSyntaxNode",
      "cmd-d": [
@@ -365,6 +369,7 @@
      "f12": "editor::GoToDefinition",
      "alt-f12": "editor::GoToDefinitionSplit",
      "cmd-f12": "editor::GoToTypeDefinition",
+      "shift-f12": "editor::GoToImplementation",
      "alt-cmd-f12": "editor::GoToTypeDefinitionSplit",
      "alt-shift-f12": "editor::FindAllReferences",
      "ctrl-m": "editor::MoveToEnclosingBracket",
@@ -435,10 +440,18 @@
      "cmd-j": "workspace::ToggleBottomDock",
      "alt-cmd-y": "workspace::CloseAllDocks",
      "cmd-shift-f": "pane::DeploySearch",
+      "cmd-shift-h": [
+        "pane::DeploySearch",
+        {
+          "replace_enabled": true
+        }
+      ],
      "cmd-k cmd-s": "zed::OpenKeymap",
      "cmd-k cmd-t": "theme_selector::Toggle",
      "cmd-t": "project_symbols::Toggle",
      "cmd-p": "file_finder::Toggle",
+      "ctrl-tab": "tab_switcher::Toggle",
+      "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
      "cmd-shift-p": "command_palette::Toggle",
      "cmd-shift-m": "diagnostics::Deploy",
      "cmd-shift-e": "project_panel::ToggleFocus",
@@ -597,6 +610,17 @@
      "tab": "channel_modal::ToggleMode"
    }
  },
+  {
+    "context": "FileFinder",
+    "bindings": { "cmd-shift-p": "file_finder::SelectPrev" }
+  },
+  {
+    "context": "TabSwitcher",
+    "bindings": {
+      "ctrl-shift-tab": "menu::SelectPrev",
+      "ctrl-backspace": "tab_switcher::CloseSelectedItem"
+    }
+  },
  {
    "context": "Terminal",
    "bindings": {
--- a/assets/keymaps/jetbrains.json
+++ b/assets/keymaps/jetbrains.json
@@ -11,7 +11,7 @@
      "ctrl->": "zed::IncreaseBufferFontSize",
      "ctrl-<": "zed::DecreaseBufferFontSize",
      "ctrl-shift-j": "editor::JoinLines",
-      "cmd-d": "editor::DuplicateLine",
+      "cmd-d": "editor::DuplicateLineDown",
      "cmd-backspace": "editor::DeleteLine",
      "cmd-pagedown": "editor::MovePageDown",
      "cmd-pageup": "editor::MovePageUp",
--- a/assets/keymaps/storybook.json
+++ b/assets/keymaps/storybook.json
@@ -13,7 +13,7 @@
      "cmd-up": "menu::SelectFirst",
      "cmd-down": "menu::SelectLast",
      "enter": "menu::Confirm",
-      "ctrl-enter": "menu::ShowContextMenu",
+      "ctrl-enter": "menu::SecondaryConfirm",
      "cmd-enter": "menu::SecondaryConfirm",
      "escape": "menu::Cancel",
      "ctrl-c": "menu::Cancel",
--- a/assets/keymaps/textmate.json
+++ b/assets/keymaps/textmate.json
@@ -9,7 +9,7 @@
    "context": "Editor",
    "bindings": {
      "cmd-l": "go_to_line::Toggle",
-      "ctrl-shift-d": "editor::DuplicateLine",
+      "ctrl-shift-d": "editor::DuplicateLineDown",
      "cmd-b": "editor::GoToDefinition",
      "cmd-j": "editor::ScrollCursorCenter",
      "cmd-enter": "editor::NewlineBelow",
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -73,8 +73,17 @@
      ],
      "g shift-e": ["vim::PreviousWordEnd", { "ignorePunctuation": true }],

-      "n": "search::SelectNextMatch",
-      "shift-n": "search::SelectPrevMatch",
+      "/": "vim::Search",
+      "?": [
+        "vim::Search",
+        {
+          "backwards": true
+        }
+      ],
+      "*": "vim::MoveToNext",
+      "#": "vim::MoveToPrev",
+      "n": "vim::MoveToNextMatch",
+      "shift-n": "vim::MoveToPrevMatch",
      "%": "vim::Matching",
      "f": [
        "vim::PushOperator",
@@ -137,8 +146,10 @@
      "g d": "editor::GoToDefinition",
      "g shift-d": "editor::GoToTypeDefinition",
      "g x": "editor::OpenUrl",
-      "g n": "vim::SelectNext",
-      "g shift-n": "vim::SelectPrevious",
+      "g n": "vim::SelectNextMatch",
+      "g shift-n": "vim::SelectPreviousMatch",
+      "g l": "vim::SelectNext",
+      "g shift-l": "vim::SelectPrevious",
      "g >": [
        "editor::SelectNext",
        {
@@ -349,15 +360,6 @@
      ],
      "u": "editor::Undo",
      "ctrl-r": "editor::Redo",
-      "/": "vim::Search",
-      "?": [
-        "vim::Search",
-        {
-          "backwards": true
-        }
-      ],
-      "*": "vim::MoveToNext",
-      "#": "vim::MoveToPrev",
      "r": ["vim::PushOperator", "Replace"],
      "s": "vim::Substitute",
      "shift-s": "vim::SubstituteLine",
@@ -382,18 +384,46 @@
      "d": "editor::Rename" // zed specific
    }
  },
+  {
+    "context": "Editor && vim_mode == normal && vim_operator == c",
+    "bindings": {
+      "s": [
+        "vim::PushOperator",
+        {
+          "ChangeSurrounds": {}
+        }
+      ]
+    }
+  },
  {
    "context": "Editor && vim_operator == d",
    "bindings": {
      "d": "vim::CurrentLine"
    }
  },
+  {
+    "context": "Editor && vim_mode == normal && vim_operator == d",
+    "bindings": {
+      "s": ["vim::PushOperator", "DeleteSurrounds"]
+    }
+  },
  {
    "context": "Editor && vim_operator == y",
    "bindings": {
      "y": "vim::CurrentLine"
    }
  },
+  {
+    "context": "Editor && vim_mode == normal && vim_operator == y",
+    "bindings": {
+      "s": [
+        "vim::PushOperator",
+        {
+          "AddSurrounds": {}
+        }
+      ]
+    }
+  },
  {
    "context": "Editor && VimObject",
    "bindings": {
@@ -510,7 +540,7 @@
      "ctrl-[": "vim::NormalBefore",
      "ctrl-x ctrl-o": "editor::ShowCompletions",
      "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
-      "ctrl-x ctrl-c": "copilot::Suggest", // zed specific
+      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
      "ctrl-x ctrl-l": "editor::ToggleCodeActions", // zed specific
      "ctrl-x ctrl-z": "editor::Cancel",
      "ctrl-w": "editor::DeleteToPreviousWordStart",
@@ -546,6 +576,12 @@
      "escape": "buffer_search::Dismiss"
    }
  },
+  {
+    "context": "EmptyPane || SharedScreen",
+    "bindings": {
+      ":": "command_palette::Toggle"
+    }
+  },
  {
    // netrw compatibility
    "context": "ProjectPanel && not_editing",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -48,7 +48,8 @@
  // which gives the same size as all other panes.
  "active_pane_magnification": 1.0,
  // The key to use for adding multiple cursors
-  // Currently "alt" or "cmd" are supported.
+  // Currently "alt" or "cmd_or_ctrl"  (also aliased as
+  // "cmd" and "ctrl") are supported.
  "multi_cursor_modifier": "alt",
  // Whether to enable vim modes and key bindings
  "vim_mode": false,
@@ -69,7 +70,7 @@
  // documentation when not included in original completion list.
  "completion_documentation_secondary_query_debounce": 300,
  // Whether to show wrap guides in the editor. Setting this to true will
-  // show a guide at the 'preferred_line_length' value if softwrap is set to
+  // show a guide at the 'preferred_line_length' value if 'soft_wrap' is set to
  // 'preferred_line_length', and will show any additional guides as specified
  // by the 'wrap_guides' setting.
  "show_wrap_guides": true,
@@ -245,6 +246,8 @@
  "assistant": {
    // Version of this setting.
    "version": "1",
+    // Whether the assistant is enabled.
+    "enabled": 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'.
@@ -281,6 +284,11 @@
  // 4. Save when idle for a certain amount of time:
  //     "autosave": { "after_delay": {"milliseconds": 500} },
  "autosave": "off",
+  // Settings related to the editor's tab bar.
+  "tab_bar": {
+    // Whether or not to show the navigation history buttons.
+    "show_nav_history_buttons": true
+  },
  // Settings related to the editor's tabs
  "tabs": {
    // Show git status colors in the editor tabs.
@@ -542,53 +550,29 @@
  "file_types": {},
  // Different settings for specific languages.
  "languages": {
-    "Plain Text": {
-      "soft_wrap": "preferred_line_length"
+    "C++": {
+      "format_on_save": "off"
    },
-    "Elixir": {
-      "tab_size": 2
+    "C": {
+      "format_on_save": "off"
    },
    "Gleam": {
      "tab_size": 2
    },
    "Go": {
-      "tab_size": 4,
-      "hard_tabs": true,
      "code_actions_on_format": {
        "source.organizeImports": true
      }
    },
-    "Markdown": {
-      "tab_size": 2,
-      "soft_wrap": "preferred_line_length"
+    "Make": {
+      "hard_tabs": true
    },
-    "JavaScript": {
-      "tab_size": 2
-    },
-    "Terraform": {
-      "tab_size": 2
-    },
-    "TypeScript": {
-      "tab_size": 2
-    },
-    "TSX": {
-      "tab_size": 2
-    },
-    "YAML": {
-      "tab_size": 2
-    },
-    "JSON": {
-      "tab_size": 2
-    },
-    "OCaml": {
-      "tab_size": 2
-    },
-    "OCaml Interface": {
+    "Prisma": {
      "tab_size": 2
    }
  },
  // Zed's Prettier integration settings.
-  // If Prettier is enabled, Zed will use this its Prettier instance for any applicable file, if
+  // If Prettier is enabled, Zed will use this for its Prettier instance for any applicable file, if
  // project has no other Prettier installed.
  "prettier": {
    // Use regular Prettier json configuration:
@@ -637,5 +621,10 @@
  // Mostly useful for developers who are managing multiple instances of Zed.
  "dev": {
    // "theme": "Andromeda"
+  },
+  // Task-related settings.
+  "task": {
+    // Whether to show task status indicator in the status bar. Default: true
+    "show_status_indicator": true
  }
 }
--- a/assets/themes/andromeda/andromeda.json
+++ b/assets/themes/andromeda/andromeda.json
@@ -111,7 +111,7 @@
        "hint": "#618399ff",
        "hint.background": "#12231fff",
        "hint.border": "#183934ff",
-        "ignored": "#aca8aeff",
+        "ignored": "#6b6b73ff",
        "ignored.background": "#262933ff",
        "ignored.border": "#2b2f38ff",
        "info": "#10a793ff",
--- a/assets/themes/atelier/atelier.json
+++ b/assets/themes/atelier/atelier.json
@@ -111,7 +111,7 @@
        "hint": "#706897ff",
        "hint.background": "#161a35ff",
        "hint.border": "#222953ff",
-        "ignored": "#898591ff",
+        "ignored": "#756f7eff",
        "ignored.background": "#3a353fff",
        "ignored.border": "#56505eff",
        "info": "#566ddaff",
@@ -495,7 +495,7 @@
        "hint": "#776d9dff",
        "hint.background": "#e1e0f9ff",
        "hint.border": "#c8c7f2ff",
-        "ignored": "#5a5462ff",
+        "ignored": "#6e6876ff",
        "ignored.background": "#bfbcc5ff",
        "ignored.border": "#8f8b96ff",
        "info": "#586cdaff",
@@ -879,7 +879,7 @@
        "hint": "#b17272ff",
        "hint.background": "#171e38ff",
        "hint.border": "#262f56ff",
-        "ignored": "#a4a08bff",
+        "ignored": "#8f8b77ff",
        "ignored.background": "#45433bff",
        "ignored.border": "#6c695cff",
        "info": "#6684e0ff",
@@ -1263,7 +1263,7 @@
        "hint": "#b37979ff",
        "hint.background": "#e3e5faff",
        "hint.border": "#cdd1f5ff",
-        "ignored": "#706d5fff",
+        "ignored": "#878471ff",
        "ignored.background": "#cecab4ff",
        "ignored.border": "#a8a48eff",
        "info": "#6684dfff",
@@ -1647,7 +1647,7 @@
        "hint": "#6f815aff",
        "hint.background": "#142319ff",
        "hint.border": "#1c3927ff",
-        "ignored": "#91907fff",
+        "ignored": "#7d7c6aff",
        "ignored.background": "#424136ff",
        "ignored.border": "#5d5c4cff",
        "info": "#36a165ff",
@@ -2031,7 +2031,7 @@
        "hint": "#758961ff",
        "hint.background": "#d9ecdfff",
        "hint.border": "#bbddc6ff",
-        "ignored": "#61604fff",
+        "ignored": "#767463ff",
        "ignored.background": "#c5c4b9ff",
        "ignored.border": "#969585ff",
        "info": "#37a165ff",
@@ -2415,7 +2415,7 @@
        "hint": "#a77087ff",
        "hint.background": "#0f1c3dff",
        "hint.border": "#182d5bff",
-        "ignored": "#a79f9dff",
+        "ignored": "#8e8683ff",
        "ignored.background": "#443c39ff",
        "ignored.border": "#665f5cff",
        "info": "#407ee6ff",
@@ -2799,7 +2799,7 @@
        "hint": "#a67287ff",
        "hint.background": "#dfe3fbff",
        "hint.border": "#c6cef7ff",
-        "ignored": "#6a6360ff",
+        "ignored": "#837b78ff",
        "ignored.background": "#ccc7c5ff",
        "ignored.border": "#aaa3a1ff",
        "info": "#407ee6ff",
@@ -3183,7 +3183,7 @@
        "hint": "#8d70a8ff",
        "hint.background": "#0d1a43ff",
        "hint.border": "#192961ff",
-        "ignored": "#a899a8ff",
+        "ignored": "#908190ff",
        "ignored.background": "#433a43ff",
        "ignored.border": "#675b67ff",
        "info": "#5169ebff",
@@ -3567,7 +3567,7 @@
        "hint": "#8c70a6ff",
        "hint.background": "#e2dffcff",
        "hint.border": "#cac7faff",
-        "ignored": "#6b5e6bff",
+        "ignored": "#857785ff",
        "ignored.background": "#c6b8c6ff",
        "ignored.border": "#ad9dadff",
        "info": "#5169ebff",
@@ -3951,7 +3951,7 @@
        "hint": "#52809aff",
        "hint.background": "#121c24ff",
        "hint.border": "#1a2f3cff",
-        "ignored": "#7c9fb3ff",
+        "ignored": "#688c9dff",
        "ignored.background": "#33444dff",
        "ignored.border": "#4f6a78ff",
        "info": "#267eadff",
@@ -4335,7 +4335,7 @@
        "hint": "#5a87a0ff",
        "hint.background": "#d8e4eeff",
        "hint.border": "#b9cee0ff",
-        "ignored": "#526f7dff",
+        "ignored": "#628496ff",
        "ignored.background": "#a6cadcff",
        "ignored.border": "#80a4b6ff",
        "info": "#267eadff",
@@ -4719,7 +4719,7 @@
        "hint": "#8a647aff",
        "hint.background": "#1c1b29ff",
        "hint.border": "#2c2b45ff",
-        "ignored": "#898383ff",
+        "ignored": "#756e6eff",
        "ignored.background": "#3b3535ff",
        "ignored.border": "#564e4eff",
        "info": "#7272caff",
@@ -5103,7 +5103,7 @@
        "hint": "#91697fff",
        "hint.background": "#e4e1f5ff",
        "hint.border": "#cecaecff",
-        "ignored": "#5a5252ff",
+        "ignored": "#6e6666ff",
        "ignored.background": "#c1bbbbff",
        "ignored.border": "#8e8989ff",
        "info": "#7272caff",
@@ -5487,7 +5487,7 @@
        "hint": "#607e76ff",
        "hint.background": "#151e20ff",
        "hint.border": "#1f3233ff",
-        "ignored": "#859188ff",
+        "ignored": "#6f7e74ff",
        "ignored.background": "#353f39ff",
        "ignored.border": "#505e55ff",
        "info": "#468b8fff",
@@ -5871,7 +5871,7 @@
        "hint": "#66847cff",
        "hint.background": "#dae7e8ff",
        "hint.border": "#bed4d6ff",
-        "ignored": "#546259ff",
+        "ignored": "#68766dff",
        "ignored.background": "#bcc5bfff",
        "ignored.border": "#8b968eff",
        "info": "#488b90ff",
@@ -6255,7 +6255,7 @@
        "hint": "#008b9fff",
        "hint.background": "#051949ff",
        "hint.border": "#102667ff",
-        "ignored": "#8ba48bff",
+        "ignored": "#778f77ff",
        "ignored.background": "#3b453bff",
        "ignored.border": "#5c6c5cff",
        "info": "#3e62f4ff",
@@ -6639,7 +6639,7 @@
        "hint": "#008fa1ff",
        "hint.background": "#e1ddfeff",
        "hint.border": "#c9c4fdff",
-        "ignored": "#5f705fff",
+        "ignored": "#718771ff",
        "ignored.background": "#b4ceb4ff",
        "ignored.border": "#8ea88eff",
        "info": "#3e61f4ff",
@@ -7023,7 +7023,7 @@
        "hint": "#6c81a5ff",
        "hint.background": "#161f2bff",
        "hint.border": "#203348ff",
-        "ignored": "#959bb2ff",
+        "ignored": "#7e849eff",
        "ignored.background": "#3e4769ff",
        "ignored.border": "#5b6385ff",
        "info": "#3e8ed0ff",
@@ -7407,7 +7407,7 @@
        "hint": "#7087b2ff",
        "hint.background": "#dde7f6ff",
        "hint.border": "#c2d5efff",
-        "ignored": "#5f6789ff",
+        "ignored": "#767d9aff",
        "ignored.background": "#c1c5d8ff",
        "ignored.border": "#9a9fb6ff",
        "info": "#3e8fd0ff",
--- a/assets/themes/ayu/ayu.json
+++ b/assets/themes/ayu/ayu.json
@@ -111,7 +111,7 @@
        "hint": "#628b80ff",
        "hint.background": "#0d2f4eff",
        "hint.border": "#1b4a6eff",
-        "ignored": "#8a8986ff",
+        "ignored": "#696a6aff",
        "ignored.background": "#313337ff",
        "ignored.border": "#3f4043ff",
        "info": "#5ac1feff",
@@ -480,7 +480,7 @@
        "hint": "#8ca7c2ff",
        "hint.background": "#deebfaff",
        "hint.border": "#c4daf6ff",
-        "ignored": "#8b8e92ff",
+        "ignored": "#a9acaeff",
        "ignored.background": "#dcdddeff",
        "ignored.border": "#cfd1d2ff",
        "info": "#3b9ee5ff",
@@ -849,7 +849,7 @@
        "hint": "#7399a3ff",
        "hint.background": "#123950ff",
        "hint.border": "#24556fff",
-        "ignored": "#9a9a98ff",
+        "ignored": "#7b7d7fff",
        "ignored.background": "#464a52ff",
        "ignored.border": "#53565dff",
        "info": "#72cffeff",
--- a/assets/themes/gruvbox/gruvbox.json
+++ b/assets/themes/gruvbox/gruvbox.json
@@ -111,7 +111,7 @@
        "hint": "#8c957dff",
        "hint.background": "#1e2321ff",
        "hint.border": "#303a36ff",
-        "ignored": "#c5b597ff",
+        "ignored": "#998b78ff",
        "ignored.background": "#4c4642ff",
        "ignored.border": "#5b534dff",
        "info": "#83a598ff",
@@ -485,7 +485,7 @@
        "hint": "#6a695bff",
        "hint.background": "#1e2321ff",
        "hint.border": "#303a36ff",
-        "ignored": "#c5b597ff",
+        "ignored": "#998b78ff",
        "ignored.background": "#4c4642ff",
        "ignored.border": "#5b534dff",
        "info": "#83a598ff",
@@ -859,7 +859,7 @@
        "hint": "#8c957dff",
        "hint.background": "#1e2321ff",
        "hint.border": "#303a36ff",
-        "ignored": "#c5b597ff",
+        "ignored": "#998b78ff",
        "ignored.background": "#4c4642ff",
        "ignored.border": "#5b534dff",
        "info": "#83a598ff",
@@ -1233,7 +1233,7 @@
        "hint": "#677562ff",
        "hint.background": "#d2dee2ff",
        "hint.border": "#adc5ccff",
-        "ignored": "#5f5650ff",
+        "ignored": "#897b6eff",
        "ignored.background": "#d9c8a4ff",
        "ignored.border": "#c8b899ff",
        "info": "#0b6678ff",
@@ -1607,7 +1607,7 @@
        "hint": "#677562ff",
        "hint.background": "#d2dee2ff",
        "hint.border": "#adc5ccff",
-        "ignored": "#5f5650ff",
+        "ignored": "#897b6eff",
        "ignored.background": "#d9c8a4ff",
        "ignored.border": "#c8b899ff",
        "info": "#0b6678ff",
@@ -1981,7 +1981,7 @@
        "hint": "#677562ff",
        "hint.background": "#d2dee2ff",
        "hint.border": "#adc5ccff",
-        "ignored": "#5f5650ff",
+        "ignored": "#897b6eff",
        "ignored.background": "#d9c8a4ff",
        "ignored.border": "#c8b899ff",
        "info": "#0b6678ff",
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -111,7 +111,7 @@
        "hint": "#5a6f89ff",
        "hint.background": "#18243dff",
        "hint.border": "#293b5bff",
-        "ignored": "#838994ff",
+        "ignored": "#555a63ff",
        "ignored.background": "#3b414dff",
        "ignored.border": "#464b57ff",
        "info": "#74ade8ff",
@@ -485,7 +485,7 @@
        "hint": "#9294beff",
        "hint.background": "#e2e2faff",
        "hint.border": "#cbcdf6ff",
-        "ignored": "#7e8087ff",
+        "ignored": "#a1a1a3ff",
        "ignored.background": "#dcdcddff",
        "ignored.border": "#c9c9caff",
        "info": "#5c78e2ff",
--- a/assets/themes/rose_pine/rose_pine.json
+++ b/assets/themes/rose_pine/rose_pine.json
@@ -111,7 +111,7 @@
        "hint": "#5e768cff",
        "hint.background": "#2f3639ff",
        "hint.border": "#435255ff",
-        "ignored": "#74708dff",
+        "ignored": "#2f2b43ff",
        "ignored.background": "#292738ff",
        "ignored.border": "#423f55ff",
        "info": "#9bced6ff",
@@ -490,7 +490,7 @@
        "hint": "#7a92aaff",
        "hint.background": "#dde9ebff",
        "hint.border": "#c3d7dbff",
-        "ignored": "#706c8cff",
+        "ignored": "#938fa3ff",
        "ignored.background": "#dcd8d8ff",
        "ignored.border": "#dcd6d5ff",
        "info": "#57949fff",
@@ -869,7 +869,7 @@
        "hint": "#728aa2ff",
        "hint.background": "#2f3639ff",
        "hint.border": "#435255ff",
-        "ignored": "#85819eff",
+        "ignored": "#605d7aff",
        "ignored.background": "#38354eff",
        "ignored.border": "#504c68ff",
        "info": "#9bced6ff",
--- a/assets/themes/sandcastle/sandcastle.json
+++ b/assets/themes/sandcastle/sandcastle.json
@@ -111,7 +111,7 @@
        "hint": "#727d68ff",
        "hint.background": "#171e1eff",
        "hint.border": "#223131ff",
-        "ignored": "#a69782ff",
+        "ignored": "#827568ff",
        "ignored.background": "#333944ff",
        "ignored.border": "#3d4350ff",
        "info": "#518b8bff",
--- a/assets/themes/solarized/solarized.json
+++ b/assets/themes/solarized/solarized.json
@@ -111,7 +111,7 @@
        "hint": "#4f8297ff",
        "hint.background": "#141f2cff",
        "hint.border": "#1b3149ff",
-        "ignored": "#93a1a1ff",
+        "ignored": "#6f8389ff",
        "ignored.background": "#073743ff",
        "ignored.border": "#2b4e58ff",
        "info": "#278ad1ff",
@@ -480,7 +480,7 @@
        "hint": "#5789a3ff",
        "hint.background": "#dbe6f6ff",
        "hint.border": "#bfd3efff",
-        "ignored": "#34555eff",
+        "ignored": "#6a7f86ff",
        "ignored.background": "#cfd0c4ff",
        "ignored.border": "#9faaa8ff",
        "info": "#288bd1ff",
--- a/assets/themes/summercamp/summercamp.json
+++ b/assets/themes/summercamp/summercamp.json
@@ -111,7 +111,7 @@
        "hint": "#246e61ff",
        "hint.background": "#0e2242ff",
        "hint.border": "#193760ff",
-        "ignored": "#736e55ff",
+        "ignored": "#4c4735ff",
        "ignored.background": "#2a261cff",
        "ignored.border": "#302c21ff",
        "info": "#499befff",
--- a/crates/activity_indicator/Cargo.toml
+++ b/crates/activity_indicator/Cargo.toml
@@ -16,6 +16,7 @@ doctest = false
 anyhow.workspace = true
 auto_update.workspace = true
 editor.workspace = true
+extension.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -1,5 +1,6 @@
 use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
 use editor::Editor;
+use extension::ExtensionStore;
 use futures::StreamExt;
 use gpui::{
    actions, svg, AppContext, CursorStyle, EventEmitter, InteractiveElement as _, Model,
@@ -205,7 +206,7 @@ impl ActivityIndicator {
                }
                LanguageServerBinaryStatus::Downloading => downloading.push(status.name.0.as_ref()),
                LanguageServerBinaryStatus::Failed { .. } => failed.push(status.name.0.as_ref()),
-                LanguageServerBinaryStatus::Downloaded | LanguageServerBinaryStatus::Cached => {}
+                LanguageServerBinaryStatus::None => {}
            }
        }

@@ -288,6 +289,18 @@ impl ActivityIndicator {
            };
        }

+        if let Some(extension_store) =
+            ExtensionStore::try_global(cx).map(|extension_store| extension_store.read(cx))
+        {
+            if let Some(extension_id) = extension_store.outstanding_operations().keys().next() {
+                return Content {
+                    icon: Some(DOWNLOAD_ICON),
+                    message: format!("Updating {extension_id} extension…"),
+                    on_click: None,
+                };
+            }
+        }
+
        Default::default()
    }
 }
--- a/crates/anthropic/Cargo.toml
+++ b/crates/anthropic/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "anthropic"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "AGPL-3.0-or-later"
+
+[lib]
+path = "src/anthropic.rs"
+
+[dependencies]
+anyhow.workspace = true
+futures.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+tokio.workspace = true
+
+[lints]
+workspace = true
--- a/crates/anthropic/LICENSE-AGPL
+++ b/crates/anthropic/LICENSE-AGPL
@@ -0,0 +1 @@
+../../LICENSE-AGPL
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -0,0 +1,234 @@
+use anyhow::{anyhow, Result};
+use futures::{io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, StreamExt};
+use serde::{Deserialize, Serialize};
+use std::convert::TryFrom;
+use util::http::{AsyncBody, HttpClient, Method, Request as HttpRequest};
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub enum Model {
+    #[default]
+    #[serde(rename = "claude-3-opus-20240229")]
+    Claude3Opus,
+    #[serde(rename = "claude-3-sonnet-20240229")]
+    Claude3Sonnet,
+    #[serde(rename = "claude-3-haiku-20240307")]
+    Claude3Haiku,
+}
+
+impl Model {
+    pub fn from_id(id: &str) -> Result<Self> {
+        if id.starts_with("claude-3-opus") {
+            Ok(Self::Claude3Opus)
+        } else if id.starts_with("claude-3-sonnet") {
+            Ok(Self::Claude3Sonnet)
+        } else if id.starts_with("claude-3-haiku") {
+            Ok(Self::Claude3Haiku)
+        } else {
+            Err(anyhow!("Invalid model id: {}", id))
+        }
+    }
+
+    pub fn display_name(&self) -> &'static str {
+        match self {
+            Self::Claude3Opus => "Claude 3 Opus",
+            Self::Claude3Sonnet => "Claude 3 Sonnet",
+            Self::Claude3Haiku => "Claude 3 Haiku",
+        }
+    }
+
+    pub fn max_token_count(&self) -> usize {
+        200_000
+    }
+}
+
+#[derive(Clone, Copy, Serialize, Deserialize, Debug, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum Role {
+    User,
+    Assistant,
+}
+
+impl TryFrom<String> for Role {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self> {
+        match value.as_str() {
+            "user" => Ok(Self::User),
+            "assistant" => Ok(Self::Assistant),
+            _ => Err(anyhow!("invalid role '{value}'")),
+        }
+    }
+}
+
+impl From<Role> for String {
+    fn from(val: Role) -> Self {
+        match val {
+            Role::User => "user".to_owned(),
+            Role::Assistant => "assistant".to_owned(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct Request {
+    pub model: Model,
+    pub messages: Vec<RequestMessage>,
+    pub stream: bool,
+    pub system: String,
+    pub max_tokens: u32,
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+pub struct RequestMessage {
+    pub role: Role,
+    pub content: String,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ResponseEvent {
+    MessageStart {
+        message: ResponseMessage,
+    },
+    ContentBlockStart {
+        index: u32,
+        content_block: ContentBlock,
+    },
+    Ping {},
+    ContentBlockDelta {
+        index: u32,
+        delta: TextDelta,
+    },
+    ContentBlockStop {
+        index: u32,
+    },
+    MessageDelta {
+        delta: ResponseMessage,
+        usage: Usage,
+    },
+    MessageStop {},
+}
+
+#[derive(Deserialize, Debug)]
+pub struct ResponseMessage {
+    #[serde(rename = "type")]
+    pub message_type: Option<String>,
+    pub id: Option<String>,
+    pub role: Option<String>,
+    pub content: Option<Vec<String>>,
+    pub model: Option<String>,
+    pub stop_reason: Option<String>,
+    pub stop_sequence: Option<String>,
+    pub usage: Option<Usage>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Usage {
+    pub input_tokens: Option<u32>,
+    pub output_tokens: Option<u32>,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ContentBlock {
+    Text { text: String },
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum TextDelta {
+    TextDelta { text: String },
+}
+
+pub async fn stream_completion(
+    client: &dyn HttpClient,
+    api_url: &str,
+    api_key: &str,
+    request: Request,
+) -> Result<BoxStream<'static, Result<ResponseEvent>>> {
+    let uri = format!("{api_url}/v1/messages");
+    let request = HttpRequest::builder()
+        .method(Method::POST)
+        .uri(uri)
+        .header("Anthropic-Version", "2023-06-01")
+        .header("Anthropic-Beta", "messages-2023-12-15")
+        .header("X-Api-Key", api_key)
+        .header("Content-Type", "application/json")
+        .body(AsyncBody::from(serde_json::to_string(&request)?))?;
+    let mut response = client.send(request).await?;
+    if response.status().is_success() {
+        let reader = BufReader::new(response.into_body());
+        Ok(reader
+            .lines()
+            .filter_map(|line| async move {
+                match line {
+                    Ok(line) => {
+                        let line = line.strip_prefix("data: ")?;
+                        match serde_json::from_str(line) {
+                            Ok(response) => Some(Ok(response)),
+                            Err(error) => Some(Err(anyhow!(error))),
+                        }
+                    }
+                    Err(error) => Some(Err(anyhow!(error))),
+                }
+            })
+            .boxed())
+    } else {
+        let mut body = Vec::new();
+        response.body_mut().read_to_end(&mut body).await?;
+
+        let body_str = std::str::from_utf8(&body)?;
+
+        match serde_json::from_str::<ResponseEvent>(body_str) {
+            Ok(_) => Err(anyhow!(
+                "Unexpected success response while expecting an error: {}",
+                body_str,
+            )),
+            Err(_) => Err(anyhow!(
+                "Failed to connect to API: {} {}",
+                response.status(),
+                body_str,
+            )),
+        }
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//     use util::http::IsahcHttpClient;
+
+//     #[tokio::test]
+//     async fn stream_completion_success() {
+//         let http_client = IsahcHttpClient::new().unwrap();
+
+//         let request = Request {
+//             model: Model::Claude3Opus,
+//             messages: vec![RequestMessage {
+//                 role: Role::User,
+//                 content: "Ping".to_string(),
+//             }],
+//             stream: true,
+//             system: "Respond to ping with pong".to_string(),
+//             max_tokens: 4096,
+//         };
+
+//         let stream = stream_completion(
+//             &http_client,
+//             "https://api.anthropic.com",
+//             &std::env::var("ANTHROPIC_API_KEY").expect("ANTHROPIC_API_KEY not set"),
+//             request,
+//         )
+//         .await
+//         .unwrap();
+
+//         stream
+//             .for_each(|event| async {
+//                 match event {
+//                     Ok(event) => println!("{:?}", event),
+//                     Err(e) => eprintln!("Error: {:?}", e),
+//                 }
+//             })
+//             .await;
+//     }
+// }
--- a/crates/assistant/Cargo.toml
+++ b/crates/assistant/Cargo.toml
@@ -14,7 +14,9 @@ anyhow.workspace = true
 chrono.workspace = true
 client.workspace = true
 collections.workspace = true
+command_palette_hooks.workspace = true
 editor.workspace = true
+file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -6,15 +6,18 @@ mod prompts;
 mod saved_conversation;
 mod streaming_diff;

+mod embedded_scope;
+
 pub use assistant_panel::AssistantPanel;
 use assistant_settings::{AssistantSettings, OpenAiModel, ZedDotDevModel};
 use chrono::{DateTime, Local};
 use client::{proto, Client};
+use command_palette_hooks::CommandPaletteFilter;
 pub(crate) use completion_provider::*;
-use gpui::{actions, AppContext, SharedString};
+use gpui::{actions, AppContext, BorrowAppContext, Global, SharedString};
 pub(crate) use saved_conversation::*;
 use serde::{Deserialize, Serialize};
-use settings::Settings;
+use settings::{Settings, SettingsStore};
 use std::{
    fmt::{self, Display},
    sync::Arc,
@@ -97,13 +100,8 @@ impl LanguageModel {

    pub fn max_token_count(&self) -> usize {
        match self {
-            LanguageModel::OpenAi(model) => tiktoken_rs::model::get_context_size(model.id()),
-            LanguageModel::ZedDotDev(model) => match model {
-                ZedDotDevModel::GptThreePointFiveTurbo
-                | ZedDotDevModel::GptFour
-                | ZedDotDevModel::GptFourTurbo => tiktoken_rs::model::get_context_size(model.id()),
-                ZedDotDevModel::Custom(_) => 30720, // TODO: Base this on the selected model.
-            },
+            LanguageModel::OpenAi(model) => model.max_token_count(),
+            LanguageModel::ZedDotDev(model) => model.max_token_count(),
        }
    }

@@ -187,10 +185,61 @@ enum MessageStatus {
    Error(SharedString),
 }

+/// The state pertaining to the Assistant.
+#[derive(Default)]
+struct Assistant {
+    /// Whether the Assistant is enabled.
+    enabled: bool,
+}
+
+impl Global for Assistant {}
+
+impl Assistant {
+    const NAMESPACE: &'static str = "assistant";
+
+    fn set_enabled(&mut self, enabled: bool, cx: &mut AppContext) {
+        if self.enabled == enabled {
+            return;
+        }
+
+        self.enabled = enabled;
+
+        if !enabled {
+            CommandPaletteFilter::update_global(cx, |filter, _cx| {
+                filter.hide_namespace(Self::NAMESPACE);
+            });
+
+            return;
+        }
+
+        CommandPaletteFilter::update_global(cx, |filter, _cx| {
+            filter.show_namespace(Self::NAMESPACE);
+        });
+    }
+}
+
 pub fn init(client: Arc<Client>, cx: &mut AppContext) {
+    cx.set_global(Assistant::default());
    AssistantSettings::register(cx);
    completion_provider::init(client, cx);
    assistant_panel::init(cx);
+
+    CommandPaletteFilter::update_global(cx, |filter, _cx| {
+        filter.hide_namespace(Assistant::NAMESPACE);
+    });
+    cx.update_global(|assistant: &mut Assistant, cx: &mut AppContext| {
+        let settings = AssistantSettings::get_global(cx);
+
+        assistant.set_enabled(settings.enabled, cx);
+    });
+    cx.observe_global::<SettingsStore>(|cx| {
+        cx.update_global(|assistant: &mut Assistant, cx: &mut AppContext| {
+            let settings = AssistantSettings::get_global(cx);
+
+            assistant.set_enabled(settings.enabled, cx);
+        });
+    })
+    .detach();
 }

 #[cfg(test)]
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -1,13 +1,14 @@
 use crate::{
    assistant_settings::{AssistantDockPosition, AssistantSettings, ZedDotDevModel},
    codegen::{self, Codegen, CodegenKind},
+    embedded_scope::EmbeddedScope,
    prompts::generate_content_prompt,
    Assist, CompletionProvider, CycleMessageRole, InlineAssist, LanguageModel,
    LanguageModelRequest, LanguageModelRequestMessage, MessageId, MessageMetadata, MessageStatus,
    NewConversation, QuoteSelection, ResetKey, Role, SavedConversation, SavedConversationMetadata,
    SavedMessage, Split, ToggleFocus, ToggleIncludeConversation,
 };
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use chrono::{DateTime, Local};
 use collections::{hash_map, HashMap, HashSet, VecDeque};
 use editor::{
@@ -16,9 +17,10 @@ use editor::{
        BlockContext, BlockDisposition, BlockId, BlockProperties, BlockStyle, ToDisplayPoint,
    },
    scroll::{Autoscroll, AutoscrollStrategy},
-    Anchor, Editor, EditorElement, EditorEvent, EditorStyle, MultiBufferSnapshot, ToOffset as _,
-    ToPoint,
+    Anchor, Editor, EditorElement, EditorEvent, EditorStyle, MultiBuffer, MultiBufferSnapshot,
+    ToOffset as _, ToPoint,
 };
+use file_icons::FileIcons;
 use fs::Fs;
 use futures::StreamExt;
 use gpui::{
@@ -47,7 +49,7 @@ use uuid::Uuid;
 use workspace::{
    dock::{DockPosition, Panel, PanelEvent},
    searchable::Direction,
-    Save, Toast, ToggleZoom, Toolbar, Workspace,
+    Event as WorkspaceEvent, Save, Toast, ToggleZoom, Toolbar, Workspace,
 };

 pub fn init(cx: &mut AppContext) {
@@ -55,6 +57,11 @@ pub fn init(cx: &mut AppContext) {
        |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {
            workspace
                .register_action(|workspace, _: &ToggleFocus, cx| {
+                    let settings = AssistantSettings::get_global(cx);
+                    if !settings.enabled {
+                        return;
+                    }
+
                    workspace.toggle_panel_focus::<AssistantPanel>(cx);
                })
                .register_action(AssistantPanel::inline_assist)
@@ -155,6 +162,11 @@ impl AssistantPanel {
                    ];
                    let model = CompletionProvider::global(cx).default_model();

+                    cx.observe_global::<FileIcons>(|_, cx| {
+                        cx.notify();
+                    })
+                    .detach();
+
                    Self {
                        workspace: workspace_handle,
                        active_conversation_editor: None,
@@ -229,6 +241,11 @@ impl AssistantPanel {
        _: &InlineAssist,
        cx: &mut ViewContext<Workspace>,
    ) {
+        let settings = AssistantSettings::get_global(cx);
+        if !settings.enabled {
+            return;
+        }
+
        let Some(assistant) = workspace.panel::<AssistantPanel>(cx) else {
            return;
        };
@@ -328,7 +345,7 @@ impl AssistantPanel {
                    style: BlockStyle::Flex,
                    position: snapshot.anchor_before(point_selection.head()),
                    height: 2,
-                    render: Arc::new({
+                    render: Box::new({
                        let inline_assistant = inline_assistant.clone();
                        move |cx: &mut BlockContext| {
                            *measurements.lock() = BlockMeasurements {
@@ -678,7 +695,7 @@ impl AssistantPanel {
                editor.clear_background_highlights::<PendingInlineAssist>(cx);
            } else {
                editor.highlight_background::<PendingInlineAssist>(
-                    background_ranges,
+                    &background_ranges,
                    |theme| theme.editor_active_line_background, // todo!("use the appropriate color")
                    cx,
                );
@@ -699,18 +716,20 @@ impl AssistantPanel {
        });
    }

-    fn new_conversation(&mut self, cx: &mut ViewContext<Self>) -> View<ConversationEditor> {
+    fn new_conversation(&mut self, cx: &mut ViewContext<Self>) -> Option<View<ConversationEditor>> {
+        let workspace = self.workspace.upgrade()?;
+
        let editor = cx.new_view(|cx| {
            ConversationEditor::new(
                self.model.clone(),
                self.languages.clone(),
                self.fs.clone(),
-                self.workspace.clone(),
+                workspace,
                cx,
            )
        });
        self.show_conversation(editor.clone(), cx);
-        editor
+        Some(editor)
    }

    fn show_conversation(
@@ -749,15 +768,18 @@ impl AssistantPanel {
                open_ai::Model::FourTurbo => open_ai::Model::ThreePointFiveTurbo,
            }),
            LanguageModel::ZedDotDev(model) => LanguageModel::ZedDotDev(match &model {
-                ZedDotDevModel::GptThreePointFiveTurbo => ZedDotDevModel::GptFour,
-                ZedDotDevModel::GptFour => ZedDotDevModel::GptFourTurbo,
-                ZedDotDevModel::GptFourTurbo => {
+                ZedDotDevModel::Gpt3Point5Turbo => ZedDotDevModel::Gpt4,
+                ZedDotDevModel::Gpt4 => ZedDotDevModel::Gpt4Turbo,
+                ZedDotDevModel::Gpt4Turbo => ZedDotDevModel::Claude3Opus,
+                ZedDotDevModel::Claude3Opus => ZedDotDevModel::Claude3Sonnet,
+                ZedDotDevModel::Claude3Sonnet => ZedDotDevModel::Claude3Haiku,
+                ZedDotDevModel::Claude3Haiku => {
                    match CompletionProvider::global(cx).default_model() {
                        LanguageModel::ZedDotDev(custom) => custom,
-                        _ => ZedDotDevModel::GptThreePointFiveTurbo,
+                        _ => ZedDotDevModel::Gpt3Point5Turbo,
                    }
                }
-                ZedDotDevModel::Custom(_) => ZedDotDevModel::GptThreePointFiveTurbo,
+                ZedDotDevModel::Custom(_) => ZedDotDevModel::Gpt3Point5Turbo,
            }),
        };

@@ -979,11 +1001,15 @@ impl AssistantPanel {
            .await?;

            this.update(&mut cx, |this, cx| {
+                let workspace = workspace
+                    .upgrade()
+                    .ok_or_else(|| anyhow!("workspace dropped"))?;
                let editor = cx.new_view(|cx| {
                    ConversationEditor::for_conversation(conversation, fs, workspace, cx)
                });
                this.show_conversation(editor, cx);
-            })?;
+                anyhow::Ok(())
+            })??;
            Ok(())
        })
    }
@@ -1217,7 +1243,12 @@ impl Panel for AssistantPanel {
    }

    fn icon(&self, cx: &WindowContext) -> Option<IconName> {
-        Some(IconName::Ai).filter(|_| AssistantSettings::get_global(cx).button)
+        let settings = AssistantSettings::get_global(cx);
+        if !settings.enabled || !settings.button {
+            return None;
+        }
+
+        Some(IconName::Ai)
    }

    fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
@@ -1249,9 +1280,10 @@ struct Summary {
    done: bool,
 }

-struct Conversation {
+pub struct Conversation {
    id: Option<String>,
    buffer: Model<Buffer>,
+    embedded_scope: EmbeddedScope,
    message_anchors: Vec<MessageAnchor>,
    messages_metadata: HashMap<MessageId, MessageMetadata>,
    next_message_id: MessageId,
@@ -1273,6 +1305,7 @@ impl Conversation {
    fn new(
        model: LanguageModel,
        language_registry: Arc<LanguageRegistry>,
+        embedded_scope: EmbeddedScope,
        cx: &mut ModelContext<Self>,
    ) -> Self {
        let markdown = language_registry.language_for_name("Markdown");
@@ -1306,7 +1339,9 @@ impl Conversation {
            pending_save: Task::ready(Ok(())),
            path: None,
            buffer,
+            embedded_scope,
        };
+
        let message = MessageAnchor {
            id: MessageId(post_inc(&mut this.next_message_id.0)),
            start: language::Anchor::MIN,
@@ -1407,6 +1442,7 @@ impl Conversation {
                pending_save: Task::ready(Ok(())),
                path: Some(path),
                buffer,
+                embedded_scope: EmbeddedScope::new(),
            };
            this.count_remaining_tokens(cx);
            this
@@ -1425,7 +1461,7 @@ impl Conversation {
        }
    }

-    fn count_remaining_tokens(&mut self, cx: &mut ModelContext<Self>) {
+    pub(crate) fn count_remaining_tokens(&mut self, cx: &mut ModelContext<Self>) {
        let request = self.to_completion_request(cx);
        self.pending_token_count = cx.spawn(|this, mut cx| {
            async move {
@@ -1588,7 +1624,7 @@ impl Conversation {
    }

    fn to_completion_request(&self, cx: &mut ModelContext<Conversation>) -> LanguageModelRequest {
-        let request = LanguageModelRequest {
+        let mut request = LanguageModelRequest {
            model: self.model.clone(),
            messages: self
                .messages(cx)
@@ -1598,6 +1634,9 @@ impl Conversation {
            stop: vec![],
            temperature: 1.0,
        };
+
+        let context_message = self.embedded_scope.message(cx);
+        request.messages.extend(context_message);
        request
    }

@@ -1987,17 +2026,18 @@ impl ConversationEditor {
        model: LanguageModel,
        language_registry: Arc<LanguageRegistry>,
        fs: Arc<dyn Fs>,
-        workspace: WeakView<Workspace>,
+        workspace: View<Workspace>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
-        let conversation = cx.new_model(|cx| Conversation::new(model, language_registry, cx));
+        let conversation = cx
+            .new_model(|cx| Conversation::new(model, language_registry, EmbeddedScope::new(), cx));
        Self::for_conversation(conversation, fs, workspace, cx)
    }

    fn for_conversation(
        conversation: Model<Conversation>,
        fs: Arc<dyn Fs>,
-        workspace: WeakView<Workspace>,
+        workspace: View<Workspace>,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        let editor = cx.new_view(|cx| {
@@ -2012,6 +2052,7 @@ impl ConversationEditor {
            cx.observe(&conversation, |_, _, cx| cx.notify()),
            cx.subscribe(&conversation, Self::handle_conversation_event),
            cx.subscribe(&editor, Self::handle_editor_event),
+            cx.subscribe(&workspace, Self::handle_workspace_event),
        ];

        let mut this = Self {
@@ -2020,9 +2061,10 @@ impl ConversationEditor {
            blocks: Default::default(),
            scroll_position: None,
            fs,
-            workspace,
+            workspace: workspace.downgrade(),
            _subscriptions,
        };
+        this.update_active_buffer(workspace, cx);
        this.update_message_headers(cx);
        this
    }
@@ -2156,6 +2198,37 @@ impl ConversationEditor {
        }
    }

+    fn handle_workspace_event(
+        &mut self,
+        workspace: View<Workspace>,
+        event: &WorkspaceEvent,
+        cx: &mut ViewContext<Self>,
+    ) {
+        if let WorkspaceEvent::ActiveItemChanged = event {
+            self.update_active_buffer(workspace, cx);
+        }
+    }
+
+    fn update_active_buffer(
+        &mut self,
+        workspace: View<Workspace>,
+        cx: &mut ViewContext<'_, ConversationEditor>,
+    ) {
+        let active_buffer = workspace
+            .read(cx)
+            .active_item(cx)
+            .and_then(|item| Some(item.act_as::<Editor>(cx)?.read(cx).buffer().clone()));
+
+        self.conversation.update(cx, |conversation, cx| {
+            conversation
+                .embedded_scope
+                .set_active_buffer(active_buffer.clone(), cx);
+
+            conversation.count_remaining_tokens(cx);
+            cx.notify();
+        });
+    }
+
    fn cursor_scroll_position(&self, cx: &mut ViewContext<Self>) -> Option<ScrollPosition> {
        self.editor.update(cx, |editor, cx| {
            let snapshot = editor.snapshot(cx);
@@ -2193,7 +2266,7 @@ impl ConversationEditor {
                        .unwrap(),
                    height: 2,
                    style: BlockStyle::Sticky,
-                    render: Arc::new({
+                    render: Box::new({
                        let conversation = self.conversation.clone();
                        move |_cx| {
                            let message_id = message.id;
@@ -2289,11 +2362,11 @@ impl ConversationEditor {
        let start_language = buffer.language_at(range.start);
        let end_language = buffer.language_at(range.end);
        let language_name = if start_language == end_language {
-            start_language.map(|language| language.name())
+            start_language.map(|language| language.code_fence_block_name())
        } else {
            None
        };
-        let language_name = language_name.as_deref().unwrap_or("").to_lowercase();
+        let language_name = language_name.as_deref().unwrap_or("");

        let selected_text = buffer.text_for_range(range).collect::<String>();
        let text = if selected_text.is_empty() {
@@ -2317,15 +2390,17 @@ impl ConversationEditor {

        if let Some(text) = text {
            panel.update(cx, |panel, cx| {
-                let conversation = panel
+                if let Some(conversation) = panel
                    .active_conversation_editor()
                    .cloned()
-                    .unwrap_or_else(|| panel.new_conversation(cx));
-                conversation.update(cx, |conversation, cx| {
-                    conversation
-                        .editor
-                        .update(cx, |editor, cx| editor.insert(&text, cx))
-                });
+                    .or_else(|| panel.new_conversation(cx))
+                {
+                    conversation.update(cx, |conversation, cx| {
+                        conversation
+                            .editor
+                            .update(cx, |editor, cx| editor.insert(&text, cx))
+                    });
+                };
            });
        }
    }
@@ -2390,12 +2465,120 @@ impl ConversationEditor {
            .map(|summary| summary.text.clone())
            .unwrap_or_else(|| "New Conversation".into())
    }
+
+    fn render_embedded_scope(&self, cx: &mut ViewContext<Self>) -> Option<impl Element> {
+        let active_buffer = self
+            .conversation
+            .read(cx)
+            .embedded_scope
+            .active_buffer()?
+            .clone();
+
+        Some(
+            div()
+                .p_4()
+                .v_flex()
+                .child(
+                    div()
+                        .h_flex()
+                        .items_center()
+                        .child(Icon::new(IconName::File))
+                        .child(
+                            div()
+                                .h_6()
+                                .child(Label::new("File Contexts"))
+                                .ml_1()
+                                .font_weight(FontWeight::SEMIBOLD),
+                        ),
+                )
+                .child(
+                    div()
+                        .ml_4()
+                        .child(self.render_active_buffer(active_buffer, cx)),
+                ),
+        )
+    }
+
+    fn render_active_buffer(
+        &self,
+        buffer: Model<MultiBuffer>,
+        cx: &mut ViewContext<Self>,
+    ) -> impl Element {
+        let buffer = buffer.read(cx);
+        let icon_path;
+        let path;
+        if let Some(singleton) = buffer.as_singleton() {
+            let singleton = singleton.read(cx);
+
+            path = singleton.file().map(|file| file.full_path(cx));
+
+            icon_path = path
+                .as_ref()
+                .and_then(|path| FileIcons::get_icon(path.as_path(), cx))
+                .map(SharedString::from)
+                .unwrap_or_else(|| SharedString::from("icons/file_icons/file.svg"));
+        } else {
+            icon_path = SharedString::from("icons/file_icons/file.svg");
+            path = None;
+        }
+
+        let file_name = path.map_or("Untitled".to_string(), |path| {
+            path.to_string_lossy().to_string()
+        });
+
+        let enabled = self
+            .conversation
+            .read(cx)
+            .embedded_scope
+            .active_buffer_enabled();
+
+        let file_name_text_color = if enabled {
+            Color::Default
+        } else {
+            Color::Disabled
+        };
+
+        div()
+            .id("active-buffer")
+            .h_flex()
+            .cursor_pointer()
+            .child(Icon::from_path(icon_path).color(file_name_text_color))
+            .child(
+                div()
+                    .h_6()
+                    .child(Label::new(file_name).color(file_name_text_color))
+                    .ml_1(),
+            )
+            .children(enabled.then(|| {
+                div()
+                    .child(Icon::new(IconName::Check).color(file_name_text_color))
+                    .ml_1()
+            }))
+            .on_click(cx.listener(move |this, _, cx| {
+                this.conversation.update(cx, |conversation, cx| {
+                    conversation
+                        .embedded_scope
+                        .set_active_buffer_enabled(!enabled);
+                    cx.notify();
+                })
+            }))
+    }
 }

 impl EventEmitter<ConversationEditorEvent> for ConversationEditor {}

 impl Render for ConversationEditor {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element {
+        //
+        // The ConversationEditor has two main segments
+        //
+        // 1. Messages Editor
+        // 2. Context
+        //   - File Context (currently only the active file)
+        //   - Project Diagnostics (Planned)
+        //   - Deep Code Context (Planned, for query and other tools for the model)
+        //
+
        div()
            .key_context("ConversationEditor")
            .capture_action(cx.listener(ConversationEditor::cancel_last_assist))
@@ -2405,14 +2588,15 @@ impl Render for ConversationEditor {
            .on_action(cx.listener(ConversationEditor::assist))
            .on_action(cx.listener(ConversationEditor::split))
            .size_full()
-            .relative()
+            .v_flex()
            .child(
                div()
-                    .size_full()
+                    .flex_grow()
                    .pl_4()
                    .bg(cx.theme().colors().editor_background)
                    .child(self.editor.clone()),
            )
+            .child(div().flex_shrink().children(self.render_embedded_scope(cx)))
    }
 }

@@ -2784,8 +2968,9 @@ mod tests {
        init(cx);
        let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));

-        let conversation =
-            cx.new_model(|cx| Conversation::new(LanguageModel::default(), registry, cx));
+        let conversation = cx.new_model(|cx| {
+            Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
+        });
        let buffer = conversation.read(cx).buffer.clone();

        let message_1 = conversation.read(cx).message_anchors[0].clone();
@@ -2916,8 +3101,9 @@ mod tests {
        init(cx);
        let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));

-        let conversation =
-            cx.new_model(|cx| Conversation::new(LanguageModel::default(), registry, cx));
+        let conversation = cx.new_model(|cx| {
+            Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
+        });
        let buffer = conversation.read(cx).buffer.clone();

        let message_1 = conversation.read(cx).message_anchors[0].clone();
@@ -3015,8 +3201,9 @@ mod tests {
        cx.set_global(settings_store);
        init(cx);
        let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
-        let conversation =
-            cx.new_model(|cx| Conversation::new(LanguageModel::default(), registry, cx));
+        let conversation = cx.new_model(|cx| {
+            Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
+        });
        let buffer = conversation.read(cx).buffer.clone();

        let message_1 = conversation.read(cx).message_anchors[0].clone();
@@ -3100,8 +3287,14 @@ mod tests {
        cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
        cx.update(init);
        let registry = Arc::new(LanguageRegistry::test(cx.executor()));
-        let conversation =
-            cx.new_model(|cx| Conversation::new(LanguageModel::default(), registry.clone(), cx));
+        let conversation = cx.new_model(|cx| {
+            Conversation::new(
+                LanguageModel::default(),
+                registry.clone(),
+                EmbeddedScope::new(),
+                cx,
+            )
+        });
        let buffer = conversation.read_with(cx, |conversation, _| conversation.buffer.clone());
        let message_0 =
            conversation.read_with(cx, |conversation, _| conversation.message_anchors[0].id);
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -10,14 +10,17 @@ use serde::{
    de::{self, Visitor},
    Deserialize, Deserializer, Serialize, Serializer,
 };
-use settings::Settings;
+use settings::{Settings, SettingsSources};

 #[derive(Clone, Debug, Default, PartialEq)]
 pub enum ZedDotDevModel {
-    GptThreePointFiveTurbo,
-    GptFour,
+    Gpt3Point5Turbo,
+    Gpt4,
    #[default]
-    GptFourTurbo,
+    Gpt4Turbo,
+    Claude3Opus,
+    Claude3Sonnet,
+    Claude3Haiku,
    Custom(String),
 }

@@ -49,9 +52,9 @@ impl<'de> Deserialize<'de> for ZedDotDevModel {
                E: de::Error,
            {
                match value {
-                    "gpt-3.5-turbo" => Ok(ZedDotDevModel::GptThreePointFiveTurbo),
-                    "gpt-4" => Ok(ZedDotDevModel::GptFour),
-                    "gpt-4-turbo-preview" => Ok(ZedDotDevModel::GptFourTurbo),
+                    "gpt-3.5-turbo" => Ok(ZedDotDevModel::Gpt3Point5Turbo),
+                    "gpt-4" => Ok(ZedDotDevModel::Gpt4),
+                    "gpt-4-turbo-preview" => Ok(ZedDotDevModel::Gpt4Turbo),
                    _ => Ok(ZedDotDevModel::Custom(value.to_owned())),
                }
            }
@@ -94,21 +97,37 @@ impl JsonSchema for ZedDotDevModel {
 impl ZedDotDevModel {
    pub fn id(&self) -> &str {
        match self {
-            Self::GptThreePointFiveTurbo => "gpt-3.5-turbo",
-            Self::GptFour => "gpt-4",
-            Self::GptFourTurbo => "gpt-4-turbo-preview",
+            Self::Gpt3Point5Turbo => "gpt-3.5-turbo",
+            Self::Gpt4 => "gpt-4",
+            Self::Gpt4Turbo => "gpt-4-turbo-preview",
+            Self::Claude3Opus => "claude-3-opus",
+            Self::Claude3Sonnet => "claude-3-sonnet",
+            Self::Claude3Haiku => "claude-3-haiku",
            Self::Custom(id) => id,
        }
    }

    pub fn display_name(&self) -> &str {
        match self {
-            Self::GptThreePointFiveTurbo => "gpt-3.5-turbo",
-            Self::GptFour => "gpt-4",
-            Self::GptFourTurbo => "gpt-4-turbo",
+            Self::Gpt3Point5Turbo => "GPT 3.5 Turbo",
+            Self::Gpt4 => "GPT 4",
+            Self::Gpt4Turbo => "GPT 4 Turbo",
+            Self::Claude3Opus => "Claude 3 Opus",
+            Self::Claude3Sonnet => "Claude 3 Sonnet",
+            Self::Claude3Haiku => "Claude 3 Haiku",
            Self::Custom(id) => id.as_str(),
        }
    }
+
+    pub fn max_token_count(&self) -> usize {
+        match self {
+            Self::Gpt3Point5Turbo => 2048,
+            Self::Gpt4 => 4096,
+            Self::Gpt4Turbo => 128000,
+            Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3Haiku => 200000,
+            Self::Custom(_) => 4096, // TODO: Make this configurable
+        }
+    }
 }

 #[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema)]
@@ -151,6 +170,7 @@ fn open_ai_url() -> String {

 #[derive(Default, Debug, Deserialize, Serialize)]
 pub struct AssistantSettings {
+    pub enabled: bool,
    pub button: bool,
    pub dock: AssistantDockPosition,
    pub default_width: Pixels,
@@ -192,42 +212,26 @@ impl AssistantSettingsContent {
            AssistantSettingsContent::Versioned(settings) => match settings {
                VersionedAssistantSettingsContent::V1(settings) => settings.clone(),
            },
-            AssistantSettingsContent::Legacy(settings) => {
-                if let Some(open_ai_api_url) = settings.openai_api_url.as_ref() {
-                    AssistantSettingsContentV1 {
-                        button: settings.button,
-                        dock: settings.dock,
-                        default_width: settings.default_width,
-                        default_height: settings.default_height,
-                        provider: Some(AssistantProvider::OpenAi {
-                            default_model: settings
-                                .default_open_ai_model
-                                .clone()
-                                .unwrap_or_default(),
-                            api_url: open_ai_api_url.clone(),
-                        }),
-                    }
-                } else if let Some(open_ai_model) = settings.default_open_ai_model.clone() {
-                    AssistantSettingsContentV1 {
-                        button: settings.button,
-                        dock: settings.dock,
-                        default_width: settings.default_width,
-                        default_height: settings.default_height,
-                        provider: Some(AssistantProvider::OpenAi {
+            AssistantSettingsContent::Legacy(settings) => AssistantSettingsContentV1 {
+                enabled: None,
+                button: settings.button,
+                dock: settings.dock,
+                default_width: settings.default_width,
+                default_height: settings.default_height,
+                provider: if let Some(open_ai_api_url) = settings.openai_api_url.as_ref() {
+                    Some(AssistantProvider::OpenAi {
+                        default_model: settings.default_open_ai_model.clone().unwrap_or_default(),
+                        api_url: open_ai_api_url.clone(),
+                    })
+                } else {
+                    settings.default_open_ai_model.clone().map(|open_ai_model| {
+                        AssistantProvider::OpenAi {
                            default_model: open_ai_model,
                            api_url: open_ai_url(),
-                        }),
-                    }
-                } else {
-                    AssistantSettingsContentV1 {
-                        button: settings.button,
-                        dock: settings.dock,
-                        default_width: settings.default_width,
-                        default_height: settings.default_height,
-                        provider: None,
-                    }
-                }
-            }
+                        }
+                    })
+                },
+            },
        }
    }

@@ -255,6 +259,7 @@ pub enum VersionedAssistantSettingsContent {
 impl Default for VersionedAssistantSettingsContent {
    fn default() -> Self {
        Self::V1(AssistantSettingsContentV1 {
+            enabled: None,
            button: None,
            dock: None,
            default_width: None,
@@ -266,6 +271,10 @@ impl Default for VersionedAssistantSettingsContent {

 #[derive(Clone, Serialize, Deserialize, JsonSchema, Debug)]
 pub struct AssistantSettingsContentV1 {
+    /// Whether the Assistant is enabled.
+    ///
+    /// Default: true
+    enabled: Option<bool>,
    /// Whether to show the assistant panel button in the status bar.
    ///
    /// Default: true
@@ -323,14 +332,14 @@ impl Settings for AssistantSettings {
    type FileContent = AssistantSettingsContent;

    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
+        sources: SettingsSources<Self::FileContent>,
        _: &mut gpui::AppContext,
    ) -> anyhow::Result<Self> {
        let mut settings = AssistantSettings::default();

-        for value in [default_value].iter().chain(user_values) {
+        for value in sources.defaults_and_customizations() {
            let value = value.upgrade();
+            merge(&mut settings.enabled, value.enabled);
            merge(&mut settings.button, value.button);
            merge(&mut settings.dock, value.dock);
            merge(
@@ -383,7 +392,7 @@ fn merge<T: Copy>(target: &mut T, value: Option<T>) {

 #[cfg(test)]
 mod tests {
-    use gpui::AppContext;
+    use gpui::{AppContext, BorrowAppContext};
    use settings::SettingsStore;

    use super::*;
--- a/crates/assistant/src/completion_provider.rs
+++ b/crates/assistant/src/completion_provider.rs
@@ -15,7 +15,7 @@ use crate::{
 use anyhow::Result;
 use client::Client;
 use futures::{future::BoxFuture, stream::BoxStream};
-use gpui::{AnyView, AppContext, Task, WindowContext};
+use gpui::{AnyView, AppContext, BorrowAppContext, Task, WindowContext};
 use settings::{Settings, SettingsStore};
 use std::sync::Arc;

--- a/crates/assistant/src/completion_provider/zed.rs
+++ b/crates/assistant/src/completion_provider/zed.rs
@@ -1,5 +1,5 @@
 use crate::{
-    assistant_settings::ZedDotDevModel, count_open_ai_tokens, CompletionProvider,
+    assistant_settings::ZedDotDevModel, count_open_ai_tokens, CompletionProvider, LanguageModel,
    LanguageModelRequest,
 };
 use anyhow::{anyhow, Result};
@@ -78,13 +78,21 @@ impl ZedDotDevCompletionProvider {
        cx: &AppContext,
    ) -> BoxFuture<'static, Result<usize>> {
        match request.model {
-            crate::LanguageModel::OpenAi(_) => future::ready(Err(anyhow!("invalid model"))).boxed(),
-            crate::LanguageModel::ZedDotDev(ZedDotDevModel::GptFour)
-            | crate::LanguageModel::ZedDotDev(ZedDotDevModel::GptFourTurbo)
-            | crate::LanguageModel::ZedDotDev(ZedDotDevModel::GptThreePointFiveTurbo) => {
+            LanguageModel::OpenAi(_) => future::ready(Err(anyhow!("invalid model"))).boxed(),
+            LanguageModel::ZedDotDev(ZedDotDevModel::Gpt4)
+            | LanguageModel::ZedDotDev(ZedDotDevModel::Gpt4Turbo)
+            | LanguageModel::ZedDotDev(ZedDotDevModel::Gpt3Point5Turbo) => {
                count_open_ai_tokens(request, cx.background_executor())
            }
-            crate::LanguageModel::ZedDotDev(ZedDotDevModel::Custom(model)) => {
+            LanguageModel::ZedDotDev(
+                ZedDotDevModel::Claude3Opus
+                | ZedDotDevModel::Claude3Sonnet
+                | ZedDotDevModel::Claude3Haiku,
+            ) => {
+                // Can't find a tokenizer for Claude 3, so for now just use the same as OpenAI's as an approximation.
+                count_open_ai_tokens(request, cx.background_executor())
+            }
+            LanguageModel::ZedDotDev(ZedDotDevModel::Custom(model)) => {
                let request = self.client.request(proto::CountTokensWithLanguageModel {
                    model,
                    messages: request
--- a/crates/assistant/src/embedded_scope.rs
+++ b/crates/assistant/src/embedded_scope.rs
@@ -0,0 +1,91 @@
+use editor::MultiBuffer;
+use gpui::{AppContext, Model, ModelContext, Subscription};
+
+use crate::{assistant_panel::Conversation, LanguageModelRequestMessage, Role};
+
+#[derive(Default)]
+pub struct EmbeddedScope {
+    active_buffer: Option<Model<MultiBuffer>>,
+    active_buffer_enabled: bool,
+    active_buffer_subscription: Option<Subscription>,
+}
+
+impl EmbeddedScope {
+    pub fn new() -> Self {
+        Self {
+            active_buffer: None,
+            active_buffer_enabled: true,
+            active_buffer_subscription: None,
+        }
+    }
+
+    pub fn set_active_buffer(
+        &mut self,
+        buffer: Option<Model<MultiBuffer>>,
+        cx: &mut ModelContext<Conversation>,
+    ) {
+        self.active_buffer_subscription.take();
+
+        if let Some(active_buffer) = buffer.clone() {
+            self.active_buffer_subscription =
+                Some(cx.subscribe(&active_buffer, |conversation, _, e, cx| {
+                    if let multi_buffer::Event::Edited { .. } = e {
+                        conversation.count_remaining_tokens(cx)
+                    }
+                }));
+        }
+
+        self.active_buffer = buffer;
+    }
+
+    pub fn active_buffer(&self) -> Option<&Model<MultiBuffer>> {
+        self.active_buffer.as_ref()
+    }
+
+    pub fn active_buffer_enabled(&self) -> bool {
+        self.active_buffer_enabled
+    }
+
+    pub fn set_active_buffer_enabled(&mut self, enabled: bool) {
+        self.active_buffer_enabled = enabled;
+    }
+
+    /// Provide a message for the language model based on the active buffer.
+    pub fn message(&self, cx: &AppContext) -> Option<LanguageModelRequestMessage> {
+        if !self.active_buffer_enabled {
+            return None;
+        }
+
+        let active_buffer = self.active_buffer.as_ref()?;
+        let buffer = active_buffer.read(cx);
+
+        if let Some(singleton) = buffer.as_singleton() {
+            let singleton = singleton.read(cx);
+
+            let filename = singleton
+                .file()
+                .map(|file| file.path().to_string_lossy())
+                .unwrap_or("Untitled".into());
+
+            let text = singleton.text();
+
+            let language = singleton
+                .language()
+                .map(|l| {
+                    let name = l.code_fence_block_name();
+                    name.to_string()
+                })
+                .unwrap_or_default();
+
+            let markdown =
+                format!("User's active file `{filename}`:\n\n```{language}\n{text}```\n\n");
+
+            return Some(LanguageModelRequestMessage {
+                role: Role::System,
+                content: markdown,
+            });
+        }
+
+        None
+    }
+}
--- a/crates/audio/src/audio.rs
+++ b/crates/audio/src/audio.rs
@@ -1,6 +1,6 @@
 use assets::SoundRegistry;
 use derive_more::{Deref, DerefMut};
-use gpui::{AppContext, AssetSource, Global};
+use gpui::{AppContext, AssetSource, BorrowAppContext, Global};
 use rodio::{OutputStream, OutputStreamHandle};
 use util::ResultExt;

--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -11,13 +11,13 @@ use gpui::{
 };
 use isahc::AsyncBody;

-use markdown_preview::markdown_preview_view::MarkdownPreviewView;
+use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde_derive::Serialize;
 use smol::io::AsyncReadExt;

-use settings::{Settings, SettingsStore};
+use settings::{Settings, SettingsSources, SettingsStore};
 use smol::{fs::File, process::Command};

 use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
@@ -82,25 +82,22 @@ struct AutoUpdateSetting(bool);
 /// Whether or not to automatically check for updates.
 ///
 /// Default: true
-#[derive(Clone, Default, JsonSchema, Deserialize, Serialize)]
+#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize)]
 #[serde(transparent)]
-struct AutoUpdateSettingOverride(Option<bool>);
+struct AutoUpdateSettingContent(bool);

 impl Settings for AutoUpdateSetting {
    const KEY: Option<&'static str> = Some("auto_update");

-    type FileContent = AutoUpdateSettingOverride;
+    type FileContent = Option<AutoUpdateSettingContent>;

-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _: &mut AppContext,
-    ) -> Result<Self> {
-        Ok(Self(
-            Self::json_merge(default_value, user_values)?
-                .0
-                .ok_or_else(Self::missing_default)?,
-        ))
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
+        let auto_update = [sources.release_channel, sources.user]
+            .into_iter()
+            .find_map(|value| value.copied().flatten())
+            .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
+
+        Ok(Self(auto_update.0))
    }
 }

@@ -238,10 +235,11 @@ fn view_release_notes_locally(workspace: &mut Workspace, cx: &mut ViewContext<Wo
                                .new_view(|cx| Editor::for_multibuffer(buffer, Some(project), cx));
                            let workspace_handle = workspace.weak_handle();
                            let view: View<MarkdownPreviewView> = MarkdownPreviewView::new(
+                                MarkdownPreviewMode::Default,
                                editor,
                                workspace_handle,
-                                Some(tab_description),
                                language_registry,
+                                Some(tab_description),
                                cx,
                            );
                            workspace.add_item_to_active_pane(Box::new(view.clone()), cx);
--- a/crates/call/src/call.rs
+++ b/crates/call/src/call.rs
@@ -373,7 +373,10 @@ impl ActiveCall {
        self.report_call_event("hang up", cx);

        Audio::end_call(cx);
+
+        let channel_id = self.channel_id(cx);
        if let Some((room, _)) = self.room.take() {
+            cx.emit(Event::RoomLeft { channel_id });
            room.update(cx, |room, cx| room.leave(cx))
        } else {
            Task::ready(Ok(()))
--- a/crates/call/src/call_settings.rs
+++ b/crates/call/src/call_settings.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use gpui::AppContext;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
-use settings::Settings;
+use settings::{Settings, SettingsSources};

 #[derive(Deserialize, Debug)]
 pub struct CallSettings {
@@ -29,14 +29,7 @@ impl Settings for CallSettings {

    type FileContent = CallSettingsContent;

-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _cx: &mut AppContext,
-    ) -> Result<Self>
-    where
-        Self: Sized,
-    {
-        Self::load_via_json_merge(default_value, user_values)
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
+        sources.json_merge()
    }
 }
--- a/crates/call/src/room.rs
+++ b/crates/call/src/room.rs
@@ -52,7 +52,7 @@ pub enum Event {
    RemoteProjectInvitationDiscarded {
        project_id: u64,
    },
-    Left {
+    RoomLeft {
        channel_id: Option<ChannelId>,
    },
 }
@@ -366,9 +366,6 @@ impl Room {

    pub(crate) fn leave(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
        cx.notify();
-        cx.emit(Event::Left {
-            channel_id: self.channel_id(),
-        });
        self.leave_internal(cx)
    }

--- a/crates/channel/src/channel_chat.rs
+++ b/crates/channel/src/channel_chat.rs
@@ -222,6 +222,9 @@ impl ChannelChat {
            let message = ChannelMessage::from_proto(response, &user_store, &mut cx).await?;
            this.update(&mut cx, |this, cx| {
                this.insert_messages(SumTree::from_item(message, &()), cx);
+                if this.first_loaded_message_id.is_none() {
+                    this.first_loaded_message_id = Some(id);
+                }
            })?;
            Ok(id)
        }))
--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -17,7 +17,7 @@ use rpc::{
 };
 use settings::Settings;
 use std::{mem, sync::Arc, time::Duration};
-use util::{async_maybe, maybe, ResultExt};
+use util::{maybe, ResultExt};

 pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);

@@ -227,7 +227,7 @@ impl ChannelStore {
            _watch_connection_status: watch_connection_status,
            disconnect_channel_buffers_task: None,
            _update_channels: cx.spawn(|this, mut cx| async move {
-                async_maybe!({
+                maybe!(async move {
                    while let Some(update_channels) = update_channels_rx.next().await {
                        if let Some(this) = this.upgrade() {
                            let update_task = this.update(&mut cx, |this, cx| {
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(target_os = "linux", allow(dead_code))]
+#![cfg_attr(any(target_os = "linux", target_os = "windows"), allow(dead_code))]

 use anyhow::{anyhow, Context, Result};
 use clap::Parser;
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -17,7 +17,8 @@ use futures::{
    TryFutureExt as _, TryStreamExt,
 };
 use gpui::{
-    actions, AnyModel, AnyWeakModel, AppContext, AsyncAppContext, Global, Model, Task, WeakModel,
+    actions, AnyModel, AnyWeakModel, AppContext, AsyncAppContext, BorrowAppContext, Global, Model,
+    Task, WeakModel,
 };
 use lazy_static::lazy_static;
 use parking_lot::RwLock;
@@ -27,8 +28,8 @@ use release_channel::{AppVersion, ReleaseChannel};
 use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, RequestMessage};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-
-use settings::{Settings, SettingsStore};
+use settings::{Settings, SettingsSources, SettingsStore};
+use std::fmt;
 use std::{
    any::TypeId,
    convert::TryFrom,
@@ -52,6 +53,15 @@ pub use rpc::*;
 pub use telemetry_events::Event;
 pub use user::*;

+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct DevServerToken(pub String);
+
+impl fmt::Display for DevServerToken {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 lazy_static! {
    static ref ZED_SERVER_URL: Option<String> = std::env::var("ZED_SERVER_URL").ok();
    static ref ZED_RPC_URL: Option<String> = std::env::var("ZED_RPC_URL").ok();
@@ -87,15 +97,8 @@ impl Settings for ClientSettings {

    type FileContent = ClientSettingsContent;

-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _: &mut AppContext,
-    ) -> Result<Self>
-    where
-        Self: Sized,
-    {
-        let mut result = Self::load_via_json_merge(default_value, user_values)?;
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
+        let mut result = sources.json_merge::<Self>()?;
        if let Some(server_url) = &*ZED_SERVER_URL {
            result.server_url = server_url.clone()
        }
@@ -277,10 +280,22 @@ enum WeakSubscriber {
    Pending(Vec<Box<dyn AnyTypedEnvelope>>),
 }

-#[derive(Clone, Debug)]
-pub struct Credentials {
-    pub user_id: u64,
-    pub access_token: String,
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Credentials {
+    DevServer { token: DevServerToken },
+    User { user_id: u64, access_token: String },
+}
+
+impl Credentials {
+    pub fn authorization_header(&self) -> String {
+        match self {
+            Credentials::DevServer { token } => format!("dev-server-token {}", token),
+            Credentials::User {
+                user_id,
+                access_token,
+            } => format!("{} {}", user_id, access_token),
+        }
+    }
 }

 impl Default for ClientState {
@@ -405,21 +420,19 @@ impl settings::Settings for TelemetrySettings {

    type FileContent = TelemetrySettingsContent;

-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _: &mut AppContext,
-    ) -> Result<Self> {
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
        Ok(Self {
-            diagnostics: user_values.first().and_then(|v| v.diagnostics).unwrap_or(
-                default_value
+            diagnostics: sources.user.as_ref().and_then(|v| v.diagnostics).unwrap_or(
+                sources
+                    .default
                    .diagnostics
                    .ok_or_else(Self::missing_default)?,
            ),
-            metrics: user_values
-                .first()
+            metrics: sources
+                .user
+                .as_ref()
                .and_then(|v| v.metrics)
-                .unwrap_or(default_value.metrics.ok_or_else(Self::missing_default)?),
+                .unwrap_or(sources.default.metrics.ok_or_else(Self::missing_default)?),
        })
    }
 }
@@ -497,11 +510,11 @@ impl Client {
    }

    pub fn user_id(&self) -> Option<u64> {
-        self.state
-            .read()
-            .credentials
-            .as_ref()
-            .map(|credentials| credentials.user_id)
+        if let Some(Credentials::User { user_id, .. }) = self.state.read().credentials.as_ref() {
+            Some(*user_id)
+        } else {
+            None
+        }
    }

    pub fn peer_id(&self) -> Option<PeerId> {
@@ -746,6 +759,10 @@ impl Client {
        read_credentials_from_keychain(cx).await.is_some()
    }

+    pub fn set_dev_server_token(&self, token: DevServerToken) {
+        self.state.write().credentials = Some(Credentials::DevServer { token });
+    }
+
    #[async_recursion(?Send)]
    pub async fn authenticate_and_connect(
        self: &Arc<Self>,
@@ -764,7 +781,6 @@ impl Client {
            }
            Status::UpgradeRequired => return Err(EstablishConnectionError::UpgradeRequired)?,
        };
-
        if was_disconnected {
            self.set_status(Status::Authenticating, cx);
        } else {
@@ -796,7 +812,9 @@ impl Client {
            }
        }
        let credentials = credentials.unwrap();
-        self.set_id(credentials.user_id);
+        if let Credentials::User { user_id, .. } = &credentials {
+            self.set_id(*user_id);
+        }

        if was_disconnected {
            self.set_status(Status::Connecting, cx);
@@ -812,7 +830,9 @@ impl Client {
                    Ok(conn) => {
                        self.state.write().credentials = Some(credentials.clone());
                        if !read_from_keychain && IMPERSONATE_LOGIN.is_none() {
-                            write_credentials_to_keychain(credentials, cx).await.log_err();
+                            if let Credentials::User{user_id, access_token} = credentials {
+                                write_credentials_to_keychain(user_id, access_token, cx).await.log_err();
+                            }
                        }

                        futures::select_biased! {
@@ -1020,10 +1040,7 @@ impl Client {
            .unwrap_or_default();

        let request = Request::builder()
-            .header(
-                "Authorization",
-                format!("{} {}", credentials.user_id, credentials.access_token),
-            )
+            .header("Authorization", credentials.authorization_header())
            .header("x-zed-protocol-version", rpc::PROTOCOL_VERSION)
            .header("x-zed-app-version", app_version)
            .header(
@@ -1176,7 +1193,7 @@ impl Client {
                        .decrypt_string(&access_token)
                        .context("failed to decrypt access token")?;

-                    Ok(Credentials {
+                    Ok(Credentials::User {
                        user_id: user_id.parse()?,
                        access_token,
                    })
@@ -1226,7 +1243,7 @@ impl Client {

        // Use the admin API token to authenticate as the impersonated user.
        api_token.insert_str(0, "ADMIN_TOKEN:");
-        Ok(Credentials {
+        Ok(Credentials::User {
            user_id: response.user.id,
            access_token: api_token,
        })
@@ -1439,21 +1456,22 @@ async fn read_credentials_from_keychain(cx: &AsyncAppContext) -> Option<Credenti
        .await
        .log_err()??;

-    Some(Credentials {
+    Some(Credentials::User {
        user_id: user_id.parse().ok()?,
        access_token: String::from_utf8(access_token).ok()?,
    })
 }

 async fn write_credentials_to_keychain(
-    credentials: Credentials,
+    user_id: u64,
+    access_token: String,
    cx: &AsyncAppContext,
 ) -> Result<()> {
    cx.update(move |cx| {
        cx.write_credentials(
            &ClientSettings::get_global(cx).server_url,
-            &credentials.user_id.to_string(),
-            credentials.access_token.as_bytes(),
+            &user_id.to_string(),
+            access_token.as_bytes(),
        )
    })?
    .await
@@ -1558,7 +1576,7 @@ mod tests {
        // Time out when client tries to connect.
        client.override_authenticate(move |cx| {
            cx.background_executor().spawn(async move {
-                Ok(Credentials {
+                Ok(Credentials::User {
                    user_id,
                    access_token: "token".into(),
                })
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -15,7 +15,8 @@ use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
 use sysinfo::{CpuRefreshKind, MemoryRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
 use telemetry_events::{
    ActionEvent, AppEvent, AssistantEvent, AssistantKind, CallEvent, CopilotEvent, CpuEvent,
-    EditEvent, EditorEvent, Event, EventRequestBody, EventWrapper, MemoryEvent, SettingEvent,
+    EditEvent, EditorEvent, Event, EventRequestBody, EventWrapper, ExtensionEvent, MemoryEvent,
+    SettingEvent,
 };
 use tempfile::NamedTempFile;
 use util::http::{self, HttpClient, HttpClientWithUrl, Method};
@@ -326,6 +327,13 @@ impl Telemetry {
        self.report_event(event)
    }

+    pub fn report_extension_event(self: &Arc<Self>, extension_id: Arc<str>, version: Arc<str>) {
+        self.report_event(Event::Extension(ExtensionEvent {
+            extension_id,
+            version,
+        }))
+    }
+
    pub fn log_edit_event(self: &Arc<Self>, environment: &'static str) {
        let mut state = self.state.lock();
        let period_data = state.event_coalescer.log_event(environment);
@@ -470,7 +478,11 @@ impl Telemetry {

                    let request = http::Request::builder()
                        .method(Method::POST)
-                        .uri(this.http_client.build_zed_api_url("/telemetry/events"))
+                        .uri(
+                            this.http_client
+                                .build_zed_api_url("/telemetry/events", &[])?
+                                .as_ref(),
+                        )
                        .header("Content-Type", "text/plain")
                        .header("x-zed-checksum", checksum)
                        .body(json_bytes.into());
@@ -578,7 +590,10 @@ mod tests {
    }

    #[gpui::test]
-    async fn test_connection_timeout(executor: BackgroundExecutor, cx: &mut TestAppContext) {
+    async fn test_telemetry_flush_on_flush_interval(
+        executor: BackgroundExecutor,
+        cx: &mut TestAppContext,
+    ) {
        init_test(cx);
        let clock = Arc::new(FakeSystemClock::new(
            Utc.with_ymd_and_hms(1990, 4, 12, 12, 0, 0).unwrap(),
--- a/crates/client/src/test.rs
+++ b/crates/client/src/test.rs
@@ -48,7 +48,7 @@ impl FakeServer {
                        let mut state = state.lock();
                        state.auth_count += 1;
                        let access_token = state.access_token.to_string();
-                        Ok(Credentials {
+                        Ok(Credentials::User {
                            user_id: client_user_id,
                            access_token,
                        })
@@ -71,9 +71,12 @@ impl FakeServer {
                            )))?
                        }

-                        assert_eq!(credentials.user_id, client_user_id);
-
-                        if credentials.access_token != state.lock().access_token.to_string() {
+                        if credentials
+                            != (Credentials::User {
+                                user_id: client_user_id,
+                                access_token: state.lock().access_token.to_string(),
+                            })
+                        {
                            Err(EstablishConnectionError::Unauthorized)?
                        }

--- a/crates/collab/.admins.default.json
+++ b/crates/collab/.admins.default.json
@@ -1,8 +0,0 @@
-[
-  "nathansobo",
-  "as-cii",
-  "maxbrunsfeld",
-  "iamnbutler",
-  "mikayla-maki",
-  "JosephTLyons"
-]
--- a/crates/collab/.env.toml
+++ b/crates/collab/.env.toml
@@ -1,4 +1,5 @@
 DATABASE_URL = "postgres://postgres@localhost/zed"
+# DATABASE_URL = "sqlite:////home/zed/.config/zed/db.sqlite3?mode=rwc"
 DATABASE_MAX_CONNECTIONS = 5
 HTTP_PORT = 8080
 API_TOKEN = "secret"
@@ -13,6 +14,7 @@ BLOB_STORE_BUCKET = "the-extensions-bucket"
 BLOB_STORE_URL = "http://127.0.0.1:9000"
 BLOB_STORE_REGION = "the-region"
 ZED_CLIENT_CHECKSUM_SEED = "development-checksum-seed"
+SEED_PATH = "crates/collab/seed.default.json"

 # CLICKHOUSE_URL = ""
 # CLICKHOUSE_USER = "default"
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -13,10 +13,12 @@ workspace = true
 [[bin]]
 name = "collab"

-[[bin]]
-name = "seed"
+[features]
+sqlite = ["sea-orm/sqlx-sqlite", "sqlx/sqlite"]
+test-support = ["sqlite"]

 [dependencies]
+anthropic.workspace = true
 anyhow.workspace = true
 async-tungstenite = "0.16"
 aws-config = { version = "1.1.5" }
@@ -45,6 +47,7 @@ reqwest = { version = "0.11", features = ["json"] }
 rpc.workspace = true
 scrypt = "0.7"
 sea-orm = { version = "0.12.x", features = ["sqlx-postgres", "postgres-array", "runtime-tokio-rustls", "with-uuid"] }
+semantic_version.workspace = true
 semver.workspace = true
 serde.workspace = true
 serde_derive.workspace = true
--- a/crates/collab/README.md
+++ b/crates/collab/README.md
@@ -6,21 +6,21 @@ It contains our back-end logic for collaboration, to which we connect from the Z

 # Local Development

- Detailed instructions on getting started are [here](https://zed.dev/docs/local-collaboration).
+Detailed instructions on getting started are [here](https://zed.dev/docs/local-collaboration).

 # Deployment

 We run two instances of collab:

-* Staging (https://staging-collab.zed.dev)
-* Production (https://collab.zed.dev)
+- Staging (https://staging-collab.zed.dev)
+- Production (https://collab.zed.dev)

 Both of these run on the Kubernetes cluster hosted in Digital Ocean.

 Deployment is triggered by pushing to the `collab-staging` (or `collab-production`) tag in Github. The best way to do this is:

-* `./script/deploy-collab staging`
-* `./script/deploy-collab production`
+- `./script/deploy-collab staging`
+- `./script/deploy-collab production`

 You can tell what is currently deployed with `./script/what-is-deployed`.

@@ -29,7 +29,7 @@ You can tell what is currently deployed with `./script/what-is-deployed`.
 To create a new migration:

 ```
-./script/sqlx migrate add <name>
+./script/create-migration <name>
 ```

 Migrations are run automatically on service start, so run `foreman start` again. The service will crash if the migrations fail.
--- a/crates/collab/basic.conf
+++ b/crates/collab/basic.conf
@@ -1,12 +0,0 @@
-
-[Interface]
-PrivateKey = B5Fp/yVfP0QYlb+YJv9ea+EMI1mWODPD3akh91cVjvc=
-Address = fdaa:0:2ce3:a7b:bea:0:a:2/120
-DNS = fdaa:0:2ce3::3
-
-[Peer]
-PublicKey = RKAYPljEJiuaELNDdQIEJmQienT9+LRISfIHwH45HAw=
-AllowedIPs = fdaa:0:2ce3::/48
-Endpoint = ord1.gateway.6pn.dev:51820
-PersistentKeepalive = 15
-
--- a/crates/collab/k8s/collab.template.yml
+++ b/crates/collab/k8s/collab.template.yml
@@ -47,19 +47,6 @@ spec:
    metadata:
      labels:
        app: ${ZED_SERVICE_NAME}
-      annotations:
-        ad.datadoghq.com/collab.check_names: |
-          ["openmetrics"]
-        ad.datadoghq.com/collab.init_configs: |
-          [{}]
-        ad.datadoghq.com/collab.instances: |
-          [
-              {
-              "openmetrics_endpoint": "http://%%host%%:%%port%%/metrics",
-              "namespace": "collab_${ZED_KUBE_NAMESPACE}",
-              "metrics": [".*"]
-              }
-          ]
    spec:
      containers:
        - name: ${ZED_SERVICE_NAME}
@@ -125,6 +112,16 @@ spec:
                secretKeyRef:
                  name: livekit
                  key: secret
+            - name: OPENAI_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: openai
+                  key: api_key
+            - name: ANTHROPIC_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: anthropic
+                  key: api_key
            - name: BLOB_STORE_ACCESS_KEY
              valueFrom:
                secretKeyRef:
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -373,6 +373,8 @@ CREATE TABLE extension_versions (
    authors TEXT NOT NULL,
    repository TEXT NOT NULL,
    description TEXT NOT NULL,
+    schema_version INTEGER NOT NULL DEFAULT 0,
+    wasm_api_version TEXT,
    download_count INTEGER NOT NULL DEFAULT 0,
    PRIMARY KEY (extension_id, version)
 );
@@ -399,3 +401,11 @@ CREATE TABLE hosted_projects (
 );
 CREATE INDEX idx_hosted_projects_on_channel_id ON hosted_projects (channel_id);
 CREATE UNIQUE INDEX uix_hosted_projects_on_channel_id_and_name ON hosted_projects (channel_id, name) WHERE (deleted_at IS NULL);
+
+CREATE TABLE dev_servers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    channel_id INTEGER NOT NULL REFERENCES channels(id),
+    name TEXT NOT NULL,
+    hashed_token TEXT NOT NULL
+);
+CREATE INDEX idx_dev_servers_on_channel_id ON dev_servers (channel_id);
--- a/crates/collab/migrations/20240320124800_add_extension_schema_version.sql
+++ b/crates/collab/migrations/20240320124800_add_extension_schema_version.sql
@@ -0,0 +1,2 @@
+-- Add migration script here
+ALTER TABLE extension_versions ADD COLUMN schema_version INTEGER NOT NULL DEFAULT 0;
--- a/crates/collab/migrations/20240321162658_add_devservers.sql
+++ b/crates/collab/migrations/20240321162658_add_devservers.sql
@@ -0,0 +1,7 @@
+CREATE TABLE dev_servers (
+  id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+  channel_id INT NOT NULL REFERENCES channels(id),
+  name TEXT NOT NULL,
+  hashed_token TEXT NOT NULL
+);
+CREATE INDEX idx_dev_servers_on_channel_id ON dev_servers (channel_id);
--- a/crates/collab/migrations/20240335123500_add_extension_wasm_api_version.sql
+++ b/crates/collab/migrations/20240335123500_add_extension_wasm_api_version.sql
@@ -0,0 +1 @@
+ALTER TABLE extension_versions ADD COLUMN wasm_api_version TEXT;
--- a/crates/collab/seed.default.json
+++ b/crates/collab/seed.default.json
@@ -0,0 +1,12 @@
+{
+  "admins": [
+    "nathansobo",
+    "as-cii",
+    "maxbrunsfeld",
+    "iamnbutler",
+    "mikayla-maki",
+    "JosephTLyons"
+  ],
+  "channels": ["zed"],
+  "number_of_users": 100
+}
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -1,5 +1,5 @@
-use std::sync::{Arc, OnceLock};
-
+use super::ips_file::IpsFile;
+use crate::{api::slack, AppState, Error, Result};
 use anyhow::{anyhow, Context};
 use aws_sdk_s3::primitives::ByteStream;
 use axum::{
@@ -9,17 +9,15 @@ use axum::{
    routing::post,
    Extension, Router, TypedHeader,
 };
+use rpc::ExtensionMetadata;
+use semantic_version::SemanticVersion;
 use serde::{Serialize, Serializer};
 use sha2::{Digest, Sha256};
+use std::sync::{Arc, OnceLock};
 use telemetry_events::{
    ActionEvent, AppEvent, AssistantEvent, CallEvent, CopilotEvent, CpuEvent, EditEvent,
-    EditorEvent, Event, EventRequestBody, EventWrapper, MemoryEvent, SettingEvent,
+    EditorEvent, Event, EventRequestBody, EventWrapper, ExtensionEvent, MemoryEvent, SettingEvent,
 };
-use util::SemanticVersion;
-
-use crate::{api::slack, AppState, Error, Result};
-
-use super::ips_file::IpsFile;

 pub fn router() -> Router {
    Router::new()
@@ -331,6 +329,21 @@ pub async fn post_events(
                &request_body,
                first_event_at,
            )),
+            Event::Extension(event) => {
+                let metadata = app
+                    .db
+                    .get_extension_version(&event.extension_id, &event.version)
+                    .await?;
+                to_upload
+                    .extension_events
+                    .push(ExtensionEventRow::from_event(
+                        event.clone(),
+                        &wrapper,
+                        &request_body,
+                        metadata,
+                        first_event_at,
+                    ))
+            }
        }
    }

@@ -352,6 +365,7 @@ struct ToUpload {
    memory_events: Vec<MemoryEventRow>,
    app_events: Vec<AppEventRow>,
    setting_events: Vec<SettingEventRow>,
+    extension_events: Vec<ExtensionEventRow>,
    edit_events: Vec<EditEventRow>,
    action_events: Vec<ActionEventRow>,
 }
@@ -410,6 +424,15 @@ impl ToUpload {
        .await
        .with_context(|| format!("failed to upload to table '{SETTING_EVENTS_TABLE}'"))?;

+        const EXTENSION_EVENTS_TABLE: &str = "extension_events";
+        Self::upload_to_table(
+            EXTENSION_EVENTS_TABLE,
+            &self.extension_events,
+            clickhouse_client,
+        )
+        .await
+        .with_context(|| format!("failed to upload to table '{EXTENSION_EVENTS_TABLE}'"))?;
+
        const EDIT_EVENTS_TABLE: &str = "edit_events";
        Self::upload_to_table(EDIT_EVENTS_TABLE, &self.edit_events, clickhouse_client)
            .await
@@ -436,6 +459,12 @@ impl ToUpload {
            }

            insert.end().await?;
+
+            let event_count = rows.len();
+            log::info!(
+                "wrote {event_count} {event_specifier} to '{table}'",
+                event_specifier = if event_count == 1 { "event" } else { "events" }
+            );
        }

        Ok(())
@@ -499,9 +528,9 @@ impl EditorEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            os_name: body.os_name.clone(),
            os_version: body.os_version.clone().unwrap_or_default(),
@@ -561,9 +590,9 @@ impl CopilotEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            os_name: body.os_name.clone(),
            os_version: body.os_version.clone().unwrap_or_default(),
@@ -616,9 +645,9 @@ impl CallEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone().unwrap_or_default(),
            session_id: body.session_id.clone(),
@@ -665,9 +694,9 @@ impl AssistantEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
@@ -709,9 +738,9 @@ impl CpuEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
@@ -756,9 +785,9 @@ impl MemoryEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
@@ -802,9 +831,9 @@ impl AppEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
@@ -847,9 +876,9 @@ impl SettingEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
@@ -861,6 +890,68 @@ impl SettingEventRow {
    }
 }

+#[derive(Serialize, Debug, clickhouse::Row)]
+pub struct ExtensionEventRow {
+    // AppInfoBase
+    app_version: String,
+    major: Option<i32>,
+    minor: Option<i32>,
+    patch: Option<i32>,
+    release_channel: String,
+
+    // ClientEventBase
+    installation_id: Option<String>,
+    session_id: Option<String>,
+    is_staff: Option<bool>,
+    time: i64,
+
+    // ExtensionEventRow
+    extension_id: Arc<str>,
+    extension_version: Arc<str>,
+    dev: bool,
+    schema_version: Option<i32>,
+    wasm_api_version: Option<String>,
+}
+
+impl ExtensionEventRow {
+    fn from_event(
+        event: ExtensionEvent,
+        wrapper: &EventWrapper,
+        body: &EventRequestBody,
+        extension_metadata: Option<ExtensionMetadata>,
+        first_event_at: chrono::DateTime<chrono::Utc>,
+    ) -> Self {
+        let semver = body.semver();
+        let time =
+            first_event_at + chrono::Duration::milliseconds(wrapper.milliseconds_since_first_event);
+
+        Self {
+            app_version: body.app_version.clone(),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
+            release_channel: body.release_channel.clone().unwrap_or_default(),
+            installation_id: body.installation_id.clone(),
+            session_id: body.session_id.clone(),
+            is_staff: body.is_staff,
+            time: time.timestamp_millis(),
+            extension_id: event.extension_id,
+            extension_version: event.version,
+            dev: extension_metadata.is_none(),
+            schema_version: extension_metadata
+                .as_ref()
+                .and_then(|metadata| metadata.manifest.schema_version),
+            wasm_api_version: extension_metadata.as_ref().and_then(|metadata| {
+                metadata
+                    .manifest
+                    .wasm_api_version
+                    .as_ref()
+                    .map(|version| version.to_string())
+            }),
+        }
+    }
+}
+
 #[derive(Serialize, Debug, clickhouse::Row)]
 pub struct EditEventRow {
    // AppInfoBase
@@ -900,9 +991,9 @@ impl EditEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
@@ -949,9 +1040,9 @@ impl ActionEventRow {

        Self {
            app_version: body.app_version.clone(),
-            major: semver.map(|s| s.major as i32),
-            minor: semver.map(|s| s.minor as i32),
-            patch: semver.map(|s| s.patch as i32),
+            major: semver.map(|v| v.major() as i32),
+            minor: semver.map(|v| v.minor() as i32),
+            patch: semver.map(|v| v.patch() as i32),
            release_channel: body.release_channel.clone().unwrap_or_default(),
            installation_id: body.installation_id.clone(),
            session_id: body.session_id.clone(),
--- a/crates/collab/src/api/extensions.rs
+++ b/crates/collab/src/api/extensions.rs
@@ -1,7 +1,5 @@
-use crate::{
-    db::{ExtensionMetadata, NewExtensionVersion},
-    AppState, Error, Result,
-};
+use crate::db::ExtensionVersionConstraints;
+use crate::{db::NewExtensionVersion, AppState, Error, Result};
 use anyhow::{anyhow, Context as _};
 use aws_sdk_s3::presigning::PresigningConfig;
 use axum::{
@@ -12,14 +10,18 @@ use axum::{
    Extension, Json, Router,
 };
 use collections::HashMap;
-use serde::{Deserialize, Serialize};
+use rpc::{ExtensionApiManifest, GetExtensionsResponse};
+use semantic_version::SemanticVersion;
+use serde::Deserialize;
 use std::{sync::Arc, time::Duration};
 use time::PrimitiveDateTime;
-use util::ResultExt;
+use util::{maybe, ResultExt};

 pub fn router() -> Router {
    Router::new()
        .route("/extensions", get(get_extensions))
+        .route("/extensions/updates", get(get_extension_updates))
+        .route("/extensions/:extension_id", get(get_extension_versions))
        .route(
            "/extensions/:extension_id/download",
            get(download_latest_extension),
@@ -33,60 +35,122 @@ pub fn router() -> Router {
 #[derive(Debug, Deserialize)]
 struct GetExtensionsParams {
    filter: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct DownloadLatestExtensionParams {
-    extension_id: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct DownloadExtensionParams {
-    extension_id: String,
-    version: String,
-}
-
-#[derive(Debug, Serialize)]
-struct GetExtensionsResponse {
-    pub data: Vec<ExtensionMetadata>,
-}
-
-#[derive(Deserialize)]
-struct ExtensionManifest {
-    name: String,
-    version: String,
-    description: Option<String>,
-    authors: Vec<String>,
-    repository: String,
+    #[serde(default)]
+    ids: Option<String>,
+    #[serde(default)]
+    max_schema_version: i32,
 }

 async fn get_extensions(
    Extension(app): Extension<Arc<AppState>>,
    Query(params): Query<GetExtensionsParams>,
 ) -> Result<Json<GetExtensionsResponse>> {
-    let extensions = app.db.get_extensions(params.filter.as_deref(), 500).await?;
+    let extension_ids = params
+        .ids
+        .as_ref()
+        .map(|s| s.split(',').map(|s| s.trim()).collect::<Vec<_>>());
+
+    let extensions = if let Some(extension_ids) = extension_ids {
+        app.db.get_extensions_by_ids(&extension_ids, None).await?
+    } else {
+        app.db
+            .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
+            .await?
+    };
+
    Ok(Json(GetExtensionsResponse { data: extensions }))
 }

+#[derive(Debug, Deserialize)]
+struct GetExtensionUpdatesParams {
+    ids: String,
+    min_schema_version: i32,
+    max_schema_version: i32,
+    min_wasm_api_version: SemanticVersion,
+    max_wasm_api_version: SemanticVersion,
+}
+
+async fn get_extension_updates(
+    Extension(app): Extension<Arc<AppState>>,
+    Query(params): Query<GetExtensionUpdatesParams>,
+) -> Result<Json<GetExtensionsResponse>> {
+    let constraints = ExtensionVersionConstraints {
+        schema_versions: params.min_schema_version..=params.max_schema_version,
+        wasm_api_versions: params.min_wasm_api_version..=params.max_wasm_api_version,
+    };
+
+    let extension_ids = params.ids.split(',').map(|s| s.trim()).collect::<Vec<_>>();
+
+    let extensions = app
+        .db
+        .get_extensions_by_ids(&extension_ids, Some(&constraints))
+        .await?;
+
+    Ok(Json(GetExtensionsResponse { data: extensions }))
+}
+
+#[derive(Debug, Deserialize)]
+struct GetExtensionVersionsParams {
+    extension_id: String,
+}
+
+async fn get_extension_versions(
+    Extension(app): Extension<Arc<AppState>>,
+    Path(params): Path<GetExtensionVersionsParams>,
+) -> Result<Json<GetExtensionsResponse>> {
+    let extension_versions = app.db.get_extension_versions(&params.extension_id).await?;
+
+    Ok(Json(GetExtensionsResponse {
+        data: extension_versions,
+    }))
+}
+
+#[derive(Debug, Deserialize)]
+struct DownloadLatestExtensionParams {
+    extension_id: String,
+    min_schema_version: Option<i32>,
+    max_schema_version: Option<i32>,
+    min_wasm_api_version: Option<SemanticVersion>,
+    max_wasm_api_version: Option<SemanticVersion>,
+}
+
 async fn download_latest_extension(
    Extension(app): Extension<Arc<AppState>>,
    Path(params): Path<DownloadLatestExtensionParams>,
 ) -> Result<Redirect> {
+    let constraints = maybe!({
+        let min_schema_version = params.min_schema_version?;
+        let max_schema_version = params.max_schema_version?;
+        let min_wasm_api_version = params.min_wasm_api_version?;
+        let max_wasm_api_version = params.max_wasm_api_version?;
+
+        Some(ExtensionVersionConstraints {
+            schema_versions: min_schema_version..=max_schema_version,
+            wasm_api_versions: min_wasm_api_version..=max_wasm_api_version,
+        })
+    });
+
    let extension = app
        .db
-        .get_extension(&params.extension_id)
+        .get_extension(&params.extension_id, constraints.as_ref())
        .await?
        .ok_or_else(|| anyhow!("unknown extension"))?;
    download_extension(
        Extension(app),
        Path(DownloadExtensionParams {
            extension_id: params.extension_id,
-            version: extension.version,
+            version: extension.manifest.version.to_string(),
        }),
    )
    .await
 }

+#[derive(Debug, Deserialize)]
+struct DownloadExtensionParams {
+    extension_id: String,
+    version: String,
+}
+
 async fn download_extension(
    Extension(app): Extension<Arc<AppState>>,
    Path(params): Path<DownloadExtensionParams>,
@@ -267,7 +331,7 @@ async fn fetch_extension_manifest(
        })?
        .to_vec();
    let manifest =
-        serde_json::from_slice::<ExtensionManifest>(&manifest_bytes).with_context(|| {
+        serde_json::from_slice::<ExtensionApiManifest>(&manifest_bytes).with_context(|| {
            format!(
                "invalid manifest for extension {extension_id} version {version}: {}",
                String::from_utf8_lossy(&manifest_bytes)
@@ -287,6 +351,8 @@ async fn fetch_extension_manifest(
        description: manifest.description.unwrap_or_default(),
        authors: manifest.authors,
        repository: manifest.repository,
+        schema_version: manifest.schema_version.unwrap_or(0),
+        wasm_api_version: manifest.wasm_api_version,
        published_at,
    })
 }
--- a/crates/collab/src/api/ips_file.rs
+++ b/crates/collab/src/api/ips_file.rs
@@ -1,9 +1,8 @@
 use collections::HashMap;

-use serde_derive::Deserialize;
-use serde_derive::Serialize;
+use semantic_version::SemanticVersion;
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use util::SemanticVersion;

 #[derive(Debug)]
 pub struct IpsFile {
--- a/crates/collab/src/auth.rs
+++ b/crates/collab/src/auth.rs
@@ -1,5 +1,6 @@
 use crate::{
-    db::{self, AccessTokenId, Database, UserId},
+    db::{self, dev_server, AccessTokenId, Database, DevServerId, UserId},
+    rpc::Principal,
    AppState, Error, Result,
 };
 use anyhow::{anyhow, Context};
@@ -19,11 +20,11 @@ use std::sync::OnceLock;
 use std::{sync::Arc, time::Instant};
 use subtle::ConstantTimeEq;

-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct Impersonator(pub Option<db::User>);
-
-/// Validates the authorization header. This has two mechanisms, one for the ADMIN_TOKEN
-/// and one for the access tokens that we issue.
+/// Validates the authorization header and adds an Extension<Principal> to the request.
+/// Authorization: <user-id> <token>
+///   <token> can be an access_token attached to that user, or an access token of an admin
+///   or (in development) the string ADMIN:<config.api_token>.
+/// Authorization: "dev-server-token" <token>
 pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl IntoResponse {
    let mut auth_header = req
        .headers()
@@ -37,7 +38,26 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into
        })?
        .split_whitespace();

-    let user_id = UserId(auth_header.next().unwrap_or("").parse().map_err(|_| {
+    let state = req.extensions().get::<Arc<AppState>>().unwrap();
+
+    let first = auth_header.next().unwrap_or("");
+    if first == "dev-server-token" {
+        let dev_server_token = auth_header.next().ok_or_else(|| {
+            Error::Http(
+                StatusCode::BAD_REQUEST,
+                "missing dev-server-token token in authorization header".to_string(),
+            )
+        })?;
+        let dev_server = verify_dev_server_token(dev_server_token, &state.db)
+            .await
+            .map_err(|e| Error::Http(StatusCode::UNAUTHORIZED, format!("{}", e)))?;
+
+        req.extensions_mut()
+            .insert(Principal::DevServer(dev_server));
+        return Ok::<_, Error>(next.run(req).await);
+    }
+
+    let user_id = UserId(first.parse().map_err(|_| {
        Error::Http(
            StatusCode::BAD_REQUEST,
            "missing user id in authorization header".to_string(),
@@ -51,8 +71,6 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into
        )
    })?;

-    let state = req.extensions().get::<Arc<AppState>>().unwrap();
-
    // In development, allow impersonation using the admin API token.
    // Don't allow this in production because we can't tell who is doing
    // the impersonating.
@@ -76,18 +94,17 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into
                .await?
                .ok_or_else(|| anyhow!("user {} not found", user_id))?;

-            let impersonator = if let Some(impersonator_id) = validate_result.impersonator_id {
-                let impersonator = state
+            if let Some(impersonator_id) = validate_result.impersonator_id {
+                let admin = state
                    .db
                    .get_user_by_id(impersonator_id)
                    .await?
                    .ok_or_else(|| anyhow!("user {} not found", impersonator_id))?;
-                Some(impersonator)
+                req.extensions_mut()
+                    .insert(Principal::Impersonated { user, admin });
            } else {
-                None
+                req.extensions_mut().insert(Principal::User(user));
            };
-            req.extensions_mut().insert(user);
-            req.extensions_mut().insert(Impersonator(impersonator));
            return Ok::<_, Error>(next.run(req).await);
        }
    }
@@ -213,6 +230,33 @@ pub async fn verify_access_token(
    })
 }

+// a dev_server_token has the format <id>.<base64>. This is to make them
+// relatively easy to copy/paste around.
+pub async fn verify_dev_server_token(
+    dev_server_token: &str,
+    db: &Arc<Database>,
+) -> anyhow::Result<dev_server::Model> {
+    let mut parts = dev_server_token.splitn(2, '.');
+    let id = DevServerId(parts.next().unwrap_or_default().parse()?);
+    let token = parts
+        .next()
+        .ok_or_else(|| anyhow!("invalid dev server token format"))?;
+
+    let token_hash = hash_access_token(&token);
+    let server = db.get_dev_server(id).await?;
+
+    if server
+        .hashed_token
+        .as_bytes()
+        .ct_eq(token_hash.as_ref())
+        .into()
+    {
+        Ok(server)
+    } else {
+        Err(anyhow!("wrong token for dev server"))
+    }
+}
+
 #[cfg(test)]
 mod test {
    use rand::thread_rng;
--- a/crates/collab/src/bin/seed.rs
+++ b/crates/collab/src/bin/seed.rs
@@ -1,97 +0,0 @@
-use collab::{
-    db::{self, NewUserParams},
-    env::load_dotenv,
-    executor::Executor,
-};
-use db::{ConnectOptions, Database};
-use serde::{de::DeserializeOwned, Deserialize};
-use std::{fmt::Write, fs};
-
-#[derive(Debug, Deserialize)]
-struct GitHubUser {
-    id: i32,
-    login: String,
-    email: Option<String>,
-}
-
-#[tokio::main]
-async fn main() {
-    load_dotenv().expect("failed to load .env.toml file");
-
-    let mut admin_logins = load_admins("crates/collab/.admins.default.json")
-        .expect("failed to load default admins file");
-    if let Ok(other_admins) = load_admins("./.admins.json") {
-        admin_logins.extend(other_admins);
-    }
-
-    let database_url = std::env::var("DATABASE_URL").expect("missing DATABASE_URL env var");
-    let db = Database::new(ConnectOptions::new(database_url), Executor::Production)
-        .await
-        .expect("failed to connect to postgres database");
-    let client = reqwest::Client::new();
-
-    // Create admin users for all of the users in `.admins.toml` or `.admins.default.toml`.
-    for admin_login in admin_logins {
-        let user = fetch_github::<GitHubUser>(
-            &client,
-            &format!("https://api.github.com/users/{admin_login}"),
-        )
-        .await;
-        db.create_user(
-            &user.email.unwrap_or(format!("{admin_login}@example.com")),
-            true,
-            NewUserParams {
-                github_login: user.login,
-                github_user_id: user.id,
-            },
-        )
-        .await
-        .expect("failed to create admin user");
-    }
-
-    // Fetch 100 other random users from GitHub and insert them into the database.
-    let mut user_count = db
-        .get_all_users(0, 200)
-        .await
-        .expect("failed to load users from db")
-        .len();
-    let mut last_user_id = None;
-    while user_count < 100 {
-        let mut uri = "https://api.github.com/users?per_page=100".to_string();
-        if let Some(last_user_id) = last_user_id {
-            write!(&mut uri, "&since={}", last_user_id).unwrap();
-        }
-        let users = fetch_github::<Vec<GitHubUser>>(&client, &uri).await;
-
-        for github_user in users {
-            last_user_id = Some(github_user.id);
-            user_count += 1;
-            db.get_or_create_user_by_github_account(
-                &github_user.login,
-                Some(github_user.id),
-                github_user.email.as_deref(),
-                None,
-            )
-            .await
-            .expect("failed to insert user");
-        }
-    }
-}
-
-fn load_admins(path: &str) -> anyhow::Result<Vec<String>> {
-    let file_content = fs::read_to_string(path)?;
-    Ok(serde_json::from_str(&file_content)?)
-}
-
-async fn fetch_github<T: DeserializeOwned>(client: &reqwest::Client, url: &str) -> T {
-    let response = client
-        .get(url)
-        .header("user-agent", "zed")
-        .send()
-        .await
-        .unwrap_or_else(|_| panic!("failed to fetch '{}'", url));
-    response
-        .json()
-        .await
-        .unwrap_or_else(|_| panic!("failed to deserialize github user from '{}'", url))
-}
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -12,7 +12,7 @@ use futures::StreamExt;
 use rand::{prelude::StdRng, Rng, SeedableRng};
 use rpc::{
    proto::{self},
-    ConnectionId,
+    ConnectionId, ExtensionMetadata,
 };
 use sea_orm::{
    entity::prelude::*,
@@ -21,11 +21,13 @@ use sea_orm::{
    FromQueryResult, IntoActiveModel, IsolationLevel, JoinType, QueryOrder, QuerySelect, Statement,
    TransactionTrait,
 };
-use serde::{ser::Error as _, Deserialize, Serialize, Serializer};
+use semantic_version::SemanticVersion;
+use serde::{Deserialize, Serialize};
 use sqlx::{
    migrate::{Migrate, Migration, MigrationSource},
    Connection,
 };
+use std::ops::RangeInclusive;
 use std::{
    fmt::Write as _,
    future::Future,
@@ -36,7 +38,7 @@ use std::{
    sync::Arc,
    time::Duration,
 };
-use time::{format_description::well_known::iso8601, PrimitiveDateTime};
+use time::PrimitiveDateTime;
 use tokio::sync::{Mutex, OwnedMutexGuard};

 #[cfg(test)]
@@ -128,12 +130,6 @@ impl Database {
        Ok(new_migrations)
    }

-    /// Initializes static data that resides in the database by upserting it.
-    pub async fn initialize_static_data(&mut self) -> Result<()> {
-        self.initialize_notification_kinds().await?;
-        Ok(())
-    }
-
    /// Transaction runs things in a transaction. If you want to call other methods
    /// and pass the transaction around you need to reborrow the transaction at each
    /// call site with: `&*tx`.
@@ -464,6 +460,8 @@ pub struct UpdatedChannelMessage {
    pub notifications: NotificationBatch,
    pub reply_to_message_id: Option<MessageId>,
    pub timestamp: PrimitiveDateTime,
+    pub deleted_mention_notification_ids: Vec<NotificationId>,
+    pub updated_mention_notifications: Vec<rpc::proto::Notification>,
 }

 #[derive(Clone, Debug, PartialEq, Eq, FromQueryResult, Serialize, Deserialize)]
@@ -731,36 +729,12 @@ pub struct NewExtensionVersion {
    pub description: String,
    pub authors: Vec<String>,
    pub repository: String,
+    pub schema_version: i32,
+    pub wasm_api_version: Option<String>,
    pub published_at: PrimitiveDateTime,
 }

-#[derive(Debug, Serialize, PartialEq)]
-pub struct ExtensionMetadata {
-    pub id: String,
-    pub name: String,
-    pub version: String,
-    pub authors: Vec<String>,
-    pub description: String,
-    pub repository: String,
-    #[serde(serialize_with = "serialize_iso8601")]
-    pub published_at: PrimitiveDateTime,
-    pub download_count: u64,
-}
-
-pub fn serialize_iso8601<S: Serializer>(
-    datetime: &PrimitiveDateTime,
-    serializer: S,
-) -> Result<S::Ok, S::Error> {
-    const SERDE_CONFIG: iso8601::EncodedConfig = iso8601::Config::DEFAULT
-        .set_year_is_six_digits(false)
-        .set_time_precision(iso8601::TimePrecision::Second {
-            decimal_digits: None,
-        })
-        .encode();
-
-    datetime
-        .assume_utc()
-        .format(&time::format_description::well_known::Iso8601::<SERDE_CONFIG>)
-        .map_err(S::Error::custom)?
-        .serialize(serializer)
+pub struct ExtensionVersionConstraints {
+    pub schema_versions: RangeInclusive<i32>,
+    pub wasm_api_versions: RangeInclusive<SemanticVersion>,
 }
--- a/crates/collab/src/db/ids.rs
+++ b/crates/collab/src/db/ids.rs
@@ -67,28 +67,29 @@ macro_rules! id_type {
    };
 }

-id_type!(BufferId);
 id_type!(AccessTokenId);
+id_type!(BufferId);
+id_type!(ChannelBufferCollaboratorId);
 id_type!(ChannelChatParticipantId);
 id_type!(ChannelId);
 id_type!(ChannelMemberId);
-id_type!(MessageId);
 id_type!(ContactId);
+id_type!(DevServerId);
+id_type!(ExtensionId);
+id_type!(FlagId);
 id_type!(FollowerId);
+id_type!(HostedProjectId);
+id_type!(MessageId);
+id_type!(NotificationId);
+id_type!(NotificationKindId);
+id_type!(ProjectCollaboratorId);
+id_type!(ProjectId);
+id_type!(ReplicaId);
 id_type!(RoomId);
 id_type!(RoomParticipantId);
-id_type!(ProjectId);
-id_type!(ProjectCollaboratorId);
-id_type!(ReplicaId);
 id_type!(ServerId);
 id_type!(SignupId);
 id_type!(UserId);
-id_type!(ChannelBufferCollaboratorId);
-id_type!(FlagId);
-id_type!(ExtensionId);
-id_type!(NotificationId);
-id_type!(NotificationKindId);
-id_type!(HostedProjectId);

 /// ChannelRole gives you permissions for both channels and calls.
 #[derive(
--- a/crates/collab/src/db/queries.rs
+++ b/crates/collab/src/db/queries.rs
@@ -5,6 +5,7 @@ pub mod buffers;
 pub mod channels;
 pub mod contacts;
 pub mod contributors;
+pub mod dev_servers;
 pub mod extensions;
 pub mod hosted_projects;
 pub mod messages;
--- a/crates/collab/src/db/queries/dev_servers.rs
+++ b/crates/collab/src/db/queries/dev_servers.rs
@@ -0,0 +1,18 @@
+use sea_orm::EntityTrait;
+
+use super::{dev_server, Database, DevServerId};
+
+impl Database {
+    pub async fn get_dev_server(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> crate::Result<dev_server::Model> {
+        self.transaction(|tx| async move {
+            Ok(dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("no dev server with id {}", dev_server_id))?)
+        })
+        .await
+    }
+}
--- a/crates/collab/src/db/queries/extensions.rs
+++ b/crates/collab/src/db/queries/extensions.rs
@@ -1,87 +1,197 @@
+use std::str::FromStr;
+
+use chrono::Utc;
+use sea_orm::sea_query::IntoCondition;
+use util::ResultExt;
+
 use super::*;

 impl Database {
    pub async fn get_extensions(
        &self,
        filter: Option<&str>,
+        max_schema_version: i32,
        limit: usize,
    ) -> Result<Vec<ExtensionMetadata>> {
        self.transaction(|tx| async move {
-            let mut condition = Condition::all();
+            let mut condition = Condition::all()
+                .add(
+                    extension::Column::LatestVersion
+                        .into_expr()
+                        .eq(extension_version::Column::Version.into_expr()),
+                )
+                .add(extension_version::Column::SchemaVersion.lte(max_schema_version));
            if let Some(filter) = filter {
                let fuzzy_name_filter = Self::fuzzy_like_string(filter);
                condition = condition.add(Expr::cust_with_expr("name ILIKE $1", fuzzy_name_filter));
            }

+            self.get_extensions_where(condition, Some(limit as u64), &tx)
+                .await
+        })
+        .await
+    }
+
+    pub async fn get_extensions_by_ids(
+        &self,
+        ids: &[&str],
+        constraints: Option<&ExtensionVersionConstraints>,
+    ) -> Result<Vec<ExtensionMetadata>> {
+        self.transaction(|tx| async move {
            let extensions = extension::Entity::find()
-                .filter(condition)
-                .order_by_desc(extension::Column::TotalDownloadCount)
-                .order_by_asc(extension::Column::Name)
-                .limit(Some(limit as u64))
-                .filter(
-                    extension::Column::LatestVersion
-                        .into_expr()
-                        .eq(extension_version::Column::Version.into_expr()),
-                )
-                .inner_join(extension_version::Entity)
-                .select_also(extension_version::Entity)
+                .filter(extension::Column::ExternalId.is_in(ids.iter().copied()))
                .all(&*tx)
                .await?;

+            let mut max_versions = self
+                .get_latest_versions_for_extensions(&extensions, constraints, &tx)
+                .await?;
+
            Ok(extensions
                .into_iter()
-                .filter_map(|(extension, latest_version)| {
-                    let version = latest_version?;
-                    Some(ExtensionMetadata {
-                        id: extension.external_id,
-                        name: extension.name,
-                        version: version.version,
-                        authors: version
-                            .authors
-                            .split(',')
-                            .map(|author| author.trim().to_string())
-                            .collect::<Vec<_>>(),
-                        description: version.description,
-                        repository: version.repository,
-                        published_at: version.published_at,
-                        download_count: extension.total_download_count as u64,
-                    })
+                .filter_map(|extension| {
+                    let (version, _) = max_versions.remove(&extension.id)?;
+                    Some(metadata_from_extension_and_version(extension, version))
                })
                .collect())
        })
        .await
    }

-    pub async fn get_extension(&self, extension_id: &str) -> Result<Option<ExtensionMetadata>> {
+    async fn get_latest_versions_for_extensions(
+        &self,
+        extensions: &[extension::Model],
+        constraints: Option<&ExtensionVersionConstraints>,
+        tx: &DatabaseTransaction,
+    ) -> Result<HashMap<ExtensionId, (extension_version::Model, SemanticVersion)>> {
+        let mut versions = extension_version::Entity::find()
+            .filter(
+                extension_version::Column::ExtensionId
+                    .is_in(extensions.iter().map(|extension| extension.id)),
+            )
+            .stream(tx)
+            .await?;
+
+        let mut max_versions =
+            HashMap::<ExtensionId, (extension_version::Model, SemanticVersion)>::default();
+        while let Some(version) = versions.next().await {
+            let version = version?;
+            let Some(extension_version) = SemanticVersion::from_str(&version.version).log_err()
+            else {
+                continue;
+            };
+
+            if let Some((_, max_extension_version)) = &max_versions.get(&version.extension_id) {
+                if max_extension_version > &extension_version {
+                    continue;
+                }
+            }
+
+            if let Some(constraints) = constraints {
+                if !constraints
+                    .schema_versions
+                    .contains(&version.schema_version)
+                {
+                    continue;
+                }
+
+                if let Some(wasm_api_version) = version.wasm_api_version.as_ref() {
+                    if let Some(version) = SemanticVersion::from_str(wasm_api_version).log_err() {
+                        if !constraints.wasm_api_versions.contains(&version) {
+                            continue;
+                        }
+                    } else {
+                        continue;
+                    }
+                }
+            }
+
+            max_versions.insert(version.extension_id, (version, extension_version));
+        }
+
+        Ok(max_versions)
+    }
+
+    /// Returns all of the versions for the extension with the given ID.
+    pub async fn get_extension_versions(
+        &self,
+        extension_id: &str,
+    ) -> Result<Vec<ExtensionMetadata>> {
+        self.transaction(|tx| async move {
+            let condition = extension::Column::ExternalId
+                .eq(extension_id)
+                .into_condition();
+
+            self.get_extensions_where(condition, None, &tx).await
+        })
+        .await
+    }
+
+    async fn get_extensions_where(
+        &self,
+        condition: Condition,
+        limit: Option<u64>,
+        tx: &DatabaseTransaction,
+    ) -> Result<Vec<ExtensionMetadata>> {
+        let extensions = extension::Entity::find()
+            .inner_join(extension_version::Entity)
+            .select_also(extension_version::Entity)
+            .filter(condition)
+            .order_by_desc(extension::Column::TotalDownloadCount)
+            .order_by_asc(extension::Column::Name)
+            .limit(limit)
+            .all(tx)
+            .await?;
+
+        Ok(extensions
+            .into_iter()
+            .filter_map(|(extension, version)| {
+                Some(metadata_from_extension_and_version(extension, version?))
+            })
+            .collect())
+    }
+
+    pub async fn get_extension(
+        &self,
+        extension_id: &str,
+        constraints: Option<&ExtensionVersionConstraints>,
+    ) -> Result<Option<ExtensionMetadata>> {
        self.transaction(|tx| async move {
            let extension = extension::Entity::find()
                .filter(extension::Column::ExternalId.eq(extension_id))
-                .filter(
-                    extension::Column::LatestVersion
-                        .into_expr()
-                        .eq(extension_version::Column::Version.into_expr()),
-                )
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such extension: {extension_id}"))?;
+
+            let extensions = [extension];
+            let mut versions = self
+                .get_latest_versions_for_extensions(&extensions, constraints, &tx)
+                .await?;
+            let [extension] = extensions;
+
+            Ok(versions.remove(&extension.id).map(|(max_version, _)| {
+                metadata_from_extension_and_version(extension, max_version)
+            }))
+        })
+        .await
+    }
+
+    pub async fn get_extension_version(
+        &self,
+        extension_id: &str,
+        version: &str,
+    ) -> Result<Option<ExtensionMetadata>> {
+        self.transaction(|tx| async move {
+            let extension = extension::Entity::find()
+                .filter(extension::Column::ExternalId.eq(extension_id))
+                .filter(extension_version::Column::Version.eq(version))
                .inner_join(extension_version::Entity)
                .select_also(extension_version::Entity)
                .one(&*tx)
                .await?;

-            Ok(extension.and_then(|(extension, latest_version)| {
-                let version = latest_version?;
-                Some(ExtensionMetadata {
-                    id: extension.external_id,
-                    name: extension.name,
-                    version: version.version,
-                    authors: version
-                        .authors
-                        .split(',')
-                        .map(|author| author.trim().to_string())
-                        .collect::<Vec<_>>(),
-                    description: version.description,
-                    repository: version.repository,
-                    published_at: version.published_at,
-                    download_count: extension.total_download_count as u64,
-                })
+            Ok(extension.and_then(|(extension, version)| {
+                Some(metadata_from_extension_and_version(extension, version?))
            }))
        })
        .await
@@ -170,6 +280,8 @@ impl Database {
                        authors: ActiveValue::Set(version.authors.join(", ")),
                        repository: ActiveValue::Set(version.repository.clone()),
                        description: ActiveValue::Set(version.description.clone()),
+                        schema_version: ActiveValue::Set(version.schema_version),
+                        wasm_api_version: ActiveValue::Set(version.wasm_api_version.clone()),
                        download_count: ActiveValue::NotSet,
                    }
                }))
@@ -239,3 +351,35 @@ impl Database {
        .await
    }
 }
+
+fn metadata_from_extension_and_version(
+    extension: extension::Model,
+    version: extension_version::Model,
+) -> ExtensionMetadata {
+    ExtensionMetadata {
+        id: extension.external_id.into(),
+        manifest: rpc::ExtensionApiManifest {
+            name: extension.name,
+            version: version.version.into(),
+            authors: version
+                .authors
+                .split(',')
+                .map(|author| author.trim().to_string())
+                .collect::<Vec<_>>(),
+            description: Some(version.description),
+            repository: version.repository,
+            schema_version: Some(version.schema_version),
+            wasm_api_version: version.wasm_api_version,
+        },
+
+        published_at: convert_time_to_chrono(version.published_at),
+        download_count: extension.total_download_count as u64,
+    }
+}
+
+pub fn convert_time_to_chrono(time: time::PrimitiveDateTime) -> chrono::DateTime<Utc> {
+    chrono::DateTime::from_naive_utc_and_offset(
+        chrono::NaiveDateTime::from_timestamp_opt(time.assume_utc().unix_timestamp(), 0).unwrap(),
+        Utc,
+    )
+}
--- a/crates/collab/src/db/queries/messages.rs
+++ b/crates/collab/src/db/queries/messages.rs
@@ -1,7 +1,8 @@
 use super::*;
 use rpc::Notification;
-use sea_orm::TryInsertResult;
+use sea_orm::{SelectColumns, TryInsertResult};
 use time::OffsetDateTime;
+use util::ResultExt;

 impl Database {
    /// Inserts a record representing a user joining the chat for a given channel.
@@ -480,13 +481,20 @@ impl Database {
        Ok(results)
    }

+    fn get_notification_kind_id_by_name(&self, notification_kind: &str) -> Option<i32> {
+        self.notification_kinds_by_id
+            .iter()
+            .find(|(_, kind)| **kind == notification_kind)
+            .map(|kind| kind.0 .0)
+    }
+
    /// Removes the channel message with the given ID.
    pub async fn remove_channel_message(
        &self,
        channel_id: ChannelId,
        message_id: MessageId,
        user_id: UserId,
-    ) -> Result<Vec<ConnectionId>> {
+    ) -> Result<(Vec<ConnectionId>, Vec<NotificationId>)> {
        self.transaction(|tx| async move {
            let mut rows = channel_chat_participant::Entity::find()
                .filter(channel_chat_participant::Column::ChannelId.eq(channel_id))
@@ -531,7 +539,29 @@ impl Database {
                }
            }

-            Ok(participant_connection_ids)
+            let notification_kind_id =
+                self.get_notification_kind_id_by_name("ChannelMessageMention");
+
+            let existing_notifications = notification::Entity::find()
+                .filter(notification::Column::EntityId.eq(message_id))
+                .filter(notification::Column::Kind.eq(notification_kind_id))
+                .select_column(notification::Column::Id)
+                .all(&*tx)
+                .await?;
+
+            let existing_notification_ids = existing_notifications
+                .into_iter()
+                .map(|notification| notification.id)
+                .collect();
+
+            // remove all the mention notifications for this message
+            notification::Entity::delete_many()
+                .filter(notification::Column::EntityId.eq(message_id))
+                .filter(notification::Column::Kind.eq(notification_kind_id))
+                .exec(&*tx)
+                .await?;
+
+            Ok((participant_connection_ids, existing_notification_ids))
        })
        .await
    }
@@ -629,14 +659,44 @@ impl Database {
                    .await?;
            }

-            let mut mentioned_user_ids = mentions.iter().map(|m| m.user_id).collect::<HashSet<_>>();
+            let mut update_mention_user_ids = HashSet::default();
+            let mut new_mention_user_ids =
+                mentions.iter().map(|m| m.user_id).collect::<HashSet<_>>();
            // Filter out users that were mentioned before
-            for mention in old_mentions {
-                mentioned_user_ids.remove(&mention.user_id.to_proto());
+            for mention in &old_mentions {
+                if new_mention_user_ids.contains(&mention.user_id.to_proto()) {
+                    update_mention_user_ids.insert(mention.user_id.to_proto());
+                }
+
+                new_mention_user_ids.remove(&mention.user_id.to_proto());
+            }
+
+            let notification_kind_id =
+                self.get_notification_kind_id_by_name("ChannelMessageMention");
+
+            let existing_notifications = notification::Entity::find()
+                .filter(notification::Column::EntityId.eq(message_id))
+                .filter(notification::Column::Kind.eq(notification_kind_id))
+                .all(&*tx)
+                .await?;
+
+            // determine which notifications should be updated or deleted
+            let mut deleted_notification_ids = HashSet::default();
+            let mut updated_mention_notifications = Vec::new();
+            for notification in existing_notifications {
+                if update_mention_user_ids.contains(&notification.recipient_id.to_proto()) {
+                    if let Some(notification) =
+                        self::notifications::model_to_proto(self, notification).log_err()
+                    {
+                        updated_mention_notifications.push(notification);
+                    }
+                } else {
+                    deleted_notification_ids.insert(notification.id);
+                }
            }

            let mut notifications = Vec::new();
-            for mentioned_user in mentioned_user_ids {
+            for mentioned_user in new_mention_user_ids {
                notifications.extend(
                    self.create_notification(
                        UserId::from_proto(mentioned_user),
@@ -658,6 +718,10 @@ impl Database {
                notifications,
                reply_to_message_id: channel_message.reply_to_message_id,
                timestamp: channel_message.sent_at,
+                deleted_mention_notification_ids: deleted_notification_ids
+                    .into_iter()
+                    .collect::<Vec<_>>(),
+                updated_mention_notifications,
            })
        })
        .await
--- a/crates/collab/src/db/queries/notifications.rs
+++ b/crates/collab/src/db/queries/notifications.rs
@@ -1,5 +1,6 @@
 use super::*;
 use rpc::Notification;
+use util::ResultExt;

 impl Database {
    /// Initializes the different kinds of notifications by upserting records for them.
@@ -53,11 +54,8 @@ impl Database {
                .await?;
            while let Some(row) = rows.next().await {
                let row = row?;
-                let kind = row.kind;
-                if let Some(proto) = model_to_proto(self, row) {
+                if let Some(proto) = model_to_proto(self, row).log_err() {
                    result.push(proto);
-                } else {
-                    log::warn!("unknown notification kind {:?}", kind);
                }
            }
            result.reverse();
@@ -200,7 +198,9 @@ impl Database {
            })
            .exec(tx)
            .await?;
-            Ok(model_to_proto(self, row).map(|notification| (recipient_id, notification)))
+            Ok(model_to_proto(self, row)
+                .map(|notification| (recipient_id, notification))
+                .ok())
        } else {
            Ok(None)
        }
@@ -241,9 +241,12 @@ impl Database {
    }
 }

-fn model_to_proto(this: &Database, row: notification::Model) -> Option<proto::Notification> {
-    let kind = this.notification_kinds_by_id.get(&row.kind)?;
-    Some(proto::Notification {
+pub fn model_to_proto(this: &Database, row: notification::Model) -> Result<proto::Notification> {
+    let kind = this
+        .notification_kinds_by_id
+        .get(&row.kind)
+        .ok_or_else(|| anyhow!("Unknown notification kind"))?;
+    Ok(proto::Notification {
        id: row.id.to_proto(),
        kind: kind.to_string(),
        timestamp: row.created_at.assume_utc().unix_timestamp() as u64,
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -349,6 +349,17 @@ impl Database {
        .await
    }

+    pub async fn stale_room_connection(&self, user_id: UserId) -> Result<Option<ConnectionId>> {
+        self.transaction(|tx| async move {
+            let participant = room_participant::Entity::find()
+                .filter(room_participant::Column::UserId.eq(user_id))
+                .one(&*tx)
+                .await?;
+            Ok(participant.and_then(|p| p.answering_connection()))
+        })
+        .await
+    }
+
    async fn get_next_participant_index_internal(
        &self,
        room_id: RoomId,
@@ -403,39 +414,50 @@ impl Database {
            .get_next_participant_index_internal(room_id, tx)
            .await?;

-        room_participant::Entity::insert_many([room_participant::ActiveModel {
-            room_id: ActiveValue::set(room_id),
-            user_id: ActiveValue::set(user_id),
-            answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
-            answering_connection_server_id: ActiveValue::set(Some(ServerId(
-                connection.owner_id as i32,
-            ))),
-            answering_connection_lost: ActiveValue::set(false),
-            calling_user_id: ActiveValue::set(user_id),
-            calling_connection_id: ActiveValue::set(connection.id as i32),
-            calling_connection_server_id: ActiveValue::set(Some(ServerId(
-                connection.owner_id as i32,
-            ))),
-            participant_index: ActiveValue::Set(Some(participant_index)),
-            role: ActiveValue::set(Some(role)),
-            id: ActiveValue::NotSet,
-            location_kind: ActiveValue::NotSet,
-            location_project_id: ActiveValue::NotSet,
-            initial_project_id: ActiveValue::NotSet,
-        }])
-        .on_conflict(
-            OnConflict::columns([room_participant::Column::UserId])
-                .update_columns([
-                    room_participant::Column::AnsweringConnectionId,
-                    room_participant::Column::AnsweringConnectionServerId,
-                    room_participant::Column::AnsweringConnectionLost,
-                    room_participant::Column::ParticipantIndex,
-                    room_participant::Column::Role,
-                ])
-                .to_owned(),
-        )
-        .exec(tx)
-        .await?;
+        // If someone has been invited into the room, accept the invite instead of inserting
+        let result = room_participant::Entity::update_many()
+            .filter(
+                Condition::all()
+                    .add(room_participant::Column::RoomId.eq(room_id))
+                    .add(room_participant::Column::UserId.eq(user_id))
+                    .add(room_participant::Column::AnsweringConnectionId.is_null()),
+            )
+            .set(room_participant::ActiveModel {
+                participant_index: ActiveValue::Set(Some(participant_index)),
+                answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                answering_connection_server_id: ActiveValue::set(Some(ServerId(
+                    connection.owner_id as i32,
+                ))),
+                answering_connection_lost: ActiveValue::set(false),
+                ..Default::default()
+            })
+            .exec(tx)
+            .await?;
+
+        if result.rows_affected == 0 {
+            room_participant::Entity::insert(room_participant::ActiveModel {
+                room_id: ActiveValue::set(room_id),
+                user_id: ActiveValue::set(user_id),
+                answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                answering_connection_server_id: ActiveValue::set(Some(ServerId(
+                    connection.owner_id as i32,
+                ))),
+                answering_connection_lost: ActiveValue::set(false),
+                calling_user_id: ActiveValue::set(user_id),
+                calling_connection_id: ActiveValue::set(connection.id as i32),
+                calling_connection_server_id: ActiveValue::set(Some(ServerId(
+                    connection.owner_id as i32,
+                ))),
+                participant_index: ActiveValue::Set(Some(participant_index)),
+                role: ActiveValue::set(Some(role)),
+                id: ActiveValue::NotSet,
+                location_kind: ActiveValue::NotSet,
+                location_project_id: ActiveValue::NotSet,
+                initial_project_id: ActiveValue::NotSet,
+            })
+            .exec(tx)
+            .await?;
+        }

        let (channel, room) = self.get_channel_room(room_id, &tx).await?;
        let channel = channel.ok_or_else(|| anyhow!("no channel for room"))?;
--- a/crates/collab/src/db/tables.rs
+++ b/crates/collab/src/db/tables.rs
@@ -10,6 +10,7 @@ pub mod channel_message;
 pub mod channel_message_mention;
 pub mod contact;
 pub mod contributor;
+pub mod dev_server;
 pub mod extension;
 pub mod extension_version;
 pub mod feature_flag;
--- a/crates/collab/src/db/tables/dev_server.rs
+++ b/crates/collab/src/db/tables/dev_server.rs
@@ -0,0 +1,17 @@
+use crate::db::{ChannelId, DevServerId};
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "dev_servers")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: DevServerId,
+    pub name: String,
+    pub channel_id: ChannelId,
+    pub hashed_token: String,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
--- a/crates/collab/src/db/tables/extension_version.rs
+++ b/crates/collab/src/db/tables/extension_version.rs
@@ -13,6 +13,8 @@ pub struct Model {
    pub authors: String,
    pub repository: String,
    pub description: String,
+    pub schema_version: i32,
+    pub wasm_api_version: Option<String>,
    pub download_count: i64,
 }

--- a/crates/collab/src/db/tests/extension_tests.rs
+++ b/crates/collab/src/db/tests/extension_tests.rs
@@ -1,10 +1,10 @@
 use super::Database;
+use crate::db::ExtensionVersionConstraints;
 use crate::{
-    db::{ExtensionMetadata, NewExtensionVersion},
+    db::{queries::extensions::convert_time_to_chrono, ExtensionMetadata, NewExtensionVersion},
    test_both_dbs,
 };
 use std::sync::Arc;
-use time::{OffsetDateTime, PrimitiveDateTime};

 test_both_dbs!(
    test_extensions,
@@ -16,11 +16,13 @@ async fn test_extensions(db: &Arc<Database>) {
    let versions = db.get_known_extension_versions().await.unwrap();
    assert!(versions.is_empty());

-    let extensions = db.get_extensions(None, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
    assert!(extensions.is_empty());

-    let t0 = OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
-    let t0 = PrimitiveDateTime::new(t0.date(), t0.time());
+    let t0 = time::OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
+    let t0 = time::PrimitiveDateTime::new(t0.date(), t0.time());
+
+    let t0_chrono = convert_time_to_chrono(t0);

    db.insert_extension_versions(
        &[
@@ -33,6 +35,8 @@ async fn test_extensions(db: &Arc<Database>) {
                        description: "an extension".into(),
                        authors: vec!["max".into()],
                        repository: "ext1/repo".into(),
+                        schema_version: 1,
+                        wasm_api_version: None,
                        published_at: t0,
                    },
                    NewExtensionVersion {
@@ -41,6 +45,8 @@ async fn test_extensions(db: &Arc<Database>) {
                        description: "a good extension".into(),
                        authors: vec!["max".into(), "marshall".into()],
                        repository: "ext1/repo".into(),
+                        schema_version: 1,
+                        wasm_api_version: None,
                        published_at: t0,
                    },
                ],
@@ -53,6 +59,8 @@ async fn test_extensions(db: &Arc<Database>) {
                    description: "a great extension".into(),
                    authors: vec!["marshall".into()],
                    repository: "ext2/repo".into(),
+                    schema_version: 0,
+                    wasm_api_version: None,
                    published_at: t0,
                }],
            ),
@@ -75,33 +83,61 @@ async fn test_extensions(db: &Arc<Database>) {
    );

    // The latest version of each extension is returned.
-    let extensions = db.get_extensions(None, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[
            ExtensionMetadata {
                id: "ext1".into(),
-                name: "Extension One".into(),
-                version: "0.0.2".into(),
-                authors: vec!["max".into(), "marshall".into()],
-                description: "a good extension".into(),
-                repository: "ext1/repo".into(),
-                published_at: t0,
+                manifest: rpc::ExtensionApiManifest {
+                    name: "Extension One".into(),
+                    version: "0.0.2".into(),
+                    authors: vec!["max".into(), "marshall".into()],
+                    description: Some("a good extension".into()),
+                    repository: "ext1/repo".into(),
+                    schema_version: Some(1),
+                    wasm_api_version: None,
+                },
+                published_at: t0_chrono,
                download_count: 0,
            },
            ExtensionMetadata {
                id: "ext2".into(),
-                name: "Extension Two".into(),
-                version: "0.2.0".into(),
-                authors: vec!["marshall".into()],
-                description: "a great extension".into(),
-                repository: "ext2/repo".into(),
-                published_at: t0,
+                manifest: rpc::ExtensionApiManifest {
+                    name: "Extension Two".into(),
+                    version: "0.2.0".into(),
+                    authors: vec!["marshall".into()],
+                    description: Some("a great extension".into()),
+                    repository: "ext2/repo".into(),
+                    schema_version: Some(0),
+                    wasm_api_version: None,
+                },
+                published_at: t0_chrono,
                download_count: 0
            },
        ]
    );

+    // Extensions with too new of a schema version are excluded.
+    let extensions = db.get_extensions(None, 0, 5).await.unwrap();
+    assert_eq!(
+        extensions,
+        &[ExtensionMetadata {
+            id: "ext2".into(),
+            manifest: rpc::ExtensionApiManifest {
+                name: "Extension Two".into(),
+                version: "0.2.0".into(),
+                authors: vec!["marshall".into()],
+                description: Some("a great extension".into()),
+                repository: "ext2/repo".into(),
+                schema_version: Some(0),
+                wasm_api_version: None,
+            },
+            published_at: t0_chrono,
+            download_count: 0
+        },]
+    );
+
    // Record extensions being downloaded.
    for _ in 0..7 {
        assert!(db.record_extension_download("ext2", "0.0.2").await.unwrap());
@@ -122,28 +158,36 @@ async fn test_extensions(db: &Arc<Database>) {
        .unwrap());

    // Extensions are returned in descending order of total downloads.
-    let extensions = db.get_extensions(None, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[
            ExtensionMetadata {
                id: "ext2".into(),
-                name: "Extension Two".into(),
-                version: "0.2.0".into(),
-                authors: vec!["marshall".into()],
-                description: "a great extension".into(),
-                repository: "ext2/repo".into(),
-                published_at: t0,
+                manifest: rpc::ExtensionApiManifest {
+                    name: "Extension Two".into(),
+                    version: "0.2.0".into(),
+                    authors: vec!["marshall".into()],
+                    description: Some("a great extension".into()),
+                    repository: "ext2/repo".into(),
+                    schema_version: Some(0),
+                    wasm_api_version: None,
+                },
+                published_at: t0_chrono,
                download_count: 7
            },
            ExtensionMetadata {
                id: "ext1".into(),
-                name: "Extension One".into(),
-                version: "0.0.2".into(),
-                authors: vec!["max".into(), "marshall".into()],
-                description: "a good extension".into(),
-                repository: "ext1/repo".into(),
-                published_at: t0,
+                manifest: rpc::ExtensionApiManifest {
+                    name: "Extension One".into(),
+                    version: "0.0.2".into(),
+                    authors: vec!["max".into(), "marshall".into()],
+                    description: Some("a good extension".into()),
+                    repository: "ext1/repo".into(),
+                    schema_version: Some(1),
+                    wasm_api_version: None,
+                },
+                published_at: t0_chrono,
                download_count: 5,
            },
        ]
@@ -161,6 +205,8 @@ async fn test_extensions(db: &Arc<Database>) {
                    description: "a real good extension".into(),
                    authors: vec!["max".into(), "marshall".into()],
                    repository: "ext1/repo".into(),
+                    schema_version: 1,
+                    wasm_api_version: None,
                    published_at: t0,
                }],
            ),
@@ -172,6 +218,8 @@ async fn test_extensions(db: &Arc<Database>) {
                    description: "an old extension".into(),
                    authors: vec!["marshall".into()],
                    repository: "ext2/repo".into(),
+                    schema_version: 0,
+                    wasm_api_version: None,
                    published_at: t0,
                }],
            ),
@@ -196,30 +244,143 @@ async fn test_extensions(db: &Arc<Database>) {
        .collect()
    );

-    let extensions = db.get_extensions(None, 5).await.unwrap();
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[
            ExtensionMetadata {
                id: "ext2".into(),
-                name: "Extension Two".into(),
-                version: "0.2.0".into(),
-                authors: vec!["marshall".into()],
-                description: "a great extension".into(),
-                repository: "ext2/repo".into(),
-                published_at: t0,
+                manifest: rpc::ExtensionApiManifest {
+                    name: "Extension Two".into(),
+                    version: "0.2.0".into(),
+                    authors: vec!["marshall".into()],
+                    description: Some("a great extension".into()),
+                    repository: "ext2/repo".into(),
+                    schema_version: Some(0),
+                    wasm_api_version: None,
+                },
+                published_at: t0_chrono,
                download_count: 7
            },
            ExtensionMetadata {
                id: "ext1".into(),
-                name: "Extension One".into(),
-                version: "0.0.3".into(),
-                authors: vec!["max".into(), "marshall".into()],
-                description: "a real good extension".into(),
-                repository: "ext1/repo".into(),
-                published_at: t0,
+                manifest: rpc::ExtensionApiManifest {
+                    name: "Extension One".into(),
+                    version: "0.0.3".into(),
+                    authors: vec!["max".into(), "marshall".into()],
+                    description: Some("a real good extension".into()),
+                    repository: "ext1/repo".into(),
+                    schema_version: Some(1),
+                    wasm_api_version: None,
+                },
+                published_at: t0_chrono,
                download_count: 5,
            },
        ]
    );
 }
+
+test_both_dbs!(
+    test_extensions_by_id,
+    test_extensions_by_id_postgres,
+    test_extensions_by_id_sqlite
+);
+
+async fn test_extensions_by_id(db: &Arc<Database>) {
+    let versions = db.get_known_extension_versions().await.unwrap();
+    assert!(versions.is_empty());
+
+    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
+    assert!(extensions.is_empty());
+
+    let t0 = time::OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
+    let t0 = time::PrimitiveDateTime::new(t0.date(), t0.time());
+
+    let t0_chrono = convert_time_to_chrono(t0);
+
+    db.insert_extension_versions(
+        &[
+            (
+                "ext1",
+                vec![
+                    NewExtensionVersion {
+                        name: "Extension 1".into(),
+                        version: semver::Version::parse("0.0.1").unwrap(),
+                        description: "an extension".into(),
+                        authors: vec!["max".into()],
+                        repository: "ext1/repo".into(),
+                        schema_version: 1,
+                        wasm_api_version: Some("0.0.4".into()),
+                        published_at: t0,
+                    },
+                    NewExtensionVersion {
+                        name: "Extension 1".into(),
+                        version: semver::Version::parse("0.0.2").unwrap(),
+                        description: "a good extension".into(),
+                        authors: vec!["max".into()],
+                        repository: "ext1/repo".into(),
+                        schema_version: 1,
+                        wasm_api_version: Some("0.0.4".into()),
+                        published_at: t0,
+                    },
+                    NewExtensionVersion {
+                        name: "Extension 1".into(),
+                        version: semver::Version::parse("0.0.3").unwrap(),
+                        description: "a real good extension".into(),
+                        authors: vec!["max".into(), "marshall".into()],
+                        repository: "ext1/repo".into(),
+                        schema_version: 1,
+                        wasm_api_version: Some("0.0.5".into()),
+                        published_at: t0,
+                    },
+                ],
+            ),
+            (
+                "ext2",
+                vec![NewExtensionVersion {
+                    name: "Extension 2".into(),
+                    version: semver::Version::parse("0.2.0").unwrap(),
+                    description: "a great extension".into(),
+                    authors: vec!["marshall".into()],
+                    repository: "ext2/repo".into(),
+                    schema_version: 0,
+                    wasm_api_version: None,
+                    published_at: t0,
+                }],
+            ),
+        ]
+        .into_iter()
+        .collect(),
+    )
+    .await
+    .unwrap();
+
+    let extensions = db
+        .get_extensions_by_ids(
+            &["ext1"],
+            Some(&ExtensionVersionConstraints {
+                schema_versions: 1..=1,
+                wasm_api_versions: "0.0.1".parse().unwrap()..="0.0.4".parse().unwrap(),
+            }),
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(
+        extensions,
+        &[ExtensionMetadata {
+            id: "ext1".into(),
+            manifest: rpc::ExtensionApiManifest {
+                name: "Extension 1".into(),
+                version: "0.0.2".into(),
+                authors: vec!["max".into()],
+                description: Some("a good extension".into()),
+                repository: "ext1/repo".into(),
+                schema_version: Some(1),
+                wasm_api_version: Some("0.0.4".into()),
+            },
+            published_at: t0_chrono,
+            download_count: 0,
+        }]
+    );
+}
--- a/crates/collab/src/lib.rs
+++ b/crates/collab/src/lib.rs
@@ -6,6 +6,7 @@ pub mod env;
 pub mod executor;
 mod rate_limiter;
 pub mod rpc;
+pub mod seed;

 #[cfg(test)]
 mod tests;
@@ -111,6 +112,8 @@ impl std::error::Error for Error {}
 pub struct Config {
    pub http_port: u16,
    pub database_url: String,
+    pub migrations_path: Option<PathBuf>,
+    pub seed_path: Option<PathBuf>,
    pub database_max_connections: u32,
    pub api_token: String,
    pub clickhouse_url: Option<String>,
@@ -131,6 +134,7 @@ pub struct Config {
    pub zed_environment: Arc<str>,
    pub openai_api_key: Option<Arc<str>>,
    pub google_ai_api_key: Option<Arc<str>>,
+    pub anthropic_api_key: Option<Arc<str>>,
    pub zed_client_checksum_seed: Option<String>,
    pub slack_panics_webhook: Option<String>,
    pub auto_join_channel_id: Option<ChannelId>,
@@ -142,12 +146,6 @@ impl Config {
    }
 }

-#[derive(Default, Deserialize)]
-pub struct MigrateConfig {
-    pub database_url: String,
-    pub migrations_path: Option<PathBuf>,
-}
-
 pub struct AppState {
    pub db: Arc<Database>,
    pub live_kit_client: Option<Arc<dyn live_kit_server::api::Client>>,
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -7,7 +7,7 @@ use axum::{
 };
 use collab::{
    api::fetch_extensions_from_blob_store_periodically, db, env, executor::Executor, AppState,
-    Config, MigrateConfig, RateLimiter, Result,
+    Config, RateLimiter, Result,
 };
 use db::Database;
 use std::{
@@ -43,7 +43,16 @@ async fn main() -> Result<()> {
            println!("collab v{} ({})", VERSION, REVISION.unwrap_or("unknown"));
        }
        Some("migrate") => {
-            run_migrations().await?;
+            let config = envy::from_env::<Config>().expect("error loading config");
+            run_migrations(&config).await?;
+        }
+        Some("seed") => {
+            let config = envy::from_env::<Config>().expect("error loading config");
+            let db_options = db::ConnectOptions::new(config.database_url.clone());
+            let mut db = Database::new(db_options, Executor::Production).await?;
+            db.initialize_notification_kinds().await?;
+
+            collab::seed::seed(&config, &db, true).await?;
        }
        Some("serve") => {
            let (is_api, is_collab) = if let Some(next) = args.next() {
@@ -53,14 +62,14 @@ async fn main() -> Result<()> {
            };
            if !is_api && !is_collab {
                Err(anyhow!(
-                    "usage: collab <version | migrate | serve [api|collab]>"
+                    "usage: collab <version | migrate | seed | serve [api|collab]>"
                ))?;
            }

            let config = envy::from_env::<Config>().expect("error loading config");
            init_tracing(&config);

-            run_migrations().await?;
+            run_migrations(&config).await?;

            let state = AppState::new(config, Executor::Production).await?;

@@ -128,18 +137,38 @@ async fn main() -> Result<()> {
                );

            #[cfg(unix)]
+            let signal = async move {
+                let mut sigterm = tokio::signal::unix::signal(SignalKind::terminate())
+                    .expect("failed to listen for interrupt signal");
+                let mut sigint = tokio::signal::unix::signal(SignalKind::interrupt())
+                    .expect("failed to listen for interrupt signal");
+                let sigterm = sigterm.recv();
+                let sigint = sigint.recv();
+                futures::pin_mut!(sigterm, sigint);
+                futures::future::select(sigterm, sigint).await;
+            };
+
+            #[cfg(windows)]
+            let signal = async move {
+                // todo(windows):
+                // `ctrl_close` does not work well, because tokio's signal handler always returns soon,
+                // but system termiates the application soon after returning CTRL+CLOSE handler.
+                // So we should implement blocking handler to treat CTRL+CLOSE signal.
+                let mut ctrl_break = tokio::signal::windows::ctrl_break()
+                    .expect("failed to listen for interrupt signal");
+                let mut ctrl_c = tokio::signal::windows::ctrl_c()
+                    .expect("failed to listen for interrupt signal");
+                let ctrl_break = ctrl_break.recv();
+                let ctrl_c = ctrl_c.recv();
+                futures::pin_mut!(ctrl_break, ctrl_c);
+                futures::future::select(ctrl_break, ctrl_c).await;
+            };
+
            axum::Server::from_tcp(listener)
                .map_err(|e| anyhow!(e))?
                .serve(app.into_make_service_with_connect_info::<SocketAddr>())
                .with_graceful_shutdown(async move {
-                    let mut sigterm = tokio::signal::unix::signal(SignalKind::terminate())
-                        .expect("failed to listen for interrupt signal");
-                    let mut sigint = tokio::signal::unix::signal(SignalKind::interrupt())
-                        .expect("failed to listen for interrupt signal");
-                    let sigterm = sigterm.recv();
-                    let sigint = sigint.recv();
-                    futures::pin_mut!(sigterm, sigint);
-                    futures::future::select(sigterm, sigint).await;
+                    signal.await;
                    tracing::info!("Received interrupt signal");

                    if let Some(rpc_server) = rpc_server {
@@ -148,29 +177,28 @@ async fn main() -> Result<()> {
                })
                .await
                .map_err(|e| anyhow!(e))?;
-
-            // todo("windows")
-            #[cfg(windows)]
-            unimplemented!();
        }
        _ => {
            Err(anyhow!(
-                "usage: collab <version | migrate | serve [api|collab]>"
+                "usage: collab <version | migrate | seed | serve [api|collab]>"
            ))?;
        }
    }
    Ok(())
 }

-async fn run_migrations() -> Result<()> {
-    let config = envy::from_env::<MigrateConfig>().expect("error loading config");
+async fn run_migrations(config: &Config) -> Result<()> {
    let db_options = db::ConnectOptions::new(config.database_url.clone());
-    let db = Database::new(db_options, Executor::Production).await?;
+    let mut db = Database::new(db_options, Executor::Production).await?;

-    let migrations_path = config
-        .migrations_path
-        .as_deref()
-        .unwrap_or_else(|| Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/migrations")));
+    let migrations_path = config.migrations_path.as_deref().unwrap_or_else(|| {
+        #[cfg(feature = "sqlite")]
+        let default_migrations = concat!(env!("CARGO_MANIFEST_DIR"), "/migrations.sqlite");
+        #[cfg(not(feature = "sqlite"))]
+        let default_migrations = concat!(env!("CARGO_MANIFEST_DIR"), "/migrations");
+
+        Path::new(default_migrations)
+    });

    let migrations = db.migrate(&migrations_path, false).await?;
    for (migration, duration) in migrations {
@@ -182,6 +210,12 @@ async fn run_migrations() -> Result<()> {
        );
    }

+    db.initialize_notification_kinds().await?;
+
+    if config.seed_path.is_some() {
+        collab::seed::seed(&config, &db, false).await?;
+    }
+
    return Ok(());
 }

--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
--- a/crates/collab/src/rpc/connection_pool.rs
+++ b/crates/collab/src/rpc/connection_pool.rs
@@ -2,9 +2,10 @@ use crate::db::{ChannelId, ChannelRole, UserId};
 use anyhow::{anyhow, Result};
 use collections::{BTreeMap, HashMap, HashSet};
 use rpc::ConnectionId;
+use semantic_version::SemanticVersion;
 use serde::Serialize;
+use std::fmt;
 use tracing::instrument;
-use util::{semver, SemanticVersion};

 #[derive(Default, Serialize)]
 pub struct ConnectionPool {
@@ -20,7 +21,6 @@ struct ConnectedUser {

 #[derive(Debug, Serialize)]
 pub struct ZedVersion(pub SemanticVersion);
-use std::fmt;

 impl fmt::Display for ZedVersion {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -30,7 +30,7 @@ impl fmt::Display for ZedVersion {

 impl ZedVersion {
    pub fn can_collaborate(&self) -> bool {
-        self.0 >= semver(0, 127, 3) || (self.0 >= semver(0, 126, 3) && self.0 < semver(0, 127, 0))
+        self.0 >= SemanticVersion::new(0, 127, 3)
    }
 }

--- a/crates/collab/src/seed.rs
+++ b/crates/collab/src/seed.rs
@@ -0,0 +1,137 @@
+use crate::db::{self, ChannelRole, NewUserParams};
+
+use anyhow::Context;
+use db::Database;
+use serde::{de::DeserializeOwned, Deserialize};
+use std::{fmt::Write, fs, path::Path};
+
+use crate::Config;
+
+#[derive(Debug, Deserialize)]
+struct GitHubUser {
+    id: i32,
+    login: String,
+    email: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct SeedConfig {
+    // Which users to create as admins.
+    admins: Vec<String>,
+    // Which channels to create (all admins are invited to all channels)
+    channels: Vec<String>,
+    // Number of random users to create from the Github API
+    number_of_users: Option<usize>,
+}
+
+pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result<()> {
+    let client = reqwest::Client::new();
+
+    if !db.get_all_users(0, 1).await?.is_empty() && !force {
+        return Ok(());
+    }
+
+    let seed_path = config
+        .seed_path
+        .as_ref()
+        .context("called seed with no SEED_PATH")?;
+
+    let seed_config = load_admins(seed_path)
+        .context(format!("failed to load {}", seed_path.to_string_lossy()))?;
+
+    let mut first_user = None;
+    let mut others = vec![];
+
+    for admin_login in seed_config.admins {
+        let user = fetch_github::<GitHubUser>(
+            &client,
+            &format!("https://api.github.com/users/{admin_login}"),
+        )
+        .await;
+        let user = db
+            .create_user(
+                &user.email.unwrap_or(format!("{admin_login}@example.com")),
+                true,
+                NewUserParams {
+                    github_login: user.login,
+                    github_user_id: user.id,
+                },
+            )
+            .await
+            .context("failed to create admin user")?;
+        if first_user.is_none() {
+            first_user = Some(user.user_id);
+        } else {
+            others.push(user.user_id)
+        }
+    }
+
+    for channel in seed_config.channels {
+        let (channel, _) = db
+            .create_channel(&channel, None, first_user.unwrap())
+            .await
+            .context("failed to create channel")?;
+
+        for user_id in &others {
+            db.invite_channel_member(
+                channel.id,
+                *user_id,
+                first_user.unwrap(),
+                ChannelRole::Admin,
+            )
+            .await
+            .context("failed to add user to channel")?;
+        }
+    }
+
+    if let Some(number_of_users) = seed_config.number_of_users {
+        // Fetch 100 other random users from GitHub and insert them into the database
+        // (for testing autocompleters, etc.)
+        let mut user_count = db
+            .get_all_users(0, 200)
+            .await
+            .expect("failed to load users from db")
+            .len();
+        let mut last_user_id = None;
+        while user_count < number_of_users {
+            let mut uri = "https://api.github.com/users?per_page=100".to_string();
+            if let Some(last_user_id) = last_user_id {
+                write!(&mut uri, "&since={}", last_user_id).unwrap();
+            }
+            let users = fetch_github::<Vec<GitHubUser>>(&client, &uri).await;
+
+            for github_user in users {
+                last_user_id = Some(github_user.id);
+                user_count += 1;
+                db.get_or_create_user_by_github_account(
+                    &github_user.login,
+                    Some(github_user.id),
+                    github_user.email.as_deref(),
+                    None,
+                )
+                .await
+                .expect("failed to insert user");
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn load_admins(path: impl AsRef<Path>) -> anyhow::Result<SeedConfig> {
+    let file_content = fs::read_to_string(path)?;
+    Ok(serde_json::from_str(&file_content)?)
+}
+
+async fn fetch_github<T: DeserializeOwned>(client: &reqwest::Client, url: &str) -> T {
+    let response = client
+        .get(url)
+        .header("user-agent", "zed")
+        .send()
+        .await
+        .unwrap_or_else(|_| panic!("failed to fetch '{}'", url));
+    response
+        .json()
+        .await
+        .unwrap_or_else(|_| panic!("failed to deserialize github user from '{}'", url))
+}
--- a/crates/collab/src/tests/channel_message_tests.rs
+++ b/crates/collab/src/tests/channel_message_tests.rs
@@ -222,8 +222,18 @@ async fn test_remove_channel_message(
        .update(cx_a, |c, cx| c.send_message("one".into(), cx).unwrap())
        .await
        .unwrap();
-    channel_chat_a
-        .update(cx_a, |c, cx| c.send_message("two".into(), cx).unwrap())
+    let msg_id_2 = channel_chat_a
+        .update(cx_a, |c, cx| {
+            c.send_message(
+                MessageParams {
+                    text: "two @user_b".to_string(),
+                    mentions: vec![(4..12, client_b.id())],
+                    reply_to_message_id: None,
+                },
+                cx,
+            )
+            .unwrap()
+        })
        .await
        .unwrap();
    channel_chat_a
@@ -233,10 +243,24 @@ async fn test_remove_channel_message(

    // Clients A and B see all of the messages.
    executor.run_until_parked();
-    let expected_messages = &["one", "two", "three"];
+    let expected_messages = &["one", "two @user_b", "three"];
    assert_messages(&channel_chat_a, expected_messages, cx_a);
    assert_messages(&channel_chat_b, expected_messages, cx_b);

+    // Ensure that client B received a notification for the mention.
+    client_b.notification_store().read_with(cx_b, |store, _| {
+        assert_eq!(store.notification_count(), 2);
+        let entry = store.notification_at(0).unwrap();
+        assert_eq!(
+            entry.notification,
+            Notification::ChannelMessageMention {
+                message_id: msg_id_2,
+                sender_id: client_a.id(),
+                channel_id: channel_id.0,
+            }
+        );
+    });
+
    // Client A deletes one of their messages.
    channel_chat_a
        .update(cx_a, |c, cx| {
@@ -261,6 +285,13 @@ async fn test_remove_channel_message(
        .await
        .unwrap();
    assert_messages(&channel_chat_c, expected_messages, cx_c);
+
+    // Ensure we remove the notifications when the message is removed
+    client_b.notification_store().read_with(cx_b, |store, _| {
+        // First notification is the channel invitation, second would be the mention
+        // notification, which should now be removed.
+        assert_eq!(store.notification_count(), 1);
+    });
 }

 #[track_caller]
@@ -598,4 +629,97 @@ async fn test_chat_editing(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext)
            }
        );
    });
+
+    // Test update message and keep the mention and check that the body is updated correctly
+
+    channel_chat_a
+        .update(cx_a, |c, cx| {
+            c.update_message(
+                msg_id,
+                MessageParams {
+                    text: "Updated body v2 including a mention for @user_b".into(),
+                    reply_to_message_id: None,
+                    mentions: vec![(37..45, client_b.id())],
+                },
+                cx,
+            )
+            .unwrap()
+        })
+        .await
+        .unwrap();
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    channel_chat_a.update(cx_a, |channel_chat, _| {
+        assert_eq!(
+            channel_chat.find_loaded_message(msg_id).unwrap().body,
+            "Updated body v2 including a mention for @user_b",
+        )
+    });
+    channel_chat_b.update(cx_b, |channel_chat, _| {
+        assert_eq!(
+            channel_chat.find_loaded_message(msg_id).unwrap().body,
+            "Updated body v2 including a mention for @user_b",
+        )
+    });
+
+    client_b.notification_store().read_with(cx_b, |store, _| {
+        let message = store.channel_message_for_id(msg_id);
+        assert!(message.is_some());
+        assert_eq!(
+            message.unwrap().body,
+            "Updated body v2 including a mention for @user_b"
+        );
+        assert_eq!(store.notification_count(), 2);
+        let entry = store.notification_at(0).unwrap();
+        assert_eq!(
+            entry.notification,
+            Notification::ChannelMessageMention {
+                message_id: msg_id,
+                sender_id: client_a.id(),
+                channel_id: channel_id.0,
+            }
+        );
+    });
+
+    // If we remove a mention from a message the corresponding mention notification
+    // should also be removed.
+
+    channel_chat_a
+        .update(cx_a, |c, cx| {
+            c.update_message(
+                msg_id,
+                MessageParams {
+                    text: "Updated body without a mention".into(),
+                    reply_to_message_id: None,
+                    mentions: vec![],
+                },
+                cx,
+            )
+            .unwrap()
+        })
+        .await
+        .unwrap();
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    channel_chat_a.update(cx_a, |channel_chat, _| {
+        assert_eq!(
+            channel_chat.find_loaded_message(msg_id).unwrap().body,
+            "Updated body without a mention",
+        )
+    });
+    channel_chat_b.update(cx_b, |channel_chat, _| {
+        assert_eq!(
+            channel_chat.find_loaded_message(msg_id).unwrap().body,
+            "Updated body without a mention",
+        )
+    });
+    client_b.notification_store().read_with(cx_b, |store, _| {
+        // First notification is the channel invitation, second would be the mention
+        // notification, which should now be removed.
+        assert_eq!(store.notification_count(), 1);
+    });
 }
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -12,7 +12,7 @@ use editor::{
    Editor,
 };
 use futures::StreamExt;
-use gpui::{TestAppContext, VisualContext, VisualTestContext};
+use gpui::{BorrowAppContext, TestAppContext, VisualContext, VisualTestContext};
 use indoc::indoc;
 use language::{
    language_settings::{AllLanguageSettings, InlayHintSettings},
@@ -23,6 +23,7 @@ use rpc::RECEIVE_TIMEOUT;
 use serde_json::json;
 use settings::SettingsStore;
 use std::{
+    ops::Range,
    path::Path,
    sync::{
        atomic::{self, AtomicBool, AtomicUsize},
@@ -1986,6 +1987,187 @@ struct Row10;"#};
        struct Row1220;"#});
 }

+#[gpui::test(iterations = 10)]
+async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
+    let mut server = TestServer::start(cx_a.executor()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+
+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+
+    client_a
+        .fs()
+        .insert_tree(
+            "/my-repo",
+            json!({
+                ".git": {},
+                "file.txt": "line1\nline2\nline3\nline\n",
+            }),
+        )
+        .await;
+
+    let blame = git::blame::Blame {
+        entries: vec![
+            blame_entry("1b1b1b", 0..1),
+            blame_entry("0d0d0d", 1..2),
+            blame_entry("3a3a3a", 2..3),
+            blame_entry("4c4c4c", 3..4),
+        ],
+        permalinks: [
+            ("1b1b1b", "http://example.com/codehost/idx-0"),
+            ("0d0d0d", "http://example.com/codehost/idx-1"),
+            ("3a3a3a", "http://example.com/codehost/idx-2"),
+            ("4c4c4c", "http://example.com/codehost/idx-3"),
+        ]
+        .into_iter()
+        .map(|(sha, url)| (sha.parse().unwrap(), url.parse().unwrap()))
+        .collect(),
+        messages: [
+            ("1b1b1b", "message for idx-0"),
+            ("0d0d0d", "message for idx-1"),
+            ("3a3a3a", "message for idx-2"),
+            ("4c4c4c", "message for idx-3"),
+        ]
+        .into_iter()
+        .map(|(sha, message)| (sha.parse().unwrap(), message.into()))
+        .collect(),
+    };
+    client_a.fs().set_blame_for_repo(
+        Path::new("/my-repo/.git"),
+        vec![(Path::new("file.txt"), blame)],
+    );
+
+    let (project_a, worktree_id) = client_a.build_local_project("/my-repo", cx_a).await;
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+
+    // Create editor_a
+    let (workspace_a, cx_a) = client_a.build_workspace(&project_a, cx_a);
+    let editor_a = workspace_a
+        .update(cx_a, |workspace, cx| {
+            workspace.open_path((worktree_id, "file.txt"), None, true, cx)
+        })
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+
+    // Join the project as client B.
+    let project_b = client_b.build_remote_project(project_id, cx_b).await;
+    let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
+    let editor_b = workspace_b
+        .update(cx_b, |workspace, cx| {
+            workspace.open_path((worktree_id, "file.txt"), None, true, cx)
+        })
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+
+    // client_b now requests git blame for the open buffer
+    editor_b.update(cx_b, |editor_b, cx| {
+        assert!(editor_b.blame().is_none());
+        editor_b.toggle_git_blame(&editor::actions::ToggleGitBlame {}, cx);
+    });
+
+    cx_a.executor().run_until_parked();
+    cx_b.executor().run_until_parked();
+
+    editor_b.update(cx_b, |editor_b, cx| {
+        let blame = editor_b.blame().expect("editor_b should have blame now");
+        let entries = blame.update(cx, |blame, cx| {
+            blame
+                .blame_for_rows((0..4).map(Some), cx)
+                .collect::<Vec<_>>()
+        });
+
+        assert_eq!(
+            entries,
+            vec![
+                Some(blame_entry("1b1b1b", 0..1)),
+                Some(blame_entry("0d0d0d", 1..2)),
+                Some(blame_entry("3a3a3a", 2..3)),
+                Some(blame_entry("4c4c4c", 3..4)),
+            ]
+        );
+
+        blame.update(cx, |blame, _| {
+            for (idx, entry) in entries.iter().flatten().enumerate() {
+                assert_eq!(
+                    blame.permalink_for_entry(entry).unwrap().to_string(),
+                    format!("http://example.com/codehost/idx-{}", idx)
+                );
+                assert_eq!(
+                    blame.message_for_entry(entry).unwrap(),
+                    format!("message for idx-{}", idx)
+                );
+            }
+        });
+    });
+
+    // editor_b updates the file, which gets sent to client_a, which updates git blame,
+    // which gets back to client_b.
+    editor_b.update(cx_b, |editor_b, cx| {
+        editor_b.edit([(Point::new(0, 3)..Point::new(0, 3), "FOO")], cx);
+    });
+
+    cx_a.executor().run_until_parked();
+    cx_b.executor().run_until_parked();
+
+    editor_b.update(cx_b, |editor_b, cx| {
+        let blame = editor_b.blame().expect("editor_b should have blame now");
+        let entries = blame.update(cx, |blame, cx| {
+            blame
+                .blame_for_rows((0..4).map(Some), cx)
+                .collect::<Vec<_>>()
+        });
+
+        assert_eq!(
+            entries,
+            vec![
+                None,
+                Some(blame_entry("0d0d0d", 1..2)),
+                Some(blame_entry("3a3a3a", 2..3)),
+                Some(blame_entry("4c4c4c", 3..4)),
+            ]
+        );
+    });
+
+    // Now editor_a also updates the file
+    editor_a.update(cx_a, |editor_a, cx| {
+        editor_a.edit([(Point::new(1, 3)..Point::new(1, 3), "FOO")], cx);
+    });
+
+    cx_a.executor().run_until_parked();
+    cx_b.executor().run_until_parked();
+
+    editor_b.update(cx_b, |editor_b, cx| {
+        let blame = editor_b.blame().expect("editor_b should have blame now");
+        let entries = blame.update(cx, |blame, cx| {
+            blame
+                .blame_for_rows((0..4).map(Some), cx)
+                .collect::<Vec<_>>()
+        });
+
+        assert_eq!(
+            entries,
+            vec![
+                None,
+                None,
+                Some(blame_entry("3a3a3a", 2..3)),
+                Some(blame_entry("4c4c4c", 3..4)),
+            ]
+        );
+    });
+}
+
 fn extract_hint_labels(editor: &Editor) -> Vec<String> {
    let mut labels = Vec::new();
    for hint in editor.inlay_hint_cache().hints() {
@@ -1996,3 +2178,11 @@ fn extract_hint_labels(editor: &Editor) -> Vec<String> {
    }
    labels
 }
+
+fn blame_entry(sha: &str, range: Range<u32>) -> git::blame::BlameEntry {
+    git::blame::BlameEntry {
+        sha: sha.parse().unwrap(),
+        range,
+        ..Default::default()
+    }
+}
--- a/crates/collab/src/tests/following_tests.rs
+++ b/crates/collab/src/tests/following_tests.rs
@@ -7,8 +7,8 @@ use collab_ui::{
 };
 use editor::{Editor, ExcerptRange, MultiBuffer};
 use gpui::{
-    point, BackgroundExecutor, Context, Entity, SharedString, TestAppContext, View, VisualContext,
-    VisualTestContext,
+    point, BackgroundExecutor, BorrowAppContext, Context, Entity, SharedString, TestAppContext,
+    View, VisualContext, VisualTestContext,
 };
 use language::Capability;
 use live_kit_client::MacOSDisplay;
@@ -2007,7 +2007,7 @@ async fn test_following_to_channel_notes_without_a_shared_project(
    });
 }

-async fn join_channel(
+pub(crate) async fn join_channel(
    channel_id: ChannelId,
    client: &TestClient,
    cx: &mut TestAppContext,
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -1,6 +1,9 @@
 use crate::{
    rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
-    tests::{channel_id, room_participants, rust_lang, RoomParticipants, TestClient, TestServer},
+    tests::{
+        channel_id, following_tests::join_channel, room_participants, rust_lang, RoomParticipants,
+        TestClient, TestServer,
+    },
 };
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{User, RECEIVE_TIMEOUT};
@@ -8,8 +11,8 @@ use collections::{HashMap, HashSet};
 use fs::{repository::GitFileStatus, FakeFs, Fs as _, RemoveOptions};
 use futures::StreamExt as _;
 use gpui::{
-    px, size, AppContext, BackgroundExecutor, Model, Modifiers, MouseButton, MouseDownEvent,
-    TestAppContext,
+    px, size, AppContext, BackgroundExecutor, BorrowAppContext, Model, Modifiers, MouseButton,
+    MouseDownEvent, TestAppContext,
 };
 use language::{
    language_settings::{AllLanguageSettings, Formatter},
@@ -1863,6 +1866,24 @@ async fn test_active_call_events(
    executor.run_until_parked();
    assert_eq!(mem::take(&mut *events_a.borrow_mut()), vec![]);
    assert_eq!(mem::take(&mut *events_b.borrow_mut()), vec![]);
+
+    // Unsharing a project should dispatch the RemoteProjectUnshared event.
+    active_call_a
+        .update(cx_a, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
+    executor.run_until_parked();
+
+    assert_eq!(
+        mem::take(&mut *events_a.borrow_mut()),
+        vec![room::Event::RoomLeft { channel_id: None }]
+    );
+    assert_eq!(
+        mem::take(&mut *events_b.borrow_mut()),
+        vec![room::Event::RemoteProjectUnshared {
+            project_id: project_a_id,
+        }]
+    );
 }

 fn active_call_events(cx: &mut TestAppContext) -> Rc<RefCell<Vec<room::Event>>> {
@@ -4638,9 +4659,16 @@ async fn test_references(
    let active_call_a = cx_a.read(ActiveCall::global);

    client_a.language_registry().add(rust_lang());
-    let mut fake_language_servers = client_a
-        .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+    let mut fake_language_servers = client_a.language_registry().register_fake_lsp_adapter(
+        "Rust",
+        FakeLspAdapter {
+            capabilities: lsp::ServerCapabilities {
+                references_provider: Some(lsp::OneOf::Left(true)),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    );

    client_a
        .fs()
@@ -4931,9 +4959,35 @@ async fn test_lsp_hover(
        .await;

    client_a.language_registry().add(rust_lang());
+    let language_server_names = ["rust-analyzer", "CrabLang-ls"];
    let mut fake_language_servers = client_a
        .language_registry()
-        .register_fake_lsp_adapter("Rust", Default::default());
+        .register_specific_fake_lsp_adapter(
+            "Rust",
+            true,
+            FakeLspAdapter {
+                name: "rust-analyzer",
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
+            },
+        );
+    let _other_server = client_a
+        .language_registry()
+        .register_specific_fake_lsp_adapter(
+            "Rust",
+            false,
+            FakeLspAdapter {
+                name: "CrabLang-ls",
+                capabilities: lsp::ServerCapabilities {
+                    hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+                    ..lsp::ServerCapabilities::default()
+                },
+                ..FakeLspAdapter::default()
+            },
+        );

    let (project_a, worktree_id) = client_a.build_local_project("/root-1", cx_a).await;
    let project_id = active_call_a
@@ -4946,62 +5000,133 @@ async fn test_lsp_hover(
    let open_buffer = project_b.update(cx_b, |p, cx| p.open_buffer((worktree_id, "main.rs"), cx));
    let buffer_b = cx_b.executor().spawn(open_buffer).await.unwrap();

+    let mut servers_with_hover_requests = HashMap::default();
+    for i in 0..language_server_names.len() {
+        let new_server = fake_language_servers.next().await.unwrap_or_else(|| {
+            panic!(
+                "Failed to get language server #{i} with name {}",
+                &language_server_names[i]
+            )
+        });
+        let new_server_name = new_server.server.name();
+        assert!(
+            !servers_with_hover_requests.contains_key(new_server_name),
+            "Unexpected: initialized server with the same name twice. Name: `{new_server_name}`"
+        );
+        let new_server_name = new_server_name.to_string();
+        match new_server_name.as_str() {
+            "CrabLang-ls" => {
+                servers_with_hover_requests.insert(
+                    new_server_name.clone(),
+                    new_server.handle_request::<lsp::request::HoverRequest, _, _>(
+                        move |params, _| {
+                            assert_eq!(
+                                params
+                                    .text_document_position_params
+                                    .text_document
+                                    .uri
+                                    .as_str(),
+                                "file:///root-1/main.rs"
+                            );
+                            let name = new_server_name.clone();
+                            async move {
+                                Ok(Some(lsp::Hover {
+                                    contents: lsp::HoverContents::Scalar(
+                                        lsp::MarkedString::String(format!("{name} hover")),
+                                    ),
+                                    range: None,
+                                }))
+                            }
+                        },
+                    ),
+                );
+            }
+            "rust-analyzer" => {
+                servers_with_hover_requests.insert(
+                    new_server_name.clone(),
+                    new_server.handle_request::<lsp::request::HoverRequest, _, _>(
+                        |params, _| async move {
+                            assert_eq!(
+                                params
+                                    .text_document_position_params
+                                    .text_document
+                                    .uri
+                                    .as_str(),
+                                "file:///root-1/main.rs"
+                            );
+                            assert_eq!(
+                                params.text_document_position_params.position,
+                                lsp::Position::new(0, 22)
+                            );
+                            Ok(Some(lsp::Hover {
+                                contents: lsp::HoverContents::Array(vec![
+                                    lsp::MarkedString::String("Test hover content.".to_string()),
+                                    lsp::MarkedString::LanguageString(lsp::LanguageString {
+                                        language: "Rust".to_string(),
+                                        value: "let foo = 42;".to_string(),
+                                    }),
+                                ]),
+                                range: Some(lsp::Range::new(
+                                    lsp::Position::new(0, 22),
+                                    lsp::Position::new(0, 29),
+                                )),
+                            }))
+                        },
+                    ),
+                );
+            }
+            unexpected => panic!("Unexpected server name: {unexpected}"),
+        }
+    }
+
    // Request hover information as the guest.
-    let fake_language_server = fake_language_servers.next().await.unwrap();
-    fake_language_server.handle_request::<lsp::request::HoverRequest, _, _>(
-        |params, _| async move {
-            assert_eq!(
-                params
-                    .text_document_position_params
-                    .text_document
-                    .uri
-                    .as_str(),
-                "file:///root-1/main.rs"
-            );
-            assert_eq!(
-                params.text_document_position_params.position,
-                lsp::Position::new(0, 22)
-            );
-            Ok(Some(lsp::Hover {
-                contents: lsp::HoverContents::Array(vec![
-                    lsp::MarkedString::String("Test hover content.".to_string()),
-                    lsp::MarkedString::LanguageString(lsp::LanguageString {
-                        language: "Rust".to_string(),
-                        value: "let foo = 42;".to_string(),
-                    }),
-                ]),
-                range: Some(lsp::Range::new(
-                    lsp::Position::new(0, 22),
-                    lsp::Position::new(0, 29),
-                )),
-            }))
-        },
+    let mut hovers = project_b
+        .update(cx_b, |p, cx| p.hover(&buffer_b, 22, cx))
+        .await;
+    assert_eq!(
+        hovers.len(),
+        2,
+        "Expected two hovers from both language servers, but got: {hovers:?}"
    );

-    let hover_info = project_b
-        .update(cx_b, |p, cx| p.hover(&buffer_b, 22, cx))
-        .await
-        .unwrap()
-        .unwrap();
+    let _: Vec<()> = futures::future::join_all(servers_with_hover_requests.into_values().map(
+        |mut hover_request| async move {
+            hover_request
+                .next()
+                .await
+                .expect("All hover requests should have been triggered")
+        },
+    ))
+    .await;

+    hovers.sort_by_key(|hover| hover.contents.len());
+    let first_hover = hovers.first().cloned().unwrap();
+    assert_eq!(
+        first_hover.contents,
+        vec![project::HoverBlock {
+            text: "CrabLang-ls hover".to_string(),
+            kind: HoverBlockKind::Markdown,
+        },]
+    );
+    let second_hover = hovers.last().cloned().unwrap();
+    assert_eq!(
+        second_hover.contents,
+        vec![
+            project::HoverBlock {
+                text: "Test hover content.".to_string(),
+                kind: HoverBlockKind::Markdown,
+            },
+            project::HoverBlock {
+                text: "let foo = 42;".to_string(),
+                kind: HoverBlockKind::Code {
+                    language: "Rust".to_string()
+                },
+            }
+        ]
+    );
    buffer_b.read_with(cx_b, |buffer, _| {
        let snapshot = buffer.snapshot();
-        assert_eq!(hover_info.range.unwrap().to_offset(&snapshot), 22..29);
-        assert_eq!(
-            hover_info.contents,
-            vec![
-                project::HoverBlock {
-                    text: "Test hover content.".to_string(),
-                    kind: HoverBlockKind::Markdown,
-                },
-                project::HoverBlock {
-                    text: "let foo = 42;".to_string(),
-                    kind: HoverBlockKind::Code {
-                        language: "Rust".to_string()
-                    },
-                }
-            ]
-        );
+        assert_eq!(second_hover.range.unwrap().to_offset(&snapshot), 22..29);
    });
 }

@@ -5891,6 +6016,7 @@ async fn test_right_click_menu_behind_collab_panel(cx: &mut TestAppContext) {
        position: new_tab_button_bounds.center(),
        modifiers: Modifiers::default(),
        click_count: 1,
+        first_mouse: false,
    });

    // regression test that the right click menu for tabs does not open.
@@ -5902,13 +6028,14 @@ async fn test_right_click_menu_behind_collab_panel(cx: &mut TestAppContext) {
        position: tab_bounds.center(),
        modifiers: Modifiers::default(),
        click_count: 1,
+        first_mouse: false,
    });
    assert!(cx.debug_bounds("MENU_ITEM-Close").is_some());
 }

 #[gpui::test]
 async fn test_cmd_k_left(cx: &mut TestAppContext) {
-    let client = TestServer::start1(cx).await;
+    let (_, client) = TestServer::start1(cx).await;
    let (workspace, cx) = client.build_test_workspace(cx).await;

    cx.simulate_keystrokes("cmd-n");
@@ -5928,3 +6055,16 @@ async fn test_cmd_k_left(cx: &mut TestAppContext) {
        assert!(workspace.items(cx).collect::<Vec<_>>().len() == 2);
    });
 }
+
+#[gpui::test]
+async fn test_join_after_restart(cx1: &mut TestAppContext, cx2: &mut TestAppContext) {
+    let (mut server, client) = TestServer::start1(cx1).await;
+    let channel1 = server.make_public_channel("channel1", &client, cx1).await;
+    let channel2 = server.make_public_channel("channel2", &client, cx1).await;
+
+    join_channel(channel1, &client, cx1).await.unwrap();
+    drop(client);
+
+    let client2 = server.create_client(cx2, "user_a").await;
+    join_channel(channel2, &client2, cx2).await.unwrap();
+}
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -832,7 +832,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                        .boxed(),
                    LspRequestKind::CodeAction => project
                        .code_actions(&buffer, offset..offset, cx)
-                        .map_ok(|_| ())
+                        .map(|_| Ok(()))
                        .boxed(),
                    LspRequestKind::Definition => project
                        .definition(&buffer, offset, cx)
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -1,7 +1,7 @@
 use crate::{
    db::{tests::TestDb, NewUserParams, UserId},
    executor::Executor,
-    rpc::{Server, ZedVersion, CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
+    rpc::{Principal, Server, ZedVersion, CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
    AppState, Config, RateLimiter,
 };
 use anyhow::anyhow;
@@ -19,7 +19,6 @@ use futures::{channel::oneshot, StreamExt as _};
 use gpui::{BackgroundExecutor, Context, Model, Task, TestAppContext, View, VisualTestContext};
 use language::LanguageRegistry;
 use node_runtime::FakeNodeRuntime;
-
 use notifications::NotificationStore;
 use parking_lot::Mutex;
 use project::{Project, WorktreeId};
@@ -27,6 +26,7 @@ use rpc::{
    proto::{self, ChannelRole},
    RECEIVE_TIMEOUT,
 };
+use semantic_version::SemanticVersion;
 use serde_json::json;
 use settings::SettingsStore;
 use std::{
@@ -39,7 +39,7 @@ use std::{
        Arc,
    },
 };
-use util::{http::FakeHttpClient, SemanticVersion};
+use util::http::FakeHttpClient;
 use workspace::{Workspace, WorkspaceId, WorkspaceStore};

 pub struct TestServer {
@@ -135,9 +135,10 @@ impl TestServer {
        (server, client_a, client_b, channel_id)
    }

-    pub async fn start1(cx: &mut TestAppContext) -> TestClient {
+    pub async fn start1(cx: &mut TestAppContext) -> (TestServer, TestClient) {
        let mut server = Self::start(cx.executor().clone()).await;
-        server.create_client(cx, "user_a").await
+        let client = server.create_client(cx, "user_a").await;
+        (server, client)
    }

    pub async fn reset(&self) {
@@ -197,15 +198,20 @@ impl TestServer {
            .override_authenticate(move |cx| {
                cx.spawn(|_| async move {
                    let access_token = "the-token".to_string();
-                    Ok(Credentials {
+                    Ok(Credentials::User {
                        user_id: user_id.to_proto(),
                        access_token,
                    })
                })
            })
            .override_establish_connection(move |credentials, cx| {
-                assert_eq!(credentials.user_id, user_id.0 as u64);
-                assert_eq!(credentials.access_token, "the-token");
+                assert_eq!(
+                    credentials,
+                    &Credentials::User {
+                        user_id: user_id.0 as u64,
+                        access_token: "the-token".into()
+                    }
+                );

                let server = server.clone();
                let db = db.clone();
@@ -230,9 +236,8 @@ impl TestServer {
                            .spawn(server.handle_connection(
                                server_conn,
                                client_name,
-                                user,
+                                Principal::User(user),
                                ZedVersion(SemanticVersion::new(1, 0, 0)),
-                                None,
                                Some(connection_id_tx),
                                Executor::Deterministic(cx.background_executor().clone()),
                            ))
@@ -508,6 +513,7 @@ impl TestServer {
                blob_store_bucket: None,
                openai_api_key: None,
                google_ai_api_key: None,
+                anthropic_api_key: None,
                clickhouse_url: None,
                clickhouse_user: None,
                clickhouse_password: None,
@@ -515,6 +521,8 @@ impl TestServer {
                zed_client_checksum_seed: None,
                slack_panics_webhook: None,
                auto_join_channel_id: None,
+                migrations_path: None,
+                seed_path: None,
            },
        })
    }
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -156,7 +156,7 @@ impl ChatPanel {
                            }
                        }
                    }
-                    room::Event::Left { channel_id } => {
+                    room::Event::RoomLeft { channel_id } => {
                        if channel_id == &this.channel_id(cx) {
                            cx.emit(PanelEvent::Close)
                        }
@@ -615,6 +615,8 @@ impl ChatPanel {
                            .child(
                                IconButton::new(("reply", message_id), IconName::ReplyArrowRight)
                                    .on_click(cx.listener(move |this, _, cx| {
+                                        this.cancel_edit_message(cx);
+
                                        this.message_editor.update(cx, |editor, cx| {
                                            editor.set_reply_to_message_id(message_id);
                                            editor.focus_handle(cx).focus(cx);
@@ -636,6 +638,8 @@ impl ChatPanel {
                                    IconButton::new(("edit", message_id), IconName::Pencil)
                                        .on_click(cx.listener(move |this, _, cx| {
                                            this.message_editor.update(cx, |editor, cx| {
+                                                editor.clear_reply_to_message_id();
+
                                                let message = this
                                                    .active_chat()
                                                    .and_then(|active_chat| {
@@ -762,7 +766,7 @@ impl ChatPanel {

        if message.edited_at.is_some() {
            rich_text.highlights.push((
-                message.body.len()..(message.body.len() + MESSAGE_UPDATED.len()),
+                (rich_text.text.len() - MESSAGE_UPDATED.len())..rich_text.text.len(),
                Highlight::Highlight(HighlightStyle {
                    fade_out: Some(0.8),
                    ..Default::default()
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -9,12 +9,12 @@ use gpui::{
    Render, SharedString, Task, TextStyle, View, ViewContext, WeakView, WhiteSpace,
 };
 use language::{
-    language_settings::SoftWrap, Anchor, Buffer, BufferSnapshot, CodeLabel, Completion,
-    LanguageRegistry, LanguageServerId, ToOffset,
+    language_settings::SoftWrap, Anchor, Buffer, BufferSnapshot, CodeLabel, LanguageRegistry,
+    LanguageServerId, ToOffset,
 };
 use lazy_static::lazy_static;
 use parking_lot::RwLock;
-use project::search::SearchQuery;
+use project::{search::SearchQuery, Completion};
 use settings::Settings;
 use std::{ops::Range, sync::Arc, time::Duration};
 use theme::ThemeSettings;
@@ -48,7 +48,7 @@ impl CompletionProvider for MessageEditorCompletionProvider {
        buffer: &Model<Buffer>,
        buffer_position: language::Anchor,
        cx: &mut ViewContext<Editor>,
-    ) -> Task<anyhow::Result<Vec<language::Completion>>> {
+    ) -> Task<anyhow::Result<Vec<Completion>>> {
        let Some(handle) = self.0.upgrade() else {
            return Task::ready(Ok(Vec::new()));
        };
@@ -60,7 +60,7 @@ impl CompletionProvider for MessageEditorCompletionProvider {
    fn resolve_completions(
        &self,
        _completion_indices: Vec<usize>,
-        _completions: Arc<RwLock<Box<[language::Completion]>>>,
+        _completions: Arc<RwLock<Box<[Completion]>>>,
        _cx: &mut ViewContext<Editor>,
    ) -> Task<anyhow::Result<bool>> {
        Task::ready(Ok(false))
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -14,12 +14,12 @@ use db::kvp::KEY_VALUE_STORE;
 use editor::{Editor, EditorElement, EditorStyle};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
-    actions, canvas, div, fill, list, overlay, point, prelude::*, px, AnyElement, AppContext,
-    AsyncWindowContext, Bounds, ClickEvent, ClipboardItem, DismissEvent, Div, EventEmitter,
-    FocusHandle, FocusableView, FontStyle, FontWeight, InteractiveElement, IntoElement, ListOffset,
-    ListState, Model, MouseDownEvent, ParentElement, Pixels, Point, PromptLevel, Render,
-    SharedString, Styled, Subscription, Task, TextStyle, View, ViewContext, VisualContext,
-    WeakView, WhiteSpace,
+    actions, anchored, canvas, deferred, div, fill, list, point, prelude::*, px, AnyElement,
+    AppContext, AsyncWindowContext, Bounds, ClickEvent, ClipboardItem, DismissEvent, Div,
+    EventEmitter, FocusHandle, FocusableView, FontStyle, FontWeight, InteractiveElement,
+    IntoElement, ListOffset, ListState, Model, MouseDownEvent, ParentElement, Pixels, Point,
+    PromptLevel, Render, SharedString, Styled, Subscription, Task, TextStyle, View, ViewContext,
+    VisualContext, WeakView, WhiteSpace,
 };
 use menu::{Cancel, Confirm, SecondaryConfirm, SelectNext, SelectPrev};
 use project::{Fs, Project};
@@ -1802,7 +1802,7 @@ impl CollabPanel {
        }
    }

-    fn show_inline_context_menu(&mut self, _: &menu::ShowContextMenu, cx: &mut ViewContext<Self>) {
+    fn show_inline_context_menu(&mut self, _: &menu::SecondaryConfirm, cx: &mut ViewContext<Self>) {
        let Some(bounds) = self
            .selection
            .and_then(|ix| self.list_state.bounds_for_item(ix))
@@ -2767,10 +2767,13 @@ impl Render for CollabPanel {
                self.render_signed_in(cx)
            })
            .children(self.context_menu.as_ref().map(|(menu, position, _)| {
-                overlay()
-                    .position(*position)
-                    .anchor(gpui::AnchorCorner::TopLeft)
-                    .child(menu.clone())
+                deferred(
+                    anchored()
+                        .position(*position)
+                        .anchor(gpui::AnchorCorner::TopLeft)
+                        .child(menu.clone()),
+                )
+                .with_priority(1)
            }))
    }
 }
--- a/crates/collab_ui/src/collab_panel/channel_modal.rs
+++ b/crates/collab_ui/src/collab_panel/channel_modal.rs
@@ -5,9 +5,9 @@ use client::{
 };
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
-    actions, div, overlay, AppContext, ClipboardItem, DismissEvent, EventEmitter, FocusableView,
-    Model, ParentElement, Render, Styled, Subscription, Task, View, ViewContext, VisualContext,
-    WeakView,
+    actions, anchored, deferred, div, AppContext, ClipboardItem, DismissEvent, EventEmitter,
+    FocusableView, Model, ParentElement, Render, Styled, Subscription, Task, View, ViewContext,
+    VisualContext, WeakView,
 };
 use picker::{Picker, PickerDelegate};
 use std::sync::Arc;
@@ -409,9 +409,12 @@ impl PickerDelegate for ChannelModalDelegate {
                            .children(
                                if let (Some((menu, _)), true) = (&self.context_menu, selected) {
                                    Some(
-                                        overlay()
-                                            .anchor(gpui::AnchorCorner::TopRight)
-                                            .child(menu.clone()),
+                                        deferred(
+                                            anchored()
+                                                .anchor(gpui::AnchorCorner::TopRight)
+                                                .child(menu.clone()),
+                                        )
+                                        .with_priority(1),
                                    )
                                } else {
                                    None
--- a/crates/collab_ui/src/collab_ui.rs
+++ b/crates/collab_ui/src/collab_ui.rs
@@ -13,8 +13,8 @@ use call::{report_call_event_for_room, ActiveCall};
 pub use collab_panel::CollabPanel;
 pub use collab_titlebar_item::CollabTitlebarItem;
 use gpui::{
-    actions, point, AppContext, GlobalPixels, Pixels, PlatformDisplay, Size, Task, WindowContext,
-    WindowKind, WindowOptions,
+    actions, point, AppContext, DevicePixels, Pixels, PlatformDisplay, Size, Task,
+    WindowBackgroundAppearance, WindowContext, WindowKind, WindowOptions,
 };
 use panel_settings::MessageEditorSettings;
 pub use panel_settings::{
@@ -97,13 +97,13 @@ fn notification_window_options(
    screen: Rc<dyn PlatformDisplay>,
    window_size: Size<Pixels>,
 ) -> WindowOptions {
-    let notification_margin_width = GlobalPixels::from(16.);
-    let notification_margin_height = GlobalPixels::from(-0.) - GlobalPixels::from(48.);
+    let notification_margin_width = DevicePixels::from(16);
+    let notification_margin_height = DevicePixels::from(-0) - DevicePixels::from(48);

    let screen_bounds = screen.bounds();
-    let size: Size<GlobalPixels> = window_size.into();
+    let size: Size<DevicePixels> = window_size.into();

-    let bounds = gpui::Bounds::<GlobalPixels> {
+    let bounds = gpui::Bounds::<DevicePixels> {
        origin: screen_bounds.upper_right()
            - point(
                size.width + notification_margin_width,
@@ -121,5 +121,6 @@ fn notification_window_options(
        is_movable: false,
        display_id: Some(screen.id()),
        fullscreen: false,
+        window_background: WindowBackgroundAppearance::default(),
    }
 }
--- a/crates/collab_ui/src/notifications/project_shared_notification.rs
+++ b/crates/collab_ui/src/notifications/project_shared_notification.rs
@@ -58,7 +58,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
            }
        }

-        room::Event::Left { .. } => {
+        room::Event::RoomLeft { .. } => {
            for (_, windows) in notification_windows.drain() {
                for window in windows {
                    window
--- a/crates/collab_ui/src/panel_settings.rs
+++ b/crates/collab_ui/src/panel_settings.rs
@@ -2,7 +2,7 @@ use anyhow;
 use gpui::Pixels;
 use schemars::JsonSchema;
 use serde_derive::{Deserialize, Serialize};
-use settings::Settings;
+use settings::{Settings, SettingsSources};
 use workspace::dock::DockPosition;

 #[derive(Deserialize, Debug)]
@@ -53,48 +53,52 @@ pub struct MessageEditorSettings {

 impl Settings for CollaborationPanelSettings {
    const KEY: Option<&'static str> = Some("collaboration_panel");
+
    type FileContent = PanelSettingsContent;
+
    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
+        sources: SettingsSources<Self::FileContent>,
        _: &mut gpui::AppContext,
    ) -> anyhow::Result<Self> {
-        Self::load_via_json_merge(default_value, user_values)
+        sources.json_merge()
    }
 }

 impl Settings for ChatPanelSettings {
    const KEY: Option<&'static str> = Some("chat_panel");
+
    type FileContent = PanelSettingsContent;
+
    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
+        sources: SettingsSources<Self::FileContent>,
        _: &mut gpui::AppContext,
    ) -> anyhow::Result<Self> {
-        Self::load_via_json_merge(default_value, user_values)
+        sources.json_merge()
    }
 }

 impl Settings for NotificationPanelSettings {
    const KEY: Option<&'static str> = Some("notification_panel");
+
    type FileContent = PanelSettingsContent;
+
    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
+        sources: SettingsSources<Self::FileContent>,
        _: &mut gpui::AppContext,
    ) -> anyhow::Result<Self> {
-        Self::load_via_json_merge(default_value, user_values)
+        sources.json_merge()
    }
 }

 impl Settings for MessageEditorSettings {
    const KEY: Option<&'static str> = Some("message_editor");
+
    type FileContent = MessageEditorSettings;
+
    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
+        sources: SettingsSources<Self::FileContent>,
        _: &mut gpui::AppContext,
    ) -> anyhow::Result<Self> {
-        Self::load_via_json_merge(default_value, user_values)
+        sources.json_merge()
    }
 }
--- a/crates/collections/src/collections.rs
+++ b/crates/collections/src/collections.rs
@@ -10,5 +10,6 @@ pub type HashMap<K, V> = std::collections::HashMap<K, V>;
 #[cfg(not(feature = "test-support"))]
 pub type HashSet<T> = std::collections::HashSet<T>;

+pub use rustc_hash::FxHasher;
 pub use rustc_hash::{FxHashMap, FxHashSet};
 pub use std::collections::*;
--- a/crates/command_palette_hooks/src/command_palette_hooks.rs
+++ b/crates/command_palette_hooks/src/command_palette_hooks.rs
@@ -6,7 +6,7 @@ use std::any::TypeId;

 use collections::HashSet;
 use derive_more::{Deref, DerefMut};
-use gpui::{Action, AppContext, Global};
+use gpui::{Action, AppContext, BorrowAppContext, Global};

 /// Initializes the command palette hooks.
 pub fn init(cx: &mut AppContext) {
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -29,8 +29,7 @@ use std::{
    sync::Arc,
 };
 use util::{
-    async_maybe, fs::remove_matching, github::latest_github_release, http::HttpClient, paths,
-    ResultExt,
+    fs::remove_matching, github::latest_github_release, http::HttpClient, maybe, paths, ResultExt,
 };

 actions!(
@@ -377,6 +376,7 @@ impl Copilot {
        use node_runtime::FakeNodeRuntime;

        let (server, fake_server) = FakeLanguageServer::new(
+            LanguageServerId(0),
            LanguageServerBinary {
                path: "path/to/copilot".into(),
                arguments: vec![],
@@ -798,7 +798,7 @@ impl Copilot {
    ) -> Task<Result<()>> {
        let server = match self.server.as_authenticated() {
            Ok(server) => server,
-            Err(error) => return Task::ready(Err(error)),
+            Err(_) => return Task::ready(Ok(())),
        };
        let request =
            server
@@ -1006,7 +1006,7 @@ async fn get_copilot_lsp(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
        e @ Err(..) => {
            e.log_err();
            // Fetch a cached binary, if it exists
-            async_maybe!({
+            maybe!(async {
                let mut last_version_dir = None;
                let mut entries = fs::read_dir(paths::COPILOT_DIR.as_path()).await?;
                while let Some(entry) = entries.next().await {
--- a/crates/copilot_ui/Cargo.toml
+++ b/crates/copilot_ui/Cargo.toml
@@ -14,6 +14,7 @@ doctest = false

 [dependencies]
 anyhow.workspace = true
+client.workspace = true
 copilot.workspace = true
 editor.workspace = true
 fs.workspace = true
@@ -27,4 +28,11 @@ workspace.workspace = true
 zed_actions.workspace = true

 [dev-dependencies]
+copilot = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
+futures.workspace = true
+indoc.workspace = true
+lsp = { workspace = true, features = ["test-support"] }
+project = { workspace = true, features = ["test-support"] }
+serde_json.workspace = true
+theme = { workspace = true, features = ["test-support"] }
--- a/crates/copilot_ui/src/copilot_completion_provider.rs
+++ b/crates/copilot_ui/src/copilot_completion_provider.rs
--- a/crates/copilot_ui/src/copilot_ui.rs
+++ b/crates/copilot_ui/src/copilot_ui.rs
@@ -1,5 +1,7 @@
 pub mod copilot_button;
+mod copilot_completion_provider;
 mod sign_in;

 pub use copilot_button::*;
+pub use copilot_completion_provider::*;
 pub use sign_in::*;
--- a/crates/copilot_ui/src/sign_in.rs
+++ b/crates/copilot_ui/src/sign_in.rs
@@ -194,9 +194,8 @@ impl Render for CopilotCodeVerification {
            .on_action(cx.listener(|_, _: &menu::Cancel, cx| {
                cx.emit(DismissEvent);
            }))
-            .capture_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, cx| {
+            .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, cx| {
                cx.focus(&this.focus_handle);
-                cx.stop_propagation();
            }))
            .child(
                svg()
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`ALTER TABLE extension_versions ADD COLUMN wasm_api_version TEXT;`