Update edit predictions documentation

Git panel: Right click menu (#24787 )
Release Notes: - N/A
2025-02-13 04:47:19 -07:00 · 2025-02-12 22:26:34 -07:00 · 2025-02-12 23:14:45 -05:00 · 2025-02-12 20:55:22 -07:00 · 2025-02-12 20:53:52 -07:00 · 2025-02-13 02:35:25 +00:00
552 changed files with 28689 additions and 15465 deletions
--- a/.github/actions/run_tests_windows/action.yml
+++ b/.github/actions/run_tests_windows/action.yml
@@ -0,0 +1,26 @@
+name: "Run tests on Windows"
+description: "Runs the tests on Windows"
+
+inputs:
+  working-directory:
+    description: "The working directory"
+    required: true
+    default: "."
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install Rust
+      shell: pwsh
+      working-directory: ${{ inputs.working-directory }}
+      run: cargo install cargo-nextest --locked
+
+    - name: Install Node
+      uses: actions/setup-node@1d0ff469b7ec7b3cb9d8673fde0c81c44821de2a # v4
+      with:
+        node-version: "18"
+
+    - name: Run tests
+      shell: pwsh
+      working-directory: ${{ inputs.working-directory }}
+      run: cargo nextest run --workspace --no-fail-fast
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -135,6 +135,7 @@ jobs:
          cargo check -p gpui --features "macos-blade"
          cargo check -p workspace
          cargo build -p remote_server
+          cargo check -p gpui --examples
          script/check-rust-livekit-macos

      # Since the macOS runners are stateful, so we need to remove the config file to prevent potential bug.
@@ -181,6 +182,7 @@ jobs:
        run: |
          cargo build -p zed
          cargo check -p workspace
+          cargo check -p gpui --examples

      # Even the Linux runner is not stateful, in theory there is no need to do this cleanup.
      # But, to avoid potential issues in the future if we choose to use a stateful Linux runner and forget to add code
@@ -226,7 +228,6 @@ jobs:
        if: always()
        run: rm -rf ./../.cargo

-  # todo(windows): Actually run the tests
  windows_tests:
    timeout-minutes: 60
    name: (Windows) Run Clippy and tests
@@ -236,33 +237,55 @@ jobs:
      # more info here:- https://github.com/rust-lang/cargo/issues/13020
      - name: Enable longer pathnames for git
        run: git config --system core.longpaths true
+
      - name: Checkout repo
        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
        with:
          clean: false

+      - name: Create Dev Drive using ReFS
+        run: ./script/setup-dev-driver.ps1
+
+      # actions/checkout does not let us clone into anywhere outside ${{ github.workspace }}, so we have to copy the clone...
+      - name: Copy Git Repo to Dev Drive
+        run: |
+          Copy-Item -Path "${{ github.workspace }}" -Destination "${{ env.ZED_WORKSPACE }}" -Recurse
+
      - name: Cache dependencies
        uses: swatinem/rust-cache@f0deed1e0edfc6a9be95417288c0e1099b1eeec3 # v2
        with:
          save-if: ${{ github.ref == 'refs/heads/main' }}
+          workspaces: ${{ env.ZED_WORKSPACE }}
          cache-provider: "github"

      - name: Configure CI
        run: |
-          mkdir -p ./../.cargo
-          cp ./.cargo/ci-config.toml ./../.cargo/config.toml
+          mkdir -p ${{ env.CARGO_HOME }} -ErrorAction Ignore
+          cp ./.cargo/ci-config.toml ${{ env.CARGO_HOME }}/config.toml

      - name: cargo clippy
+        working-directory: ${{ env.ZED_WORKSPACE }}
        # Windows can't run shell scripts, so we need to use `cargo xtask`.
        run: cargo xtask clippy

+      - name: Run tests
+        uses: ./.github/actions/run_tests_windows
+        with:
+          working-directory: ${{ env.ZED_WORKSPACE }}
+
      - name: Build Zed
+        working-directory: ${{ env.ZED_WORKSPACE }}
        run: cargo build

+      - name: Check dev drive space
+        working-directory: ${{ env.ZED_WORKSPACE }}
+        # `setup-dev-driver.ps1` creates a 100GB drive, with CI taking up ~45GB of the drive.
+        run: ./script/exit-ci-if-dev-drive-is-full.ps1 95
+
      # Since the Windows runners are stateful, so we need to remove the config file to prevent potential bug.
      - name: Clean CI config file
        if: always()
-        run: Remove-Item -Path "./../.cargo" -Recurse -Force
+        run: Remove-Item -Path "${{ env.CARGO_HOME }}/config.toml"  -Force

  bundle-mac:
    timeout-minutes: 120
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -37,29 +37,36 @@ jobs:
          mdbook build ./docs --dest-dir=../target/deploy/docs/

      - name: Deploy Docs
-        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
+        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: pages deploy target/deploy --project-name=docs

      - name: Deploy Install
-        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
+        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: r2 object put -f script/install.sh zed-open-source-website-assets/install.sh

      - name: Deploy Docs Workers
-        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
+        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: deploy .cloudflare/docs-proxy/src/worker.js

      - name: Deploy Install Workers
-        uses: cloudflare/wrangler-action@7a5f8bbdfeedcde38e6777a50fe685f89259d4ca # v3
+        uses: cloudflare/wrangler-action@392082e81ffbcb9ebdde27400634aa004b35ea37 # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: deploy .cloudflare/docs-proxy/src/worker.js
+
+      - name: Preserve Wrangler logs
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08 # v4
+        if: always()
+        with:
+          name: wrangler_logs
+          path: /home/runner/.config/.wrangler/logs/
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -24,11 +24,13 @@ jobs:
      - name: Prettier Check on /docs
        working-directory: ./docs
        run: |
-          pnpm dlx prettier . --check || {
+          pnpm dlx prettier@${PRETTIER_VERSION} . --check || {
            echo "To fix, run from the root of the zed repo:"
-            echo "  cd docs && pnpm dlx prettier . --write && cd .."
+            echo "  cd docs && pnpm dlx prettier@${PRETTIER_VERSION} . --write && cd .."
            false
          }
+        env:
+          PRETTIER_VERSION: 3.5.0

      - name: Check for Typos with Typos-CLI
        uses: crate-ci/typos@8e6a4285bcbde632c5d79900a7779746e8b7ea3f # v1.24.6
--- a/.gitignore
+++ b/.gitignore
@@ -1,35 +1,35 @@
-/.direnv
-.envrc
-.idea
-**/target
+**/*.db
 **/cargo-target
-/zed.xcworkspace
-.DS_Store
-/plugins/bin
-/script/node_modules
-/crates/theme/schemas/theme.json
-/crates/collab/seed.json
-/crates/zed/resources/flatpak/flatpak-cargo-sources.json
-/dev.zed.Zed*.json
-/assets/*licenses.*
+**/target
 **/venv
-.build
 *.wasm
-Packages
 *.xcodeproj
-xcuserdata/
-DerivedData/
+.DS_Store
+.blob_store
+.build
+.envrc
+.flatpak-builder
+.idea
+.netrc
+.pytest_cache
+.swiftpm
 .swiftpm/config/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
-.netrc
-.swiftpm
-**/*.db
-.pytest_cache
 .venv
-.blob_store
 .vscode
 .wrangler
-.flatpak-builder
+/.direnv
+/assets/*licenses.*
+/crates/collab/seed.json
+/crates/theme/schemas/theme.json
+/crates/zed/resources/flatpak/flatpak-cargo-sources.json
+/dev.zed.Zed*.json
+/plugins/bin
+/script/node_modules
+/zed.xcworkspace
+DerivedData/
+Packages
+xcuserdata/

 # Don't commit any secrets to the repo.
 .env.secret.toml
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -52,3 +52,9 @@ Zed is made up of several smaller crates - let's go over those you're most likel
 - [`rpc`](/crates/rpc) defines messages to be exchanged with collaboration server.
 - [`theme`](/crates/theme) defines the theme system and provides a default theme.
 - [`ui`](/crates/ui) is a collection of UI components and common patterns used throughout Zed.
+- [`cli`](/crates/cli) is the CLI crate which invokes the Zed binary.
+- [`zed`](/crates/zed) is where all things come together, and the `main` entry point for Zed.
+
+## Packaging Zed
+
+Check our [notes for packaging Zed](https://zed.dev/docs/development/linux#notes-for-packaging-zed).
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,12 +26,15 @@ members = [
    "crates/collections",
    "crates/command_palette",
    "crates/command_palette_hooks",
+    "crates/component",
+    "crates/component_preview",
    "crates/context_server",
    "crates/context_server_settings",
    "crates/copilot",
    "crates/db",
    "crates/deepseek",
    "crates/diagnostics",
+    "crates/buffer_diff",
    "crates/docs_preprocessor",
    "crates/editor",
    "crates/evals",
@@ -80,6 +83,7 @@ members = [
    "crates/markdown_preview",
    "crates/media",
    "crates/menu",
+    "crates/migrator",
    "crates/multi_buffer",
    "crates/node_runtime",
    "crates/notifications",
@@ -87,6 +91,7 @@ members = [
    "crates/open_ai",
    "crates/outline",
    "crates/outline_panel",
+    "crates/panel",
    "crates/paths",
    "crates/picker",
    "crates/prettier",
@@ -103,7 +108,6 @@ members = [
    "crates/remote_server",
    "crates/repl",
    "crates/reqwest_client",
-    "crates/reqwest_client",
    "crates/rich_text",
    "crates/rope",
    "crates/rpc",
@@ -144,7 +148,7 @@ members = [
    "crates/ui_input",
    "crates/ui_macros",
    "crates/util",
-    "crates/vcs_menu",
+    "crates/util_macros",
    "crates/vim",
    "crates/vim_mode_setting",
    "crates/welcome",
@@ -152,7 +156,6 @@ members = [
    "crates/worktree",
    "crates/zed",
    "crates/zed_actions",
-    "crates/zed_predict_onboarding",
    "crates/zeta",

    #
@@ -168,7 +171,6 @@ members = [
    "extensions/haskell",
    "extensions/html",
    "extensions/lua",
-    "extensions/php",
    "extensions/perplexity",
    "extensions/proto",
    "extensions/purescript",
@@ -225,12 +227,15 @@ collab_ui = { path = "crates/collab_ui" }
 collections = { path = "crates/collections" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
+component = { path = "crates/component" }
+component_preview = { path = "crates/component_preview" }
 context_server = { path = "crates/context_server" }
 context_server_settings = { path = "crates/context_server_settings" }
 copilot = { path = "crates/copilot" }
 db = { path = "crates/db" }
 deepseek = { path = "crates/deepseek" }
 diagnostics = { path = "crates/diagnostics" }
+buffer_diff = { path = "crates/buffer_diff" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
 extension_host = { path = "crates/extension_host" }
@@ -243,8 +248,8 @@ fs = { path = "crates/fs" }
 fsevent = { path = "crates/fsevent" }
 fuzzy = { path = "crates/fuzzy" }
 git = { path = "crates/git" }
-git_ui = { path = "crates/git_ui" }
 git_hosting_providers = { path = "crates/git_hosting_providers" }
+git_ui = { path = "crates/git_ui" }
 go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
 gpui = { path = "crates/gpui", default-features = false, features = [
@@ -277,6 +282,7 @@ markdown = { path = "crates/markdown" }
 markdown_preview = { path = "crates/markdown_preview" }
 media = { path = "crates/media" }
 menu = { path = "crates/menu" }
+migrator = { path = "crates/migrator" }
 multi_buffer = { path = "crates/multi_buffer" }
 node_runtime = { path = "crates/node_runtime" }
 notifications = { path = "crates/notifications" }
@@ -285,6 +291,7 @@ open_ai = { path = "crates/open_ai" }
 outline = { path = "crates/outline" }
 outline_panel = { path = "crates/outline_panel" }
 paths = { path = "crates/paths" }
+panel = { path = "crates/panel" }
 picker = { path = "crates/picker" }
 plugin = { path = "crates/plugin" }
 plugin_macros = { path = "crates/plugin_macros" }
@@ -340,7 +347,7 @@ ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
 util = { path = "crates/util" }
-vcs_menu = { path = "crates/vcs_menu" }
+util_macros = { path = "crates/util_macros" }
 vim = { path = "crates/vim" }
 vim_mode_setting = { path = "crates/vim_mode_setting" }
 welcome = { path = "crates/welcome" }
@@ -348,7 +355,6 @@ workspace = { path = "crates/workspace" }
 worktree = { path = "crates/worktree" }
 zed = { path = "crates/zed" }
 zed_actions = { path = "crates/zed_actions" }
-zed_predict_onboarding = { path = "crates/zed_predict_onboarding" }
 zeta = { path = "crates/zeta" }

 #
@@ -361,7 +367,7 @@ alacritty_terminal = { git = "https://github.com/alacritty/alacritty.git", rev =
 any_vec = "0.14"
 anyhow = "1.0.86"
 arrayvec = { version = "0.7.4", features = ["serde"] }
-ashpd = { version = "0.10", default-features = false, features = ["async-std"]}
+ashpd = { version = "0.10", default-features = false, features = ["async-std"] }
 async-compat = "0.2.1"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-dispatcher = "0.1"
@@ -416,6 +422,7 @@ ignore = "0.4.22"
 image = "0.25.1"
 indexmap = { version = "2.7.0", features = ["serde"] }
 indoc = "2"
+inventory = "0.3.19"
 itertools = "0.14.0"
 jsonwebtoken = "9.3"
 jupyter-protocol = { version = "0.6.0" }
@@ -423,7 +430,12 @@ jupyter-websocket-client = { version = "0.9.0" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
-livekit = { git = "https://github.com/zed-industries/livekit-rust-sdks", rev="060964da10574cd9bf06463a53bf6e0769c5c45e", features = ["dispatcher", "services-dispatcher", "rustls-tls-native-roots"], default-features = false }
+linkme = "0.3.31"
+livekit = { git = "https://github.com/zed-industries/livekit-rust-sdks", rev = "811ceae29fabee455f110c56cd66b3f49a7e5003", features = [
+    "dispatcher",
+    "services-dispatcher",
+    "rustls-tls-native-roots",
+], default-features = false }
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
@@ -443,11 +455,13 @@ pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git"
 pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "1abe5cec5ebfbe97ca71746a4cfc7fe89bddf8e0" }
 postage = { version = "0.5", features = ["futures-traits"] }
 pretty_assertions = { version = "1.3.0", features = ["unstable"] }
+proc-macro2 = "1.0.93"
 profiling = "1"
 prost = "0.9"
 prost-build = "0.9"
 prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
+quote = "1.0.9"
 rand = "0.8.5"
 rayon = "1.8"
 regex = "1.5"
@@ -467,8 +481,8 @@ runtimelib = { version = "0.25.0", default-features = false, features = [
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
 rustc-hash = "2.1.0"
-rustls = "0.21.12"
-rustls-native-certs = "0.8.0"
+rustls = { version = "0.23.22" }
+rustls-platform-verifier = "0.5.0"
 schemars = { version = "0.8", features = ["impl_json_schema", "indexmap2"] }
 semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
@@ -488,9 +502,11 @@ simplelog = "0.12.2"
 smallvec = { version = "1.6", features = ["union"] }
 smol = "2.0"
 sqlformat = "0.2"
+streaming-iterator = "0.1"
 strsim = "0.11"
 strum = { version = "0.26.0", features = ["derive"] }
 subtle = "2.5.0"
+syn = { version = "1.0.72", features = ["full", "extra-traits"] }
 sys-locale = "0.3.1"
 sysinfo = "0.31.0"
 take-until = "0.2.0"
@@ -508,13 +524,14 @@ tiny_http = "0.8"
 toml = "0.8"
 tokio = { version = "1" }
 tower-http = "0.4.4"
-tree-sitter = { version = "0.23", features = ["wasm"] }
+tree-sitter = { version = "0.24", features = ["wasm"] }
 tree-sitter-bash = "0.23"
 tree-sitter-c = "0.23"
 tree-sitter-cpp = "0.23"
 tree-sitter-css = "0.23"
 tree-sitter-elixir = "0.3"
 tree-sitter-embedded-template = "0.23.0"
+tree-sitter-gitcommit = {git  = "https://github.com/zed-industries/tree-sitter-git-commit", rev = "88309716a69dd13ab83443721ba6e0b491d37ee9"}
 tree-sitter-go = "0.23"
 tree-sitter-go-mod = { git = "https://github.com/camdencheek/tree-sitter-go-mod", rev = "6efb59652d30e0e9cd5f3b3a669afd6f1a926d3c", package = "tree-sitter-gomod" }
 tree-sitter-gowork = { git = "https://github.com/zed-industries/tree-sitter-go-work", rev = "acb0617bf7f4fda02c6217676cc64acb89536dc7" }
@@ -536,18 +553,19 @@ unicode-segmentation = "1.10"
 unicode-script = "0.5.7"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "v7", "serde"] }
-wasmparser = "0.215"
-wasm-encoder = "0.215"
-wasmtime = { version = "24", default-features = false, features = [
+wasmparser = "0.217"
+wasm-encoder = "0.217"
+wasmtime = { version = "25", default-features = false, features = [
    "async",
    "demangle",
    "runtime",
    "cranelift",
    "component-model",
 ] }
-wasmtime-wasi = "24"
+wasmtime-wasi = "25"
 which = "6.0.0"
 wit-component = "0.201"
+zed_llm_client = "0.4"
 zstd = "0.11"
 metal = "0.31"

@@ -608,6 +626,7 @@ features = [
 # TODO livekit https://github.com/RustAudio/cpal/pull/891
 [patch.crates-io]
 cpal = { git = "https://github.com/zed-industries/cpal", rev = "fd8bc2fd39f1f5fdee5a0690656caff9a26d9d50" }
+real-async-tls = { git = "https://github.com/zed-industries/async-tls", rev = "1e759a4b5e370f87dc15e40756ac4f8815b61d9d", package = "async-tls"}

 [profile.dev]
 split-debuginfo = "unpacked"
@@ -661,7 +680,6 @@ telemetry_events = { codegen-units = 1 }
 theme_selector = { codegen-units = 1 }
 time_format = { codegen-units = 1 }
 ui_input = { codegen-units = 1 }
-vcs_menu = { codegen-units = 1 }
 zed_actions = { codegen-units = 1 }

 [profile.release]
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright 2022 - 2024 Zed Industries, Inc.
+Copyright 2022 - 2025 Zed Industries, Inc.



--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright 2022 - 2024 Zed Industries, Inc.
+Copyright 2022 - 2025 Zed Industries, Inc.


   Licensed under the Apache License, Version 2.0 (the "License");
--- a/assets/icons/circle.svg
+++ b/assets/icons/circle.svg
@@ -0,0 +1 @@
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg"><circle cx="7.25" cy="7.25" r="3" fill="currentColor"></circle></svg>
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -18,18 +18,23 @@
    "bash_logout": "terminal",
    "bash_profile": "terminal",
    "bashrc": "terminal",
+    "bicep": "bicep",
    "bmp": "image",
    "c": "c",
    "c++": "cpp",
    "cc": "cpp",
    "cjs": "javascript",
+    "cjsx": "react",
    "coffee": "coffeescript",
    "conf": "settings",
    "cpp": "cpp",
+    "cs": "csharp",
    "css": "css",
    "csv": "storage",
    "cxx": "cpp",
    "cts": "typescript",
+    "ctsx": "react",
+    "cue": "cue",
    "dart": "dart",
    "dat": "storage",
    "db": "storage",
@@ -64,6 +69,7 @@
    "gitattributes": "vcs",
    "gitignore": "vcs",
    "gitkeep": "vcs",
+    "gitlab-ci.yml": "gitlab",
    "gitmodules": "vcs",
    "TAG_EDITMSG": "vcs",
    "MERGE_MSG": "vcs",
@@ -86,8 +92,8 @@
    "hpp": "cpp",
    "hrl": "erlang",
    "hs": "haskell",
-    "htm": "template",
-    "html": "template",
+    "htm": "html",
+    "html": "html",
    "hxx": "cpp",
    "ib": "storage",
    "ico": "image",
@@ -101,7 +107,7 @@
    "jpeg": "image",
    "jpg": "image",
    "js": "javascript",
-    "json": "storage",
+    "json": "json",
    "jsonc": "storage",
    "jsx": "react",
    "jxl": "image",
@@ -111,16 +117,18 @@
    "lockb": "bun",
    "log": "log",
    "lua": "lua",
+    "luau": "luau",
    "m4a": "audio",
    "m4v": "video",
-    "markdown": "document",
-    "md": "document",
+    "markdown": "markdown",
+    "md": "markdown",
    "mdb": "storage",
    "mdf": "storage",
    "mdx": "document",
    "metadata": "code",
    "metal": "metal",
    "mjs": "javascript",
+    "mjsx": "react",
    "mka": "audio",
    "mkv": "video",
    "ml": "ocaml",
@@ -130,6 +138,7 @@
    "mp3": "audio",
    "mp4": "video",
    "mts": "typescript",
+    "mtsx": "react",
    "myd": "storage",
    "myi": "storage",
    "nim": "nim",
@@ -150,8 +159,19 @@
    "postcss": "css",
    "ppt": "document",
    "pptx": "document",
+    "prettier.config.cjs": "prettier",
+    "prettier.config.js": "prettier",
+    "prettier.config.mjs": "prettier",
    "prettierignore": "prettier",
    "prettierrc": "prettier",
+    "prettierrc.cjs": "prettier",
+    "prettierrc.js": "prettier",
+    "prettierrc.json": "prettier",
+    "prettierrc.json5": "prettier",
+    "prettierrc.mjs": "prettier",
+    "prettierrc.toml": "prettier",
+    "prettierrc.yaml": "prettier",
+    "prettierrc.yml": "prettier",
    "prisma": "prisma",
    "profile": "terminal",
    "ps1": "terminal",
@@ -173,9 +193,21 @@
    "scss": "sass",
    "sdf": "storage",
    "sh": "terminal",
+    "sol": "solidity",
    "sql": "storage",
    "sqlite": "storage",
-    "svelte": "template",
+    "stylelint.config.cjs": "stylelint",
+    "stylelint.config.js": "stylelint",
+    "stylelint.config.mjs": "stylelint",
+    "stylelintignore": "stylelint",
+    "stylelintrc": "stylelint",
+    "stylelintrc.cjs": "stylelint",
+    "stylelintrc.js": "stylelint",
+    "stylelintrc.json": "stylelint",
+    "stylelintrc.mjs": "stylelint",
+    "stylelintrc.yaml": "stylelint",
+    "stylelintrc.yml": "stylelint",
+    "svelte": "svelte",
    "svg": "image",
    "swift": "swift",
    "tcl": "tcl",
--- a/assets/icons/lock_outlined.svg
+++ b/assets/icons/lock_outlined.svg
@@ -0,0 +1,6 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5 5C5 3.89543 5.89543 3 7 3H9C10.1046 3 11 3.89543 11 5V6H5V5Z" stroke="black" stroke-width="1.5"/>
+<path d="M8 9V11" stroke="black" stroke-width="1.5" stroke-linecap="round"/>
+<circle cx="8" cy="9" r="1" fill="black"/>
+<rect x="3.75" y="5.75" width="8.5" height="7.5" rx="1.25" stroke="black" stroke-width="1.5" stroke-linejoin="round"/>
+</svg>
--- a/assets/icons/zed_predict_bg.svg
+++ b/assets/icons/zed_predict_bg.svg
@@ -1,6 +1,6 @@
-<svg width="420" height="128" xmlns="http://www.w3.org/2000/svg">
+<svg width="550" height="128" xmlns="http://www.w3.org/2000/svg">
  <defs>
-    <pattern id="tilePattern" width="22" height="22" patternUnits="userSpaceOnUse">
+    <pattern id="tilePattern" width="23" height="23" patternUnits="userSpaceOnUse">
      <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
        <path d="M12 5L14 8L12 11" stroke="black" stroke-width="1.5"/>
        <path d="M10 6.5L11 8L10 9.5" stroke="black" stroke-width="1.5"/>
--- a/assets/icons/zed_predict_disabled.svg
+++ b/assets/icons/zed_predict_disabled.svg
@@ -0,0 +1,6 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path opacity="0.6" fill-rule="evenodd" clip-rule="evenodd" d="M6.75 9.31247L8.25 10.5576V11.75H1.75V10.0803L4.49751 7.44273L5.65909 8.40693L3.73923 10.25H6.75V9.31247ZM8.25 5.85739V4.25H6.31358L8.25 5.85739ZM1.75 5.16209V7.1H3.25V6.4072L1.75 5.16209Z" fill="black"/>
+<path opacity="0.6" fill-rule="evenodd" clip-rule="evenodd" d="M10.9624 9.40853L11.9014 8L10.6241 6.08397L9.37598 6.91603L10.0986 8L9.80184 8.44518L10.9624 9.40853Z" fill="black"/>
+<path opacity="0.6" fill-rule="evenodd" clip-rule="evenodd" d="M12.8936 11.0116L14.9014 8L12.6241 4.58397L11.376 5.41603L13.0986 8L11.7331 10.0483L12.8936 11.0116Z" fill="black"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M14.1225 13.809C14.0341 13.9146 13.877 13.9289 13.7711 13.8409L1.19311 3.40021C1.08659 3.31178 1.07221 3.15362 1.16104 3.04743L1.87752 2.19101C1.96588 2.0854 2.123 2.07112 2.22895 2.15906L14.8069 12.5998C14.9134 12.6882 14.9278 12.8464 14.839 12.9526L14.1225 13.809Z" fill="black"/>
+</svg>
--- a/assets/icons/zed_predict_down.svg
+++ b/assets/icons/zed_predict_down.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M15 9.33333L14.5 9.66667L12.5 11L10.5 9.66667L10 9.33333" stroke="black" stroke-width="1.5"/>
+<path d="M12.5 11V4.5" stroke="black" stroke-width="1.5"/>
+<path d="M7.5 8.9V11C5.43097 11 4.56903 11 2.5 11V10.4L7.5 5.6V5H2.5V7.1" stroke="black" stroke-width="1.5"/>
+</svg>
--- a/assets/icons/zed_predict_up.svg
+++ b/assets/icons/zed_predict_up.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10 6.66667L10.5 6.33333L12.5 5L14.5 6.33333L15 6.66667" stroke="black" stroke-width="1.5"/>
+<path d="M12.5 11V5" stroke="black" stroke-width="1.5"/>
+<path d="M7.5 8.9V11C5.43097 11 4.56903 11 2.5 11V10.4L7.5 5.6V5H2.5V7.1" stroke="black" stroke-width="1.5"/>
+</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -31,8 +31,8 @@
      "ctrl-,": "zed::OpenSettings",
      "ctrl-q": "zed::Quit",
      "f11": "zed::ToggleFullScreen",
-      "ctrl-alt-z": "zeta::RateCompletions",
-      "ctrl-shift-i": "inline_completion::ToggleMenu"
+      "ctrl-alt-z": "edit_prediction::RateCompletions",
+      "ctrl-shift-i": "edit_prediction::ToggleMenu"
    }
  },
  {
@@ -122,7 +122,8 @@
      "ctrl-i": "editor::ShowSignatureHelp",
      "alt-g b": "editor::ToggleGitBlame",
      "menu": "editor::OpenContextMenu",
-      "shift-f10": "editor::OpenContextMenu"
+      "shift-f10": "editor::OpenContextMenu",
+      "ctrl-shift-e": "editor::ToggleEditPrediction"
    }
  },
  {
@@ -145,17 +146,17 @@
    }
  },
  {
-    "context": "Editor && mode == full && inline_completion",
+    "context": "Editor && mode == full && edit_prediction",
    "bindings": {
-      "alt-]": "editor::NextInlineCompletion",
-      "alt-[": "editor::PreviousInlineCompletion",
-      "alt-right": "editor::AcceptPartialInlineCompletion"
+      "alt-]": "editor::NextEditPrediction",
+      "alt-[": "editor::PreviousEditPrediction",
+      "alt-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
-    "context": "Editor && !inline_completion",
+    "context": "Editor && !edit_prediction",
    "bindings": {
-      "alt-\\": "editor::ShowInlineCompletion"
+      "alt-\\": "editor::ShowEditPrediction"
    }
  },
  {
@@ -203,8 +204,8 @@
      "enter": "search::SelectNextMatch",
      "shift-enter": "search::SelectPrevMatch",
      "alt-enter": "search::SelectAllMatches",
-      "ctrl-f": "search::FocusSearch",
      "find": "search::FocusSearch",
+      "ctrl-f": "search::FocusSearch",
      "ctrl-h": "search::ToggleReplace",
      "ctrl-l": "search::ToggleSelection"
    }
@@ -274,8 +275,8 @@
      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-shift-pageup": "pane::SwapItemLeft",
      "ctrl-shift-pagedown": "pane::SwapItemRight",
-      "ctrl-f4": "pane::CloseActiveItem",
-      "ctrl-w": "pane::CloseActiveItem",
+      "ctrl-f4": ["pane::CloseActiveItem", { "close_pinned": false }],
+      "ctrl-w": ["pane::CloseActiveItem", { "close_pinned": false }],
      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
      "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
@@ -290,15 +291,15 @@
      "f3": "search::SelectNextMatch",
      "ctrl-alt-shift-g": "search::SelectPrevMatch",
      "shift-f3": "search::SelectPrevMatch",
-      "ctrl-shift-f": "project_search::ToggleFocus",
      "shift-find": "project_search::ToggleFocus",
+      "ctrl-shift-f": "project_search::ToggleFocus",
      "ctrl-alt-shift-h": "search::ToggleReplace",
      "ctrl-alt-shift-l": "search::ToggleSelection",
      "alt-enter": "search::SelectAllMatches",
      "alt-c": "search::ToggleCaseSensitive",
      "alt-w": "search::ToggleWholeWord",
-      "alt-ctrl-f": "project_search::ToggleFilters",
      "alt-find": "project_search::ToggleFilters",
+      "alt-ctrl-f": "project_search::ToggleFilters",
      "ctrl-alt-shift-r": "search::ToggleRegex",
      "ctrl-alt-shift-x": "search::ToggleRegex",
      "alt-r": "search::ToggleRegex",
@@ -348,15 +349,15 @@
      "ctrl-k ctrl-l": "editor::ToggleFold",
      "ctrl-k ctrl-[": "editor::FoldRecursive",
      "ctrl-k ctrl-]": "editor::UnfoldRecursive",
-      "ctrl-k ctrl-1": ["editor::FoldAtLevel", { "level": 1 }],
-      "ctrl-k ctrl-2": ["editor::FoldAtLevel", { "level": 2 }],
-      "ctrl-k ctrl-3": ["editor::FoldAtLevel", { "level": 3 }],
-      "ctrl-k ctrl-4": ["editor::FoldAtLevel", { "level": 4 }],
-      "ctrl-k ctrl-5": ["editor::FoldAtLevel", { "level": 5 }],
-      "ctrl-k ctrl-6": ["editor::FoldAtLevel", { "level": 6 }],
-      "ctrl-k ctrl-7": ["editor::FoldAtLevel", { "level": 7 }],
-      "ctrl-k ctrl-8": ["editor::FoldAtLevel", { "level": 8 }],
-      "ctrl-k ctrl-9": ["editor::FoldAtLevel", { "level": 9 }],
+      "ctrl-k ctrl-1": ["editor::FoldAtLevel", 1],
+      "ctrl-k ctrl-2": ["editor::FoldAtLevel", 2],
+      "ctrl-k ctrl-3": ["editor::FoldAtLevel", 3],
+      "ctrl-k ctrl-4": ["editor::FoldAtLevel", 4],
+      "ctrl-k ctrl-5": ["editor::FoldAtLevel", 5],
+      "ctrl-k ctrl-6": ["editor::FoldAtLevel", 6],
+      "ctrl-k ctrl-7": ["editor::FoldAtLevel", 7],
+      "ctrl-k ctrl-8": ["editor::FoldAtLevel", 8],
+      "ctrl-k ctrl-9": ["editor::FoldAtLevel", 9],
      "ctrl-k ctrl-0": "editor::FoldAll",
      "ctrl-k ctrl-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
@@ -432,14 +433,14 @@
      "ctrl-alt-s": "workspace::SaveAll",
      "ctrl-k m": "language_selector::Toggle",
      "escape": "workspace::Unfollow",
-      "ctrl-k ctrl-left": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-k ctrl-right": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-k ctrl-up": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-k ctrl-down": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-k shift-left": ["workspace::SwapPaneInDirection", "Left"],
-      "ctrl-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
-      "ctrl-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
-      "ctrl-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
+      "ctrl-k ctrl-left": "workspace::ActivatePaneLeft",
+      "ctrl-k ctrl-right": "workspace::ActivatePaneRight",
+      "ctrl-k ctrl-up": "workspace::ActivatePaneUp",
+      "ctrl-k ctrl-down": "workspace::ActivatePaneDown",
+      "ctrl-k shift-left": "workspace::SwapPaneLeft",
+      "ctrl-k shift-right": "workspace::SwapPaneRight",
+      "ctrl-k shift-up": "workspace::SwapPaneUp",
+      "ctrl-k shift-down": "workspace::SwapPaneDown",
      "ctrl-shift-x": "zed::Extensions",
      "ctrl-shift-r": "task::Rerun",
      "ctrl-alt-r": "task::Rerun",
@@ -453,8 +454,8 @@
  {
    "context": "ApplicationMenu",
    "bindings": {
-      "left": ["app_menu::NavigateApplicationMenuInDirection", "Left"],
-      "right": ["app_menu::NavigateApplicationMenuInDirection", "Right"]
+      "left": "app_menu::ActivateMenuLeft",
+      "right": "app_menu::ActivateMenuRight"
    }
  },
  // Bindings from Sublime Text
@@ -496,17 +497,27 @@
  },
  {
    "context": "Editor && showing_completions",
-    "use_key_equivalents": true,
    "bindings": {
      "enter": "editor::ConfirmCompletion",
      "tab": "editor::ComposeCompletion"
    }
  },
+  // Bindings for accepting edit predictions
+  //
+  // alt-l is provided as an alternative to tab/alt-tab. and will be displayed in the UI. This is
+  // because alt-tab may not be available, as it is often used for window switching.
  {
-    "context": "Editor && inline_completion && !showing_completions",
-    "use_key_equivalents": true,
+    "context": "Editor && edit_prediction",
    "bindings": {
-      "tab": "editor::AcceptInlineCompletion"
+      "alt-tab": "editor::AcceptEditPrediction",
+      "alt-l": "editor::AcceptEditPrediction"
+    }
+  },
+  {
+    "context": "Editor && edit_prediction && !edit_prediction_requires_modifier",
+    "bindings": {
+      "tab": "editor::AcceptEditPrediction",
+      "alt-l": "editor::AcceptEditPrediction"
    }
  },
  {
@@ -530,8 +541,7 @@
  {
    "bindings": {
      "ctrl-alt-shift-f": "workspace::FollowNextCollaborator",
-      "ctrl-alt-i": "zed::DebugElements",
-      "ctrl-:": "editor::ToggleInlayHints"
+      "ctrl-alt-i": "zed::DebugElements"
    }
  },
  {
@@ -549,7 +559,8 @@
      "ctrl-shift-e": "pane::RevealInProjectPanel",
      "ctrl-f8": "editor::GoToHunk",
      "ctrl-shift-f8": "editor::GoToPrevHunk",
-      "ctrl-enter": "assistant::InlineAssist"
+      "ctrl-enter": "assistant::InlineAssist",
+      "ctrl-:": "editor::ToggleInlayHints"
    }
  },
  {
@@ -595,14 +606,12 @@
  },
  {
    "context": "MessageEditor > Editor",
-    "use_key_equivalents": true,
    "bindings": {
      "enter": "assistant2::Chat"
    }
  },
  {
    "context": "ContextStrip",
-    "use_key_equivalents": true,
    "bindings": {
      "up": "assistant2::FocusUp",
      "right": "assistant2::FocusRight",
@@ -680,8 +689,8 @@
      "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
      "alt-ctrl-r": "project_panel::RevealInFileManager",
      "ctrl-shift-enter": "project_panel::OpenWithSystem",
-      "ctrl-shift-f": "project_panel::NewSearchInDirectory",
      "shift-find": "project_panel::NewSearchInDirectory",
+      "ctrl-shift-f": "project_panel::NewSearchInDirectory",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev",
      "escape": "menu::Cancel"
@@ -695,30 +704,32 @@
  },
  {
    "context": "GitPanel && !CommitEditor",
-    "use_key_equivalents": true,
    "bindings": {
      "escape": "git_panel::Close"
    }
  },
  {
    "context": "GitPanel && ChangesList",
-    "use_key_equivalents": true,
    "bindings": {
      "up": "menu::SelectPrev",
      "down": "menu::SelectNext",
      "enter": "menu::Confirm",
      "space": "git::ToggleStaged",
      "ctrl-space": "git::StageAll",
-      "ctrl-shift-space": "git::UnstageAll"
+      "ctrl-shift-space": "git::UnstageAll",
+      "tab": "git_panel::FocusEditor",
+      "shift-tab": "git_panel::FocusEditor",
+      "escape": "git_panel::ToggleFocus"
    }
  },
  {
-    "context": "GitPanel && CommitEditor > Editor",
-    "use_key_equivalents": true,
+    "context": "GitPanel > Editor",
    "bindings": {
      "escape": "git_panel::FocusChanges",
-      "ctrl-enter": "git::CommitChanges",
-      "ctrl-shift-enter": "git::CommitAllChanges"
+      "ctrl-enter": "git::Commit",
+      "tab": "git_panel::FocusChanges",
+      "shift-tab": "git_panel::FocusChanges",
+      "alt-up": "git_panel::FocusChanges"
    }
  },
  {
@@ -826,7 +837,6 @@
  },
  {
    "context": "ZedPredictModal",
-    "use_key_equivalents": true,
    "bindings": {
      "escape": "menu::Cancel"
    }
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -39,8 +39,8 @@
      "cmd-m": "zed::Minimize",
      "fn-f": "zed::ToggleFullScreen",
      "ctrl-cmd-f": "zed::ToggleFullScreen",
-      "ctrl-shift-z": "zeta::RateCompletions",
-      "ctrl-shift-i": "inline_completion::ToggleMenu"
+      "ctrl-cmd-z": "edit_prediction::RateCompletions",
+      "ctrl-cmd-i": "edit_prediction::ToggleMenu"
    }
  },
  {
@@ -132,7 +132,8 @@
      "cmd-alt-g b": "editor::ToggleGitBlame",
      "cmd-i": "editor::ShowSignatureHelp",
      "ctrl-f12": "editor::GoToDeclaration",
-      "alt-ctrl-f12": "editor::GoToDeclarationSplit"
+      "alt-ctrl-f12": "editor::GoToDeclarationSplit",
+      "ctrl-cmd-e": "editor::ToggleEditPrediction"
    }
  },
  {
@@ -155,19 +156,19 @@
    }
  },
  {
-    "context": "Editor && mode == full && inline_completion",
+    "context": "Editor && mode == full && edit_prediction",
    "use_key_equivalents": true,
    "bindings": {
-      "alt-tab": "editor::NextInlineCompletion",
-      "alt-shift-tab": "editor::PreviousInlineCompletion",
-      "ctrl-cmd-right": "editor::AcceptPartialInlineCompletion"
+      "alt-tab": "editor::NextEditPrediction",
+      "alt-shift-tab": "editor::PreviousEditPrediction",
+      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
-    "context": "Editor && !inline_completion",
+    "context": "Editor && !edit_prediction",
    "use_key_equivalents": true,
    "bindings": {
-      "alt-tab": "editor::ShowInlineCompletion"
+      "alt-tab": "editor::ShowEditPrediction"
    }
  },
  {
@@ -349,7 +350,7 @@
      "cmd-}": "pane::ActivateNextItem",
      "ctrl-shift-pageup": "pane::SwapItemLeft",
      "ctrl-shift-pagedown": "pane::SwapItemRight",
-      "cmd-w": "pane::CloseActiveItem",
+      "cmd-w": ["pane::CloseActiveItem", { "close_pinned": false }],
      "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
      "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
      "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
@@ -413,15 +414,15 @@
      "cmd-k cmd-l": "editor::ToggleFold",
      "cmd-k cmd-[": "editor::FoldRecursive",
      "cmd-k cmd-]": "editor::UnfoldRecursive",
-      "cmd-k cmd-1": ["editor::FoldAtLevel", { "level": 1 }],
-      "cmd-k cmd-2": ["editor::FoldAtLevel", { "level": 2 }],
-      "cmd-k cmd-3": ["editor::FoldAtLevel", { "level": 3 }],
-      "cmd-k cmd-4": ["editor::FoldAtLevel", { "level": 4 }],
-      "cmd-k cmd-5": ["editor::FoldAtLevel", { "level": 5 }],
-      "cmd-k cmd-6": ["editor::FoldAtLevel", { "level": 6 }],
-      "cmd-k cmd-7": ["editor::FoldAtLevel", { "level": 7 }],
-      "cmd-k cmd-8": ["editor::FoldAtLevel", { "level": 8 }],
-      "cmd-k cmd-9": ["editor::FoldAtLevel", { "level": 9 }],
+      "cmd-k cmd-1": ["editor::FoldAtLevel", 1],
+      "cmd-k cmd-2": ["editor::FoldAtLevel", 2],
+      "cmd-k cmd-3": ["editor::FoldAtLevel", 3],
+      "cmd-k cmd-4": ["editor::FoldAtLevel", 4],
+      "cmd-k cmd-5": ["editor::FoldAtLevel", 5],
+      "cmd-k cmd-6": ["editor::FoldAtLevel", 6],
+      "cmd-k cmd-7": ["editor::FoldAtLevel", 7],
+      "cmd-k cmd-8": ["editor::FoldAtLevel", 8],
+      "cmd-k cmd-9": ["editor::FoldAtLevel", 9],
      "cmd-k cmd-0": "editor::FoldAll",
      "cmd-k cmd-j": "editor::UnfoldAll",
      // Using `ctrl-space` in Zed requires disabling the macOS global shortcut.
@@ -509,14 +510,14 @@
      "cmd-alt-s": "workspace::SaveAll",
      "cmd-k m": "language_selector::Toggle",
      "escape": "workspace::Unfollow",
-      "cmd-k cmd-left": ["workspace::ActivatePaneInDirection", "Left"],
-      "cmd-k cmd-right": ["workspace::ActivatePaneInDirection", "Right"],
-      "cmd-k cmd-up": ["workspace::ActivatePaneInDirection", "Up"],
-      "cmd-k cmd-down": ["workspace::ActivatePaneInDirection", "Down"],
-      "cmd-k shift-left": ["workspace::SwapPaneInDirection", "Left"],
-      "cmd-k shift-right": ["workspace::SwapPaneInDirection", "Right"],
-      "cmd-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
-      "cmd-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
+      "cmd-k cmd-left": "workspace::ActivatePaneLeft",
+      "cmd-k cmd-right": "workspace::ActivatePaneRight",
+      "cmd-k cmd-up": "workspace::ActivatePaneUp",
+      "cmd-k cmd-down": "workspace::ActivatePaneDown",
+      "cmd-k shift-left": "workspace::SwapPaneLeft",
+      "cmd-k shift-right": "workspace::SwapPaneRight",
+      "cmd-k shift-up": "workspace::SwapPaneUp",
+      "cmd-k shift-down": "workspace::SwapPaneDown",
      "cmd-shift-x": "zed::Extensions"
    }
  },
@@ -580,10 +581,16 @@
    }
  },
  {
-    "context": "Editor && inline_completion && !showing_completions",
+    "context": "Editor && edit_prediction",
+    "bindings": {
+      "alt-tab": "editor::AcceptEditPrediction"
+    }
+  },
+  {
+    "context": "Editor && edit_prediction && !edit_prediction_requires_modifier",
    "use_key_equivalents": true,
    "bindings": {
-      "tab": "editor::AcceptInlineCompletion"
+      "tab": "editor::AcceptEditPrediction"
    }
  },
  {
@@ -612,8 +619,7 @@
      "ctrl-alt-cmd-f": "workspace::FollowNextCollaborator",
      // TODO: Move this to a dock open action
      "cmd-shift-c": "collab_panel::ToggleFocus",
-      "cmd-alt-i": "zed::DebugElements",
-      "ctrl-:": "editor::ToggleInlayHints"
+      "cmd-alt-i": "zed::DebugElements"
    }
  },
  {
@@ -626,7 +632,8 @@
      "cmd-shift-e": "pane::RevealInProjectPanel",
      "cmd-f8": "editor::GoToHunk",
      "cmd-shift-f8": "editor::GoToPrevHunk",
-      "ctrl-enter": "assistant::InlineAssist"
+      "ctrl-enter": "assistant::InlineAssist",
+      "ctrl-:": "editor::ToggleInlayHints"
    }
  },
  {
@@ -708,13 +715,6 @@
      "space": "project_panel::Open"
    }
  },
-  {
-    "context": "GitPanel && !CommitEditor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "escape": "git_panel::Close"
-    }
-  },
  {
    "context": "GitPanel && ChangesList",
    "use_key_equivalents": true,
@@ -727,17 +727,21 @@
      "space": "git::ToggleStaged",
      "cmd-shift-space": "git::StageAll",
      "ctrl-shift-space": "git::UnstageAll",
-      "alt-down": "git_panel::FocusEditor"
+      "alt-down": "git_panel::FocusEditor",
+      "tab": "git_panel::FocusEditor",
+      "shift-tab": "git_panel::FocusEditor",
+      "escape": "git_panel::ToggleFocus"
    }
  },
  {
-    "context": "GitPanel && CommitEditor > Editor",
+    "context": "GitPanel > Editor",
    "use_key_equivalents": true,
    "bindings": {
-      "alt-up": "git_panel::FocusChanges",
-      "escape": "git_panel::FocusChanges",
-      "cmd-enter": "git::CommitChanges",
-      "cmd-alt-enter": "git::CommitAllChanges"
+      "enter": "editor::Newline",
+      "cmd-enter": "git::Commit",
+      "tab": "git_panel::FocusChanges",
+      "shift-tab": "git_panel::FocusChanges",
+      "alt-up": "git_panel::FocusChanges"
    }
  },
  {
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -2,8 +2,8 @@
  {
    "context": "VimControl && !menu",
    "bindings": {
-      "i": ["vim::PushOperator", { "Object": { "around": false } }],
-      "a": ["vim::PushOperator", { "Object": { "around": true } }],
+      "i": ["vim::PushObject", { "around": false }],
+      "a": ["vim::PushObject", { "around": true }],
      "left": "vim::Left",
      "h": "vim::Left",
      "backspace": "vim::Backspace",
@@ -54,10 +54,10 @@
      // "b": "vim::PreviousSubwordStart",
      // "e": "vim::NextSubwordEnd",
      // "g e": "vim::PreviousSubwordEnd",
-      "shift-w": ["vim::NextWordStart", { "ignorePunctuation": true }],
-      "shift-e": ["vim::NextWordEnd", { "ignorePunctuation": true }],
-      "shift-b": ["vim::PreviousWordStart", { "ignorePunctuation": true }],
-      "g shift-e": ["vim::PreviousWordEnd", { "ignorePunctuation": true }],
+      "shift-w": ["vim::NextWordStart", { "ignore_punctuation": true }],
+      "shift-e": ["vim::NextWordEnd", { "ignore_punctuation": true }],
+      "shift-b": ["vim::PreviousWordStart", { "ignore_punctuation": true }],
+      "g shift-e": ["vim::PreviousWordEnd", { "ignore_punctuation": true }],
      "/": "vim::Search",
      "g /": "pane::DeploySearch",
      "?": ["vim::Search", { "backwards": true }],
@@ -70,20 +70,20 @@
      "[ {": ["vim::UnmatchedBackward", { "char": "{" }],
      "] )": ["vim::UnmatchedForward", { "char": ")" }],
      "[ (": ["vim::UnmatchedBackward", { "char": "(" }],
-      "f": ["vim::PushOperator", { "FindForward": { "before": false } }],
-      "t": ["vim::PushOperator", { "FindForward": { "before": true } }],
-      "shift-f": ["vim::PushOperator", { "FindBackward": { "after": false } }],
-      "shift-t": ["vim::PushOperator", { "FindBackward": { "after": true } }],
-      "m": ["vim::PushOperator", "Mark"],
-      "'": ["vim::PushOperator", { "Jump": { "line": true } }],
-      "`": ["vim::PushOperator", { "Jump": { "line": false } }],
+      "f": ["vim::PushFindForward", { "before": false }],
+      "t": ["vim::PushFindForward", { "before": true }],
+      "shift-f": ["vim::PushFindBackward", { "after": false }],
+      "shift-t": ["vim::PushFindBackward", { "after": true }],
+      "m": "vim::PushMark",
+      "'": ["vim::PushJump", { "line": true }],
+      "`": ["vim::PushJump", { "line": false }],
      ";": "vim::RepeatFind",
      ",": "vim::RepeatFindReversed",
      "ctrl-o": "pane::GoBack",
      "ctrl-i": "pane::GoForward",
      "ctrl-]": "editor::GoToDefinition",
-      "escape": ["vim::SwitchMode", "Normal"],
-      "ctrl-[": ["vim::SwitchMode", "Normal"],
+      "escape": "vim::SwitchToNormalMode",
+      "ctrl-[": "vim::SwitchToNormalMode",
      "v": "vim::ToggleVisual",
      "shift-v": "vim::ToggleVisualLine",
      "ctrl-g": "vim::ShowLocation",
@@ -102,6 +102,7 @@
      "ctrl-e": "vim::LineDown",
      "ctrl-y": "vim::LineUp",
      // "g" commands
+      "g r": "vim::PushReplaceWithRegister",
      "g g": "vim::StartOfDocument",
      "g h": "editor::Hover",
      "g t": "pane::ActivateNextItem",
@@ -124,17 +125,17 @@
      "g .": "editor::ToggleCodeActions", // zed specific
      "g shift-a": "editor::FindAllReferences", // zed specific
      "g space": "editor::OpenExcerpts", // zed specific
-      "g *": ["vim::MoveToNext", { "partialWord": true }],
-      "g #": ["vim::MoveToPrev", { "partialWord": true }],
-      "g j": ["vim::Down", { "displayLines": true }],
-      "g down": ["vim::Down", { "displayLines": true }],
-      "g k": ["vim::Up", { "displayLines": true }],
-      "g up": ["vim::Up", { "displayLines": true }],
-      "g $": ["vim::EndOfLine", { "displayLines": true }],
-      "g end": ["vim::EndOfLine", { "displayLines": true }],
-      "g 0": ["vim::StartOfLine", { "displayLines": true }],
-      "g home": ["vim::StartOfLine", { "displayLines": true }],
-      "g ^": ["vim::FirstNonWhitespace", { "displayLines": true }],
+      "g *": ["vim::MoveToNext", { "partial_word": true }],
+      "g #": ["vim::MoveToPrev", { "partial_word": true }],
+      "g j": ["vim::Down", { "display_lines": true }],
+      "g down": ["vim::Down", { "display_lines": true }],
+      "g k": ["vim::Up", { "display_lines": true }],
+      "g up": ["vim::Up", { "display_lines": true }],
+      "g $": ["vim::EndOfLine", { "display_lines": true }],
+      "g end": ["vim::EndOfLine", { "display_lines": true }],
+      "g 0": ["vim::StartOfLine", { "display_lines": true }],
+      "g home": ["vim::StartOfLine", { "display_lines": true }],
+      "g ^": ["vim::FirstNonWhitespace", { "display_lines": true }],
      "g v": "vim::RestoreVisualSelection",
      "g ]": "editor::GoToDiagnostic",
      "g [": "editor::GoToPrevDiagnostic",
@@ -146,7 +147,7 @@
      "shift-l": "vim::WindowBottom",
      "q": "vim::ToggleRecord",
      "shift-q": "vim::ReplayLastRecording",
-      "@": ["vim::PushOperator", "ReplayRegister"],
+      "@": "vim::PushReplayRegister",
      // z commands
      "z enter": ["workspace::SendKeystrokes", "z t ^"],
      "z -": ["workspace::SendKeystrokes", "z b ^"],
@@ -165,8 +166,8 @@
      "z f": "editor::FoldSelectedRanges",
      "z shift-m": "editor::FoldAll",
      "z shift-r": "editor::UnfoldAll",
-      "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
-      "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
+      "shift-z shift-q": ["pane::CloseActiveItem", { "save_intent": "skip" }],
+      "shift-z shift-z": ["pane::CloseActiveItem", { "save_intent": "save_all" }],
      // Count support
      "1": ["vim::Number", 1],
      "2": ["vim::Number", 2],
@@ -193,13 +194,13 @@
      "escape": "editor::Cancel",
      ":": "command_palette::Toggle",
      ".": "vim::Repeat",
-      "c": ["vim::PushOperator", "Change"],
+      "c": "vim::PushChange",
      "shift-c": "vim::ChangeToEndOfLine",
-      "d": ["vim::PushOperator", "Delete"],
+      "d": "vim::PushDelete",
      "shift-d": "vim::DeleteToEndOfLine",
      "shift-j": "vim::JoinLines",
      "g shift-j": "vim::JoinLinesNoWhitespace",
-      "y": ["vim::PushOperator", "Yank"],
+      "y": "vim::PushYank",
      "shift-y": "vim::YankLine",
      "i": "vim::InsertBefore",
      "shift-i": "vim::InsertFirstNonWhitespace",
@@ -216,19 +217,19 @@
      "shift-p": ["vim::Paste", { "before": true }],
      "u": "vim::Undo",
      "ctrl-r": "vim::Redo",
-      "r": ["vim::PushOperator", "Replace"],
+      "r": "vim::PushReplace",
      "s": "vim::Substitute",
      "shift-s": "vim::SubstituteLine",
-      ">": ["vim::PushOperator", "Indent"],
-      "<": ["vim::PushOperator", "Outdent"],
-      "=": ["vim::PushOperator", "AutoIndent"],
-      "!": ["vim::PushOperator", "ShellCommand"],
-      "g u": ["vim::PushOperator", "Lowercase"],
-      "g shift-u": ["vim::PushOperator", "Uppercase"],
-      "g ~": ["vim::PushOperator", "OppositeCase"],
-      "\"": ["vim::PushOperator", "Register"],
-      "g w": ["vim::PushOperator", "Rewrap"],
-      "g q": ["vim::PushOperator", "Rewrap"],
+      ">": "vim::PushIndent",
+      "<": "vim::PushOutdent",
+      "=": "vim::PushAutoIndent",
+      "!": "vim::PushShellCommand",
+      "g u": "vim::PushLowercase",
+      "g shift-u": "vim::PushUppercase",
+      "g ~": "vim::PushOppositeCase",
+      "\"": "vim::PushRegister",
+      "g w": "vim::PushRewrap",
+      "g q": "vim::PushRewrap",
      "ctrl-pagedown": "pane::ActivateNextItem",
      "ctrl-pageup": "pane::ActivatePrevItem",
      "insert": "vim::InsertBefore",
@@ -239,7 +240,7 @@
      "[ d": "editor::GoToPrevDiagnostic",
      "] c": "editor::GoToHunk",
      "[ c": "editor::GoToPrevHunk",
-      "g c": ["vim::PushOperator", "ToggleComments"]
+      "g c": "vim::PushToggleComments"
    }
  },
  {
@@ -264,14 +265,14 @@
      "y": "vim::VisualYank",
      "shift-y": "vim::VisualYankLine",
      "p": "vim::Paste",
-      "shift-p": ["vim::Paste", { "preserveClipboard": true }],
+      "shift-p": ["vim::Paste", { "preserve_clipboard": true }],
      "c": "vim::Substitute",
      "s": "vim::Substitute",
      "shift-r": "vim::SubstituteLine",
      "shift-s": "vim::SubstituteLine",
      "~": "vim::ChangeCase",
-      "*": ["vim::MoveToNext", { "partialWord": true }],
-      "#": ["vim::MoveToPrev", { "partialWord": true }],
+      "*": ["vim::MoveToNext", { "partial_word": true }],
+      "#": ["vim::MoveToPrev", { "partial_word": true }],
      "ctrl-a": "vim::Increment",
      "ctrl-x": "vim::Decrement",
      "g ctrl-a": ["vim::Increment", { "step": true }],
@@ -282,19 +283,19 @@
      "g shift-a": "vim::VisualInsertEndOfLine",
      "shift-j": "vim::JoinLines",
      "g shift-j": "vim::JoinLinesNoWhitespace",
-      "r": ["vim::PushOperator", "Replace"],
-      "ctrl-c": ["vim::SwitchMode", "Normal"],
-      "ctrl-[": ["vim::SwitchMode", "Normal"],
-      "escape": ["vim::SwitchMode", "Normal"],
+      "r": "vim::PushReplace",
+      "ctrl-c": "vim::SwitchToNormalMode",
+      "ctrl-[": "vim::SwitchToNormalMode",
+      "escape": "vim::SwitchToNormalMode",
      ">": "vim::Indent",
      "<": "vim::Outdent",
      "=": "vim::AutoIndent",
      "!": "vim::ShellCommand",
-      "i": ["vim::PushOperator", { "Object": { "around": false } }],
-      "a": ["vim::PushOperator", { "Object": { "around": true } }],
+      "i": ["vim::PushObject", { "around": false }],
+      "a": ["vim::PushObject", { "around": true }],
      "g c": "vim::ToggleComments",
      "g q": "vim::Rewrap",
-      "\"": ["vim::PushOperator", "Register"],
+      "\"": "vim::PushRegister",
      // tree-sitter related commands
      "[ x": "editor::SelectLargerSyntaxNode",
      "] x": "editor::SelectSmallerSyntaxNode"
@@ -309,19 +310,19 @@
      "ctrl-x": null,
      "ctrl-x ctrl-o": "editor::ShowCompletions",
      "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
-      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
+      "ctrl-x ctrl-c": "editor::ShowEditPrediction", // zed specific
      "ctrl-x ctrl-l": "editor::ToggleCodeActions", // zed specific
      "ctrl-x ctrl-z": "editor::Cancel",
      "ctrl-w": "editor::DeleteToPreviousWordStart",
      "ctrl-u": "editor::DeleteToBeginningOfLine",
      "ctrl-t": "vim::Indent",
      "ctrl-d": "vim::Outdent",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-k": ["vim::PushDigraph", {}],
+      "ctrl-v": ["vim::PushLiteral", {}],
      "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-r": ["vim::PushOperator", "Register"],
+      "ctrl-q": ["vim::PushLiteral", {}],
+      "ctrl-shift-q": ["vim::PushLiteral", {}],
+      "ctrl-r": "vim::PushRegister",
      "insert": "vim::ToggleReplace",
      "ctrl-o": "vim::TemporaryNormal"
    }
@@ -356,11 +357,11 @@
      "ctrl-c": "vim::NormalBefore",
      "ctrl-[": "vim::NormalBefore",
      "escape": "vim::NormalBefore",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-k": ["vim::PushDigraph", {}],
+      "ctrl-v": ["vim::PushLiteral", {}],
      "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
+      "ctrl-q": ["vim::PushLiteral", {}],
+      "ctrl-shift-q": ["vim::PushLiteral", {}],
      "backspace": "vim::UndoReplace",
      "tab": "vim::Tab",
      "enter": "vim::Enter",
@@ -375,9 +376,15 @@
      "ctrl-c": "vim::ClearOperators",
      "ctrl-[": "vim::ClearOperators",
      "escape": "vim::ClearOperators",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }]
+      "ctrl-k": ["vim::PushDigraph", {}],
+      "ctrl-v": ["vim::PushLiteral", {}],
+      "ctrl-q": ["vim::PushLiteral", {}]
+    }
+  },
+  {
+    "context": "Editor && vim_mode == waiting && (vim_operator == ys || vim_operator == cs)",
+    "bindings": {
+      "escape": "vim::SwitchToNormalMode"
    }
  },
  {
@@ -393,10 +400,10 @@
    "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
    "bindings": {
      "w": "vim::Word",
-      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
+      "shift-w": ["vim::Word", { "ignore_punctuation": true }],
      // Subword TextObject
      // "w": "vim::Subword",
-      // "shift-w": ["vim::Subword", { "ignorePunctuation": true }],
+      // "shift-w": ["vim::Subword", { "ignore_punctuation": true }],
      "t": "vim::Tag",
      "s": "vim::Sentence",
      "p": "vim::Paragraph",
@@ -419,9 +426,10 @@
      ">": "vim::AngleBrackets",
      "a": "vim::Argument",
      "i": "vim::IndentObj",
-      "shift-i": ["vim::IndentObj", { "includeBelow": true }],
+      "shift-i": ["vim::IndentObj", { "include_below": true }],
      "f": "vim::Method",
-      "c": "vim::Class"
+      "c": "vim::Class",
+      "e": "vim::EntireFile"
    }
  },
  {
@@ -429,14 +437,14 @@
    "bindings": {
      "c": "vim::CurrentLine",
      "d": "editor::Rename", // zed specific
-      "s": ["vim::PushOperator", { "ChangeSurrounds": {} }]
+      "s": ["vim::PushChangeSurrounds", {}]
    }
  },
  {
    "context": "vim_operator == d",
    "bindings": {
      "d": "vim::CurrentLine",
-      "s": ["vim::PushOperator", "DeleteSurrounds"],
+      "s": "vim::PushDeleteSurrounds",
      "o": "editor::ToggleSelectedDiffHunks", // "d o"
      "p": "editor::RevertSelectedHunks" // "d p"
    }
@@ -475,7 +483,7 @@
    "context": "vim_operator == y",
    "bindings": {
      "y": "vim::CurrentLine",
-      "s": ["vim::PushOperator", { "AddSurrounds": {} }]
+      "s": ["vim::PushAddSurrounds", {}]
    }
  },
  {
@@ -565,34 +573,34 @@
    }
  },
  {
-    "context": "ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
+    "context": "GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
    "bindings": {
      // window related commands (ctrl-w X)
      "ctrl-w": null,
-      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w right": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w up": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w down": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-w ctrl-h": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w ctrl-l": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w ctrl-k": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w ctrl-j": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"],
-      "ctrl-w shift-left": ["workspace::SwapPaneInDirection", "Left"],
-      "ctrl-w shift-right": ["workspace::SwapPaneInDirection", "Right"],
-      "ctrl-w shift-up": ["workspace::SwapPaneInDirection", "Up"],
-      "ctrl-w shift-down": ["workspace::SwapPaneInDirection", "Down"],
-      "ctrl-w shift-h": ["workspace::SwapPaneInDirection", "Left"],
-      "ctrl-w shift-l": ["workspace::SwapPaneInDirection", "Right"],
-      "ctrl-w shift-k": ["workspace::SwapPaneInDirection", "Up"],
-      "ctrl-w shift-j": ["workspace::SwapPaneInDirection", "Down"],
-      "ctrl-w >": ["vim::ResizePane", "Widen"],
-      "ctrl-w <": ["vim::ResizePane", "Narrow"],
-      "ctrl-w -": ["vim::ResizePane", "Shorten"],
-      "ctrl-w +": ["vim::ResizePane", "Lengthen"],
+      "ctrl-w left": "workspace::ActivatePaneLeft",
+      "ctrl-w right": "workspace::ActivatePaneRight",
+      "ctrl-w up": "workspace::ActivatePaneUp",
+      "ctrl-w down": "workspace::ActivatePaneDown",
+      "ctrl-w ctrl-h": "workspace::ActivatePaneLeft",
+      "ctrl-w ctrl-l": "workspace::ActivatePaneRight",
+      "ctrl-w ctrl-k": "workspace::ActivatePaneUp",
+      "ctrl-w ctrl-j": "workspace::ActivatePaneDown",
+      "ctrl-w h": "workspace::ActivatePaneLeft",
+      "ctrl-w l": "workspace::ActivatePaneRight",
+      "ctrl-w k": "workspace::ActivatePaneUp",
+      "ctrl-w j": "workspace::ActivatePaneDown",
+      "ctrl-w shift-left": "workspace::SwapPaneLeft",
+      "ctrl-w shift-right": "workspace::SwapPaneRight",
+      "ctrl-w shift-up": "workspace::SwapPaneUp",
+      "ctrl-w shift-down": "workspace::SwapPaneDown",
+      "ctrl-w shift-h": "workspace::SwapPaneLeft",
+      "ctrl-w shift-l": "workspace::SwapPaneRight",
+      "ctrl-w shift-k": "workspace::SwapPaneUp",
+      "ctrl-w shift-j": "workspace::SwapPaneDown",
+      "ctrl-w >": "vim::ResizePaneRight",
+      "ctrl-w <": "vim::ResizePaneLeft",
+      "ctrl-w -": "vim::ResizePaneDown",
+      "ctrl-w +": "vim::ResizePaneUp",
      "ctrl-w _": "vim::MaximizePane",
      "ctrl-w =": "vim::ResetPaneSizes",
      "ctrl-w g t": "pane::ActivateNextItem",
@@ -610,10 +618,12 @@
      "ctrl-w shift-s": "pane::SplitHorizontal",
      "ctrl-w ctrl-s": "pane::SplitHorizontal",
      "ctrl-w s": "pane::SplitHorizontal",
-      "ctrl-w ctrl-c": "pane::CloseAllItems",
-      "ctrl-w c": "pane::CloseAllItems",
-      "ctrl-w ctrl-q": "pane::CloseAllItems",
-      "ctrl-w q": "pane::CloseAllItems",
+      "ctrl-w ctrl-c": "pane::CloseActiveItem",
+      "ctrl-w c": "pane::CloseActiveItem",
+      "ctrl-w ctrl-q": "pane::CloseActiveItem",
+      "ctrl-w q": "pane::CloseActiveItem",
+      "ctrl-w ctrl-a": "pane::CloseAllItems",
+      "ctrl-w a": "pane::CloseAllItems",
      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal",
@@ -621,7 +631,7 @@
    }
  },
  {
-    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome",
+    "context": "ChangesList || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || Welcome",
    "bindings": {
      ":": "command_palette::Toggle",
      "g /": "pane::DeploySearch"
@@ -684,5 +694,22 @@
      "shift-x": "git::StageAll",
      "shift-u": "git::UnstageAll"
    }
+  },
+  {
+    "context": "Editor && edit_prediction && !edit_prediction_requires_modifier",
+    "bindings": {
+      // This is identical to the binding in the base keymap, but the vim bindings above to
+      // "vim::Tab" shadow it, so it needs to be bound again.
+      "tab": "editor::AcceptEditPrediction"
+    }
+  },
+  {
+    "context": "os != macos && Editor && edit_prediction",
+    "bindings": {
+      // alt-l is provided as an alternative to tab/alt-tab. and will be displayed in the UI. This
+      // is because alt-tab may not be available, as it is often used for window switching on Linux
+      // and Windows.
+      "alt-l": "editor::AcceptEditPrediction"
+    }
  }
 ]
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -24,8 +24,8 @@
  "base_keymap": "VSCode",
  // Features that can be globally enabled or disabled
  "features": {
-    // Which inline completion provider to use.
-    "inline_completion_provider": "copilot"
+    // Which edit prediction provider to use.
+    "edit_prediction_provider": "copilot"
  },
  // The name of a font to use for rendering text in the editor
  "buffer_font_family": "Zed Plex Mono",
@@ -93,6 +93,13 @@
    // workspace when the centered layout is used.
    "right_padding": 0.2
  },
+  // All settings related to the image viewer.
+  "image_viewer": {
+    // The unit for image file sizes.
+    // By default we're setting it to binary.
+    // The second option is decimal.
+    "unit": "binary"
+  },
  // The key to use for adding multiple cursors
  // Currently "alt" or "cmd_or_ctrl"  (also aliased as
  // "cmd" and "ctrl") are supported.
@@ -161,9 +168,6 @@
  /// Whether to show the signature help after completion or a bracket pair inserted.
  /// If `auto_signature_help` is enabled, this setting will be treated as enabled also.
  "show_signature_help_after_edits": false,
-  /// Whether to show the inline completions next to the completions provided by a language server.
-  /// Only has an effect if inline completion provider supports it.
-  "show_inline_completions_in_menu": true,
  // Whether to show wrap guides (vertical rulers) in the editor.
  // Setting this to true will show a guide at the 'preferred_line_length' value
  // if 'soft_wrap' is set to 'preferred_line_length', and will show any
@@ -196,12 +200,12 @@
  // Otherwise(when `true`), the closing characters are always skipped over and auto-removed
  // no matter how they were inserted.
  "always_treat_brackets_as_autoclosed": false,
-  // Controls whether inline completions are shown immediately (true)
-  // or manually by triggering `editor::ShowInlineCompletion` (false).
-  "show_inline_completions": true,
-  // Controls whether inline completions are shown in a given language scope.
+  // Controls whether edit predictions are shown immediately (true)
+  // or manually by triggering `editor::ShowEditPrediction` (false).
+  "show_edit_predictions": true,
+  // Controls whether edit predictions are shown in a given language scope.
  // Example: ["string", "comment"]
-  "inline_completions_disabled_in": [],
+  "edit_predictions_disabled_in": [],
  // Whether to show tabs and spaces in the editor.
  // This setting can take four values:
  //
@@ -648,15 +652,15 @@
    // There are 5 possible width values:
    //
    // 1. Small: This value is essentially a fixed width.
-    //    "modal_width": "small"
+    //    "modal_max_width": "small"
    // 2. Medium:
-    //    "modal_width": "medium"
+    //    "modal_max_width": "medium"
    // 3. Large:
-    //    "modal_width": "large"
+    //    "modal_max_width": "large"
    // 4. Extra Large:
-    //    "modal_width": "xlarge"
+    //    "modal_max_width": "xlarge"
    // 5. Fullscreen: This value removes any horizontal padding, as it consumes the whole viewport width.
-    //    "modal_width": "full"
+    //    "modal_max_width": "full"
    //
    // Default: small
    "modal_max_width": "small"
@@ -774,9 +778,25 @@
  // 2. Load direnv configuration through the shell hook, works for POSIX shells and fish.
  //      "load_direnv": "shell_hook"
  "load_direnv": "direct",
-  "inline_completions": {
-    // A list of globs representing files that inline completions should be disabled for.
-    "disabled_globs": [".env"]
+  "edit_predictions": {
+    // A list of globs representing files that edit predictions should be disabled for.
+    // There's a sensible default list of globs already included.
+    // Any addition to this list will be merged with the default list.
+    "disabled_globs": [
+      "**/.env*",
+      "**/*.pem",
+      "**/*.key",
+      "**/*.cert",
+      "**/*.crt",
+      "**/secrets.yml"
+    ],
+    // When to show edit predictions previews in buffer.
+    // This setting takes two possible values:
+    // 1. Display inline when there are no language server completions available.
+    //     "mode": "eager_preview"
+    // 2. Display inline when holding modifier key (alt by default).
+    //     "mode": "auto"
+    "mode": "eager_preview"
  },
  // Settings specific to journaling
  "journal": {
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -81,7 +81,7 @@
        "terminal.ansi.bright_green": "#4d6140ff",
        "terminal.ansi.dim_green": "#d1e0bfff",
        "terminal.ansi.yellow": "#dec184ff",
-        "terminal.ansi.bright_yellow": "#786441ff",
+        "terminal.ansi.bright_yellow": "#e5c07bff",
        "terminal.ansi.dim_yellow": "#f1dfc1ff",
        "terminal.ansi.blue": "#74ade8ff",
        "terminal.ansi.bright_blue": "#385378ff",
@@ -457,7 +457,7 @@
        "terminal.ansi.bright_green": "#b2cfa9ff",
        "terminal.ansi.dim_green": "#354d2eff",
        "terminal.ansi.yellow": "#dec184ff",
-        "terminal.ansi.bright_yellow": "#f1dfc1ff",
+        "terminal.ansi.bright_yellow": "#826221ff",
        "terminal.ansi.dim_yellow": "#786441ff",
        "terminal.ansi.blue": "#5c78e2ff",
        "terminal.ansi.bright_blue": "#b5baf2ff",
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -250,7 +250,7 @@ pub async fn stream_completion(
        .map(|output| output.0)
 }

-/// https://docs.anthropic.com/en/api/rate-limits#response-headers
+/// <https://docs.anthropic.com/en/api/rate-limits#response-headers>
 #[derive(Debug)]
 pub struct RateLimitInfo {
    pub requests_limit: usize,
@@ -626,7 +626,7 @@ pub struct ApiError {
 }

 /// An Anthropic API error code.
-/// https://docs.anthropic.com/en/api/errors#http-errors
+/// <https://docs.anthropic.com/en/api/errors#http-errors>
 #[derive(Debug, PartialEq, Eq, Clone, Copy, EnumString)]
 #[strum(serialize_all = "snake_case")]
 pub enum ApiErrorCode {
--- a/crates/anthropic/src/supported_countries.rs
+++ b/crates/anthropic/src/supported_countries.rs
@@ -3,7 +3,7 @@ use std::sync::LazyLock;

 /// Returns whether the given country code is supported by Anthropic.
 ///
-/// https://www.anthropic.com/supported-countries
+/// <https://www.anthropic.com/supported-countries>
 pub fn is_supported_country(country_code: &str) -> bool {
    SUPPORTED_COUNTRIES.contains(&country_code)
 }
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -250,10 +250,10 @@ impl AssistantPanel {
                    )
                    .child(
                        PopoverMenu::new("assistant-panel-popover-menu")
-                            .trigger(
+                            .trigger_with_tooltip(
                                IconButton::new("menu", IconName::EllipsisVertical)
-                                    .icon_size(IconSize::Small)
-                                    .tooltip(Tooltip::text("Toggle Assistant Menu")),
+                                    .icon_size(IconSize::Small),
+                                Tooltip::text("Toggle Assistant Menu"),
                            )
                            .menu(move |window, cx| {
                                let zoom_label = if _pane.read(cx).is_zoomed() {
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1255,7 +1255,7 @@ impl InlineAssistant {
                    editor.scroll_manager.set_forbid_vertical_scroll(true);
                    editor.set_show_scrollbars(false, cx);
                    editor.set_read_only(true);
-                    editor.set_show_inline_completions(Some(false), window, cx);
+                    editor.set_show_edit_predictions(Some(false), window, cx);
                    editor.highlight_rows::<DeletedLines>(
                        Anchor::min()..Anchor::max(),
                        cx.theme().status().deleted_background,
@@ -1595,22 +1595,22 @@ impl Render for PromptEditor {
                        IconButton::new("context", IconName::SettingsAlt)
                            .shape(IconButtonShape::Square)
                            .icon_size(IconSize::Small)
-                            .icon_color(Color::Muted)
-                            .tooltip(move |window, cx| {
-                                Tooltip::with_meta(
-                                    format!(
-                                        "Using {}",
-                                        LanguageModelRegistry::read_global(cx)
-                                            .active_model()
-                                            .map(|model| model.name().0)
-                                            .unwrap_or_else(|| "No model selected".into()),
-                                    ),
-                                    None,
-                                    "Change Model",
-                                    window,
-                                    cx,
-                                )
-                            }),
+                            .icon_color(Color::Muted),
+                        move |window, cx| {
+                            Tooltip::with_meta(
+                                format!(
+                                    "Using {}",
+                                    LanguageModelRegistry::read_global(cx)
+                                        .active_model()
+                                        .map(|model| model.name().0)
+                                        .unwrap_or_else(|| "No model selected".into()),
+                                ),
+                                None,
+                                "Change Model",
+                                window,
+                                cx,
+                            )
+                        },
                    ))
                    .map(|el| {
                        let CodegenStatus::Error(error) = self.codegen.read(cx).status(cx) else {
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -646,22 +646,22 @@ impl Render for PromptEditor {
                        IconButton::new("context", IconName::SettingsAlt)
                            .shape(IconButtonShape::Square)
                            .icon_size(IconSize::Small)
-                            .icon_color(Color::Muted)
-                            .tooltip(move |window, cx| {
-                                Tooltip::with_meta(
-                                    format!(
-                                        "Using {}",
-                                        LanguageModelRegistry::read_global(cx)
-                                            .active_model()
-                                            .map(|model| model.name().0)
-                                            .unwrap_or_else(|| "No model selected".into()),
-                                    ),
-                                    None,
-                                    "Change Model",
-                                    window,
-                                    cx,
-                                )
-                            }),
+                            .icon_color(Color::Muted),
+                        move |window, cx| {
+                            Tooltip::with_meta(
+                                format!(
+                                    "Using {}",
+                                    LanguageModelRegistry::read_global(cx)
+                                        .active_model()
+                                        .map(|model| model.name().0)
+                                        .unwrap_or_else(|| "No model selected".into()),
+                                ),
+                                None,
+                                "Change Model",
+                                window,
+                                cx,
+                            )
+                        },
                    ))
                    .children(
                        if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {
--- a/crates/assistant2/src/assistant_model_selector.rs
+++ b/crates/assistant2/src/assistant_model_selector.rs
@@ -74,16 +74,16 @@ impl Render for AssistantModelSelector {
                                .color(Color::Muted)
                                .size(IconSize::XSmall),
                        ),
+                ),
+            move |window, cx| {
+                Tooltip::for_action_in(
+                    "Change Model",
+                    &ToggleModelSelector,
+                    &focus_handle,
+                    window,
+                    cx,
                )
-                .tooltip(move |window, cx| {
-                    Tooltip::for_action_in(
-                        "Change Model",
-                        &ToggleModelSelector,
-                        &focus_handle,
-                        window,
-                        cx,
-                    )
-                }),
+            },
        )
        .with_handle(self.menu_handle.clone())
    }
--- a/crates/assistant2/src/assistant_panel.rs
+++ b/crates/assistant2/src/assistant_panel.rs
@@ -442,7 +442,7 @@ impl AssistantPanel {

    fn handle_assistant_configuration_event(
        &mut self,
-        _model: &Entity<AssistantConfiguration>,
+        _entity: &Entity<AssistantConfiguration>,
        event: &AssistantConfigurationEvent,
        window: &mut Window,
        cx: &mut Context<Self>,
@@ -660,11 +660,11 @@ impl AssistantPanel {
                    .gap(DynamicSpacing::Base02.rems(cx))
                    .child(
                        PopoverMenu::new("assistant-toolbar-new-popover-menu")
-                            .trigger(
+                            .trigger_with_tooltip(
                                IconButton::new("new", IconName::Plus)
                                    .icon_size(IconSize::Small)
-                                    .style(ButtonStyle::Subtle)
-                                    .tooltip(Tooltip::text("New…")),
+                                    .style(ButtonStyle::Subtle),
+                                Tooltip::text("New…"),
                            )
                            .anchor(Corner::TopRight)
                            .with_handle(self.new_item_context_menu_handle.clone())
@@ -677,11 +677,11 @@ impl AssistantPanel {
                    )
                    .child(
                        PopoverMenu::new("assistant-toolbar-history-popover-menu")
-                            .trigger(
+                            .trigger_with_tooltip(
                                IconButton::new("open-history", IconName::HistoryRerun)
                                    .icon_size(IconSize::Small)
-                                    .style(ButtonStyle::Subtle)
-                                    .tooltip(Tooltip::text("History…")),
+                                    .style(ButtonStyle::Subtle),
+                                Tooltip::text("History…"),
                            )
                            .anchor(Corner::TopRight)
                            .with_handle(self.open_history_context_menu_handle.clone())
--- a/crates/assistant2/src/context_store.rs
+++ b/crates/assistant2/src/context_store.rs
@@ -79,8 +79,8 @@ impl ContextStore {
                project.open_buffer(project_path.clone(), cx)
            })?;

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

            let already_included = this.update(&mut cx, |this, _cx| {
                match this.will_include_buffer(buffer_id, &project_path.path) {
@@ -98,10 +98,10 @@ impl ContextStore {
            }

            let (buffer_info, text_task) = this.update(&mut cx, |_, cx| {
-                let buffer = buffer_model.read(cx);
+                let buffer = buffer_entity.read(cx);
                collect_buffer_info_and_text(
                    project_path.path.clone(),
-                    buffer_model,
+                    buffer_entity,
                    buffer,
                    cx.to_async(),
                )
@@ -119,18 +119,18 @@ impl ContextStore {

    pub fn add_file_from_buffer(
        &mut self,
-        buffer_model: Entity<Buffer>,
+        buffer_entity: Entity<Buffer>,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
        cx.spawn(|this, mut cx| async move {
            let (buffer_info, text_task) = this.update(&mut cx, |_, cx| {
-                let buffer = buffer_model.read(cx);
+                let buffer = buffer_entity.read(cx);
                let Some(file) = buffer.file() else {
                    return Err(anyhow!("Buffer has no path."));
                };
                Ok(collect_buffer_info_and_text(
                    file.path().clone(),
-                    buffer_model,
+                    buffer_entity,
                    buffer,
                    cx.to_async(),
                ))
@@ -207,11 +207,11 @@ impl ContextStore {
            let mut buffer_infos = Vec::new();
            let mut text_tasks = Vec::new();
            this.update(&mut cx, |_, cx| {
-                for (path, buffer_model) in files.into_iter().zip(buffers) {
-                    let buffer_model = buffer_model?;
-                    let buffer = buffer_model.read(cx);
+                for (path, buffer_entity) in files.into_iter().zip(buffers) {
+                    let buffer_entity = buffer_entity?;
+                    let buffer = buffer_entity.read(cx);
                    let (buffer_info, text_task) =
-                        collect_buffer_info_and_text(path, buffer_model, buffer, cx.to_async());
+                        collect_buffer_info_and_text(path, buffer_entity, buffer, cx.to_async());
                    buffer_infos.push(buffer_info);
                    text_tasks.push(text_task);
                }
@@ -429,7 +429,7 @@ pub enum FileInclusion {

 // ContextBuffer without text.
 struct BufferInfo {
-    buffer_model: Entity<Buffer>,
+    buffer_entity: Entity<Buffer>,
    id: BufferId,
    version: clock::Global,
 }
@@ -437,7 +437,7 @@ struct BufferInfo {
 fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {
    ContextBuffer {
        id: info.id,
-        buffer: info.buffer_model,
+        buffer: info.buffer_entity,
        version: info.version,
        text,
    }
@@ -445,13 +445,13 @@ fn make_context_buffer(info: BufferInfo, text: SharedString) -> ContextBuffer {

 fn collect_buffer_info_and_text(
    path: Arc<Path>,
-    buffer_model: Entity<Buffer>,
+    buffer_entity: Entity<Buffer>,
    buffer: &Buffer,
    cx: AsyncApp,
 ) -> (BufferInfo, Task<SharedString>) {
    let buffer_info = BufferInfo {
        id: buffer.remote_id(),
-        buffer_model,
+        buffer_entity,
        version: buffer.version(),
    };
    // Important to collect version at the same time as content so that staleness logic is correct.
--- a/crates/assistant2/src/context_strip.rs
+++ b/crates/assistant2/src/context_strip.rs
@@ -92,8 +92,8 @@ impl ContextStrip {
        let active_item = workspace.read(cx).active_item(cx)?;

        let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
-        let active_buffer_model = editor.buffer().read(cx).as_singleton()?;
-        let active_buffer = active_buffer_model.read(cx);
+        let active_buffer_entity = editor.buffer().read(cx).as_singleton()?;
+        let active_buffer = active_buffer_entity.read(cx);

        let path = active_buffer.file()?.path();

@@ -115,7 +115,7 @@ impl ContextStrip {

        Some(SuggestedContext::File {
            name,
-            buffer: active_buffer_model.downgrade(),
+            buffer: active_buffer_entity.downgrade(),
            icon_path,
        })
    }
@@ -393,9 +393,9 @@ impl Render for ContextStrip {
            .on_action(cx.listener(Self::remove_focused_context))
            .on_action(cx.listener(Self::accept_suggested_context))
            .on_children_prepainted({
-                let model = cx.entity().downgrade();
+                let entity = cx.entity().downgrade();
                move |children_bounds, _window, cx| {
-                    model
+                    entity
                        .update(cx, |this, _| {
                            this.children_bounds = Some(children_bounds);
                        })
@@ -411,22 +411,22 @@ impl Render for ContextStrip {

                        Some(context_picker.clone())
                    })
-                    .trigger(
+                    .trigger_with_tooltip(
                        IconButton::new("add-context", IconName::Plus)
                            .icon_size(IconSize::Small)
-                            .style(ui::ButtonStyle::Filled)
-                            .tooltip({
-                                let focus_handle = focus_handle.clone();
-                                move |window, cx| {
-                                    Tooltip::for_action_in(
-                                        "Add Context",
-                                        &ToggleContextPicker,
-                                        &focus_handle,
-                                        window,
-                                        cx,
-                                    )
-                                }
-                            }),
+                            .style(ui::ButtonStyle::Filled),
+                        {
+                            let focus_handle = focus_handle.clone();
+                            move |window, cx| {
+                                Tooltip::for_action_in(
+                                    "Add Context",
+                                    &ToggleContextPicker,
+                                    &focus_handle,
+                                    window,
+                                    cx,
+                                )
+                            }
+                        },
                    )
                    .attach(gpui::Corner::TopLeft)
                    .anchor(gpui::Corner::BottomLeft)
--- a/crates/assistant2/src/inline_assistant.rs
+++ b/crates/assistant2/src/inline_assistant.rs
@@ -1345,7 +1345,7 @@ impl InlineAssistant {
                    editor.scroll_manager.set_forbid_vertical_scroll(true);
                    editor.set_show_scrollbars(false, cx);
                    editor.set_read_only(true);
-                    editor.set_show_inline_completions(Some(false), window, cx);
+                    editor.set_show_edit_predictions(Some(false), window, cx);
                    editor.highlight_rows::<DeletedLines>(
                        Anchor::min()..Anchor::max(),
                        cx.theme().status().deleted_background,
--- a/crates/assistant2/src/message_editor.rs
+++ b/crates/assistant2/src/message_editor.rs
@@ -12,6 +12,7 @@ use language_model_selector::LanguageModelSelector;
 use rope::Point;
 use settings::Settings;
 use std::time::Duration;
+use text::Bias;
 use theme::ThemeSettings;
 use ui::{
    prelude::*, ButtonLike, KeyBinding, PopoverMenu, PopoverMenuHandle, Switch, TintColor, Tooltip,
@@ -239,7 +240,10 @@ impl MessageEditor {
                    let snapshot = editor.buffer().read(cx).snapshot(cx);
                    let newest_cursor = editor.selections.newest::<Point>(cx).head();
                    if newest_cursor.column > 0 {
-                        let behind_cursor = Point::new(newest_cursor.row, newest_cursor.column - 1);
+                        let behind_cursor = snapshot.clip_point(
+                            Point::new(newest_cursor.row, newest_cursor.column - 1),
+                            Bias::Left,
+                        );
                        let char_behind_cursor = snapshot.chars_at(behind_cursor).next();
                        if char_behind_cursor == Some('@') {
                            self.inline_context_picker_menu_handle.show(window, cx);
--- a/crates/assistant_context_editor/src/context_editor.rs
+++ b/crates/assistant_context_editor/src/context_editor.rs
@@ -459,7 +459,7 @@ impl ContextEditor {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        if self.editor.read(cx).has_active_completions_menu() {
+        if self.editor.read(cx).has_visible_completions_menu() {
            return;
        }

@@ -832,12 +832,13 @@ impl ContextEditor {
                let render_block: RenderBlock = Arc::new({
                    let this = this.clone();
                    let patch_range = range.clone();
-                    move |cx: &mut BlockContext<'_, '_>| {
+                    move |cx: &mut BlockContext| {
                        let max_width = cx.max_width;
                        let gutter_width = cx.gutter_dimensions.full_width();
                        let block_id = cx.block_id;
                        let selected = cx.selected;
-                        this.update_in(cx, |this, window, cx| {
+                        let window = &mut cx.window;
+                        this.update(cx.app, |this, cx| {
                            this.render_patch_block(
                                patch_range.clone(),
                                max_width,
@@ -2358,8 +2359,8 @@ impl ContextEditor {
                .icon(IconName::Plus)
                .icon_size(IconSize::Small)
                .icon_color(Color::Muted)
-                .icon_position(IconPosition::Start)
-                .tooltip(Tooltip::text("Type / to insert via keyboard")),
+                .icon_position(IconPosition::Start),
+            Tooltip::text("Type / to insert via keyboard"),
        )
    }

@@ -3322,10 +3323,10 @@ impl Render for ContextEditorToolbarItem {
                                        .color(Color::Muted)
                                        .size(IconSize::XSmall),
                                ),
-                        )
-                        .tooltip(move |window, cx| {
-                            Tooltip::for_action("Change Model", &ToggleModelSelector, window, cx)
-                        }),
+                        ),
+                    move |window, cx| {
+                        Tooltip::for_action("Change Model", &ToggleModelSelector, window, cx)
+                    },
                )
                .with_handle(self.language_model_selector_menu_handle.clone()),
            )
--- a/crates/assistant_context_editor/src/context_store.rs
+++ b/crates/assistant_context_editor/src/context_store.rs
@@ -31,11 +31,11 @@ use std::{
 use util::{ResultExt, TryFutureExt};

 pub(crate) fn init(client: &AnyProtoClient) {
-    client.add_model_message_handler(ContextStore::handle_advertise_contexts);
-    client.add_model_request_handler(ContextStore::handle_open_context);
-    client.add_model_request_handler(ContextStore::handle_create_context);
-    client.add_model_message_handler(ContextStore::handle_update_context);
-    client.add_model_request_handler(ContextStore::handle_synchronize_contexts);
+    client.add_entity_message_handler(ContextStore::handle_advertise_contexts);
+    client.add_entity_request_handler(ContextStore::handle_open_context);
+    client.add_entity_request_handler(ContextStore::handle_create_context);
+    client.add_entity_message_handler(ContextStore::handle_update_context);
+    client.add_entity_request_handler(ContextStore::handle_synchronize_contexts);
 }

 #[derive(Clone)]
@@ -144,11 +144,9 @@ impl ContextStore {
                this.handle_project_changed(project.clone(), cx);
                this.synchronize_contexts(cx);
                this.register_context_server_handlers(cx);
+                this.reload(cx).detach_and_log_err(cx);
                this
            })?;
-            this.update(&mut cx, |this, cx| this.reload(cx))?
-                .await
-                .log_err();

            Ok(this)
        })
@@ -312,7 +310,7 @@ impl ContextStore {
                .client
                .subscribe_to_entity(remote_id)
                .log_err()
-                .map(|subscription| subscription.set_model(&cx.entity(), &mut cx.to_async()));
+                .map(|subscription| subscription.set_entity(&cx.entity(), &mut cx.to_async()));
            self.advertise_contexts(cx);
        } else {
            self.client_subscription = None;
--- a/crates/assistant_context_editor/src/slash_command.rs
+++ b/crates/assistant_context_editor/src/slash_command.rs
@@ -5,7 +5,7 @@ use assistant_slash_command::{AfterCompletion, SlashCommandLine, SlashCommandWor
 use editor::{CompletionProvider, Editor};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{App, Context, Entity, Task, WeakEntity, Window};
-use language::{Anchor, Buffer, Documentation, LanguageServerId, ToPoint};
+use language::{Anchor, Buffer, CompletionDocumentation, LanguageServerId, ToPoint};
 use parking_lot::Mutex;
 use project::CompletionIntent;
 use rope::Point;
@@ -120,7 +120,9 @@ impl SlashCommandCompletionProvider {
                                });
                        Some(project::Completion {
                            old_range: name_range.clone(),
-                            documentation: Some(Documentation::SingleLine(command.description())),
+                            documentation: Some(CompletionDocumentation::SingleLine(
+                                command.description(),
+                            )),
                            new_text,
                            label: command.label(cx),
                            server_id: LanguageServerId(0),
--- a/crates/assistant_context_editor/src/slash_command_picker.rs
+++ b/crates/assistant_context_editor/src/slash_command_picker.rs
@@ -1,17 +1,22 @@
 use std::sync::Arc;

 use assistant_slash_command::SlashCommandWorkingSet;
-use gpui::{AnyElement, DismissEvent, SharedString, Task, WeakEntity};
+use gpui::{AnyElement, AnyView, DismissEvent, SharedString, Task, WeakEntity};
 use picker::{Picker, PickerDelegate, PickerEditorPosition};
 use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger, Tooltip};

 use crate::context_editor::ContextEditor;

 #[derive(IntoElement)]
-pub(super) struct SlashCommandSelector<T: PopoverTrigger> {
+pub(super) struct SlashCommandSelector<T, TT>
+where
+    T: PopoverTrigger + ButtonCommon,
+    TT: Fn(&mut Window, &mut App) -> AnyView + 'static,
+{
    working_set: Arc<SlashCommandWorkingSet>,
    active_context_editor: WeakEntity<ContextEditor>,
    trigger: T,
+    tooltip: TT,
 }

 #[derive(Clone)]
@@ -48,16 +53,22 @@ pub(crate) struct SlashCommandDelegate {
    selected_index: usize,
 }

-impl<T: PopoverTrigger> SlashCommandSelector<T> {
+impl<T, TT> SlashCommandSelector<T, TT>
+where
+    T: PopoverTrigger + ButtonCommon,
+    TT: Fn(&mut Window, &mut App) -> AnyView + 'static,
+{
    pub(crate) fn new(
        working_set: Arc<SlashCommandWorkingSet>,
        active_context_editor: WeakEntity<ContextEditor>,
        trigger: T,
+        tooltip: TT,
    ) -> Self {
        SlashCommandSelector {
            working_set,
            active_context_editor,
            trigger,
+            tooltip,
        }
    }
 }
@@ -241,7 +252,11 @@ impl PickerDelegate for SlashCommandDelegate {
    }
 }

-impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
+impl<T, TT> RenderOnce for SlashCommandSelector<T, TT>
+where
+    T: PopoverTrigger + ButtonCommon,
+    TT: Fn(&mut Window, &mut App) -> AnyView + 'static,
+{
    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
        let all_models = self
            .working_set
@@ -322,7 +337,7 @@ impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
            .ok();
        PopoverMenu::new("model-switcher")
            .menu(move |_window, _cx| Some(picker_view.clone()))
-            .trigger(self.trigger)
+            .trigger_with_tooltip(self.trigger, self.tooltip)
            .attach(gpui::Corner::TopLeft)
            .anchor(gpui::Corner::BottomLeft)
            .offset(gpui::Point {
--- a/crates/assistant_settings/src/assistant_settings.rs
+++ b/crates/assistant_settings/src/assistant_settings.rs
@@ -434,7 +434,7 @@ pub struct LegacyAssistantSettingsContent {
    pub default_open_ai_model: Option<OpenAiModel>,
    /// OpenAI API base URL to use when creating new chats.
    ///
-    /// Default: https://api.openai.com/v1
+    /// Default: <https://api.openai.com/v1>
    pub openai_api_url: Option<String>,
 }

--- a/crates/assistant_slash_commands/src/file_command.rs
+++ b/crates/assistant_slash_commands/src/file_command.rs
@@ -323,7 +323,14 @@ fn collect_files(
                        )))?;
                        directory_stack.push(entry.path.clone());
                    } else {
-                        let entry_name = format!("{}/{}", prefix_paths, &filename);
+                        // todo(windows)
+                        // Potential bug: this assumes that the path separator is always `\` on Windows
+                        let entry_name = format!(
+                            "{}{}{}",
+                            prefix_paths,
+                            std::path::MAIN_SEPARATOR_STR,
+                            &filename
+                        );
                        events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
                            icon: IconName::Folder,
                            label: entry_name.clone().into(),
@@ -455,6 +462,7 @@ mod custom_path_matcher {
    use std::{fmt::Debug as _, path::Path};

    use globset::{Glob, GlobSet, GlobSetBuilder};
+    use util::paths::SanitizedPath;

    #[derive(Clone, Debug, Default)]
    pub struct PathMatcher {
@@ -481,7 +489,7 @@ mod custom_path_matcher {
        pub fn new(globs: &[String]) -> Result<Self, globset::Error> {
            let globs = globs
                .into_iter()
-                .map(|glob| Glob::new(&glob))
+                .map(|glob| Glob::new(&SanitizedPath::from(glob).to_glob_string()))
                .collect::<Result<Vec<_>, _>>()?;
            let sources = globs.iter().map(|glob| glob.glob().to_owned()).collect();
            let sources_with_trailing_slash = globs
@@ -507,7 +515,9 @@ mod custom_path_matcher {
                .zip(self.sources_with_trailing_slash.iter())
                .any(|(source, with_slash)| {
                    let as_bytes = other_path.as_os_str().as_encoded_bytes();
-                    let with_slash = if source.ends_with("/") {
+                    // todo(windows)
+                    // Potential bug: this assumes that the path separator is always `\` on Windows
+                    let with_slash = if source.ends_with(std::path::MAIN_SEPARATOR_STR) {
                        source.as_bytes()
                    } else {
                        with_slash.as_bytes()
@@ -569,6 +579,7 @@ mod test {
    use serde_json::json;
    use settings::SettingsStore;
    use smol::stream::StreamExt;
+    use util::{path, separator};

    use super::collect_files;

@@ -592,7 +603,7 @@ mod test {
        let fs = FakeFs::new(cx.executor());

        fs.insert_tree(
-            "/root",
+            path!("/root"),
            json!({
                "dir": {
                    "subdir": {
@@ -607,7 +618,7 @@ mod test {
        )
        .await;

-        let project = Project::test(fs, ["/root".as_ref()], cx).await;
+        let project = Project::test(fs, [path!("/root").as_ref()], cx).await;

        let result_1 =
            cx.update(|cx| collect_files(project.clone(), &["root/dir".to_string()], cx));
@@ -615,7 +626,7 @@ mod test {
            .await
            .unwrap();

-        assert!(result_1.text.starts_with("root/dir"));
+        assert!(result_1.text.starts_with(separator!("root/dir")));
        // 4 files + 2 directories
        assert_eq!(result_1.sections.len(), 6);

@@ -631,7 +642,7 @@ mod test {
            cx.update(|cx| collect_files(project.clone(), &["root/dir*".to_string()], cx).boxed());
        let result = SlashCommandOutput::from_event_stream(result).await.unwrap();

-        assert!(result.text.starts_with("root/dir"));
+        assert!(result.text.starts_with(separator!("root/dir")));
        // 5 files + 2 directories
        assert_eq!(result.sections.len(), 7);

@@ -645,7 +656,7 @@ mod test {
        let fs = FakeFs::new(cx.executor());

        fs.insert_tree(
-            "/zed",
+            path!("/zed"),
            json!({
                "assets": {
                    "dir1": {
@@ -670,7 +681,7 @@ mod test {
        )
        .await;

-        let project = Project::test(fs, ["/zed".as_ref()], cx).await;
+        let project = Project::test(fs, [path!("/zed").as_ref()], cx).await;

        let result =
            cx.update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx));
@@ -679,27 +690,36 @@ mod test {
            .unwrap();

        // Sanity check
-        assert!(result.text.starts_with("zed/assets/themes\n"));
+        assert!(result.text.starts_with(separator!("zed/assets/themes\n")));
        assert_eq!(result.sections.len(), 7);

        // Ensure that full file paths are included in the real output
-        assert!(result.text.contains("zed/assets/themes/andromeda/LICENSE"));
-        assert!(result.text.contains("zed/assets/themes/ayu/LICENSE"));
-        assert!(result.text.contains("zed/assets/themes/summercamp/LICENSE"));
+        assert!(result
+            .text
+            .contains(separator!("zed/assets/themes/andromeda/LICENSE")));
+        assert!(result
+            .text
+            .contains(separator!("zed/assets/themes/ayu/LICENSE")));
+        assert!(result
+            .text
+            .contains(separator!("zed/assets/themes/summercamp/LICENSE")));

        assert_eq!(result.sections[5].label, "summercamp");

        // Ensure that things are in descending order, with properly relativized paths
        assert_eq!(
            result.sections[0].label,
-            "zed/assets/themes/andromeda/LICENSE"
+            separator!("zed/assets/themes/andromeda/LICENSE")
        );
        assert_eq!(result.sections[1].label, "andromeda");
-        assert_eq!(result.sections[2].label, "zed/assets/themes/ayu/LICENSE");
+        assert_eq!(
+            result.sections[2].label,
+            separator!("zed/assets/themes/ayu/LICENSE")
+        );
        assert_eq!(result.sections[3].label, "ayu");
        assert_eq!(
            result.sections[4].label,
-            "zed/assets/themes/summercamp/LICENSE"
+            separator!("zed/assets/themes/summercamp/LICENSE")
        );

        // Ensure that the project lasts until after the last await
@@ -712,7 +732,7 @@ mod test {
        let fs = FakeFs::new(cx.executor());

        fs.insert_tree(
-            "/zed",
+            path!("/zed"),
            json!({
                "assets": {
                    "themes": {
@@ -732,7 +752,7 @@ mod test {
        )
        .await;

-        let project = Project::test(fs, ["/zed".as_ref()], cx).await;
+        let project = Project::test(fs, [path!("/zed").as_ref()], cx).await;

        let result =
            cx.update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx));
@@ -740,26 +760,29 @@ mod test {
            .await
            .unwrap();

-        assert!(result.text.starts_with("zed/assets/themes\n"));
-        assert_eq!(result.sections[0].label, "zed/assets/themes/LICENSE");
+        assert!(result.text.starts_with(separator!("zed/assets/themes\n")));
+        assert_eq!(
+            result.sections[0].label,
+            separator!("zed/assets/themes/LICENSE")
+        );
        assert_eq!(
            result.sections[1].label,
-            "zed/assets/themes/summercamp/LICENSE"
+            separator!("zed/assets/themes/summercamp/LICENSE")
        );
        assert_eq!(
            result.sections[2].label,
-            "zed/assets/themes/summercamp/subdir/LICENSE"
+            separator!("zed/assets/themes/summercamp/subdir/LICENSE")
        );
        assert_eq!(
            result.sections[3].label,
-            "zed/assets/themes/summercamp/subdir/subsubdir/LICENSE"
+            separator!("zed/assets/themes/summercamp/subdir/subsubdir/LICENSE")
        );
        assert_eq!(result.sections[4].label, "subsubdir");
        assert_eq!(result.sections[5].label, "subdir");
        assert_eq!(result.sections[6].label, "summercamp");
-        assert_eq!(result.sections[7].label, "zed/assets/themes");
+        assert_eq!(result.sections[7].label, separator!("zed/assets/themes"));

-        assert_eq!(result.text, "zed/assets/themes\n```zed/assets/themes/LICENSE\n1\n```\n\nsummercamp\n```zed/assets/themes/summercamp/LICENSE\n1\n```\n\nsubdir\n```zed/assets/themes/summercamp/subdir/LICENSE\n1\n```\n\nsubsubdir\n```zed/assets/themes/summercamp/subdir/subsubdir/LICENSE\n3\n```\n\n");
+        assert_eq!(result.text, separator!("zed/assets/themes\n```zed/assets/themes/LICENSE\n1\n```\n\nsummercamp\n```zed/assets/themes/summercamp/LICENSE\n1\n```\n\nsubdir\n```zed/assets/themes/summercamp/subdir/LICENSE\n1\n```\n\nsubsubdir\n```zed/assets/themes/summercamp/subdir/subsubdir/LICENSE\n3\n```\n\n"));

        // Ensure that the project lasts until after the last await
        drop(project);
--- a/crates/auto_update_ui/src/auto_update_ui.rs
+++ b/crates/auto_update_ui/src/auto_update_ui.rs
@@ -9,7 +9,7 @@ use release_channel::{AppVersion, ReleaseChannel};
 use serde::Deserialize;
 use smol::io::AsyncReadExt;
 use util::ResultExt as _;
-use workspace::notifications::NotificationId;
+use workspace::notifications::{show_app_notification, NotificationId};
 use workspace::Workspace;

 use crate::update_notification::UpdateNotification;
@@ -17,6 +17,7 @@ use crate::update_notification::UpdateNotification;
 actions!(auto_update, [ViewReleaseNotesLocally]);

 pub fn init(cx: &mut App) {
+    notify_if_app_was_updated(cx);
    cx.observe_new(|workspace: &mut Workspace, _window, _cx| {
        workspace.register_action(|workspace, _: &ViewReleaseNotesLocally, window, cx| {
            view_release_notes_locally(workspace, window, cx);
@@ -124,31 +125,35 @@ fn view_release_notes_locally(
        .detach();
 }

-pub fn notify_of_any_new_update(window: &mut Window, cx: &mut Context<Workspace>) -> Option<()> {
-    let updater = AutoUpdater::get(cx)?;
+/// Shows a notification across all workspaces if an update was previously automatically installed
+/// and this notification had not yet been shown.
+pub fn notify_if_app_was_updated(cx: &mut App) {
+    let Some(updater) = AutoUpdater::get(cx) else {
+        return;
+    };
    let version = updater.read(cx).current_version();
    let should_show_notification = updater.read(cx).should_show_update_notification(cx);

-    cx.spawn_in(window, |workspace, mut cx| async move {
+    cx.spawn(|cx| async move {
        let should_show_notification = should_show_notification.await?;
        if should_show_notification {
-            workspace.update(&mut cx, |workspace, cx| {
-                let workspace_handle = workspace.weak_handle();
-                workspace.show_notification(
+            cx.update(|cx| {
+                show_app_notification(
                    NotificationId::unique::<UpdateNotification>(),
                    cx,
-                    |cx| cx.new(|_| UpdateNotification::new(version, workspace_handle)),
+                    move |cx| {
+                        let workspace_handle = cx.entity().downgrade();
+                        cx.new(|_| UpdateNotification::new(version, workspace_handle))
+                    },
                );
                updater.update(cx, |updater, cx| {
                    updater
                        .set_should_show_update_notification(false, cx)
                        .detach_and_log_err(cx);
-                });
+                })
            })?;
        }
        anyhow::Ok(())
    })
    .detach();
-
-    None
 }
--- a/crates/buffer_diff/Cargo.toml
+++ b/crates/buffer_diff/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "buffer_diff"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/buffer_diff.rs"
+
+[features]
+test-support = []
+
+[dependencies]
+anyhow.workspace = true
+futures.workspace = true
+git2.workspace = true
+gpui.workspace = true
+language.workspace = true
+log.workspace = true
+rope.workspace = true
+sum_tree.workspace = true
+text.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+ctor.workspace = true
+env_logger.workspace = true
+gpui = { workspace = true, features = ["test-support"] }
+pretty_assertions.workspace = true
+rand.workspace = true
+serde_json.workspace = true
+text = { workspace = true, features = ["test-support"] }
+unindent.workspace = true
--- a/crates/buffer_diff/LICENSE-GPL
+++ b/crates/buffer_diff/LICENSE-GPL
--- a/crates/buffer_diff/src/buffer_diff.rs
+++ b/crates/buffer_diff/src/buffer_diff.rs
--- a/crates/call/src/cross_platform/room.rs
+++ b/crates/call/src/cross_platform/room.rs
@@ -532,6 +532,10 @@ impl Room {
        &self.local_participant
    }

+    pub fn local_participant_user(&self, cx: &App) -> Option<Arc<User>> {
+        self.user_store.read(cx).current_user()
+    }
+
    pub fn remote_participants(&self) -> &BTreeMap<u64, RemoteParticipant> {
        &self.remote_participants
    }
--- a/crates/call/src/macos/room.rs
+++ b/crates/call/src/macos/room.rs
@@ -588,6 +588,10 @@ impl Room {
        &self.local_participant
    }

+    pub fn local_participant_user(&self, cx: &App) -> Option<Arc<User>> {
+        self.user_store.read(cx).current_user()
+    }
+
    pub fn remote_participants(&self) -> &BTreeMap<u64, RemoteParticipant> {
        &self.remote_participants
    }
--- a/crates/channel/src/channel_buffer.rs
+++ b/crates/channel/src/channel_buffer.rs
@@ -15,8 +15,8 @@ use util::ResultExt;
 pub const ACKNOWLEDGE_DEBOUNCE_INTERVAL: Duration = Duration::from_millis(250);

 pub(crate) fn init(client: &AnyProtoClient) {
-    client.add_model_message_handler(ChannelBuffer::handle_update_channel_buffer);
-    client.add_model_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators);
+    client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer);
+    client.add_entity_message_handler(ChannelBuffer::handle_update_channel_buffer_collaborators);
 }

 pub struct ChannelBuffer {
@@ -81,7 +81,7 @@ impl ChannelBuffer {
                collaborators: Default::default(),
                acknowledge_task: None,
                channel_id: channel.id,
-                subscription: Some(subscription.set_model(&cx.entity(), &mut cx.to_async())),
+                subscription: Some(subscription.set_entity(&cx.entity(), &mut cx.to_async())),
                user_store,
                channel_store,
            };
--- a/crates/channel/src/channel_chat.rs
+++ b/crates/channel/src/channel_chat.rs
@@ -95,9 +95,9 @@ pub enum ChannelChatEvent {

 impl EventEmitter<ChannelChatEvent> for ChannelChat {}
 pub fn init(client: &AnyProtoClient) {
-    client.add_model_message_handler(ChannelChat::handle_message_sent);
-    client.add_model_message_handler(ChannelChat::handle_message_removed);
-    client.add_model_message_handler(ChannelChat::handle_message_updated);
+    client.add_entity_message_handler(ChannelChat::handle_message_sent);
+    client.add_entity_message_handler(ChannelChat::handle_message_removed);
+    client.add_entity_message_handler(ChannelChat::handle_message_updated);
 }

 impl ChannelChat {
@@ -132,7 +132,7 @@ impl ChannelChat {
                last_acknowledged_id: None,
                rng: StdRng::from_entropy(),
                first_loaded_message_id: None,
-                _subscription: subscription.set_model(&cx.entity(), &mut cx.to_async()),
+                _subscription: subscription.set_entity(&cx.entity(), &mut cx.to_async()),
            }
        })?;
        Self::handle_loaded_messages(
--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -39,8 +39,8 @@ pub struct ChannelStore {
    channel_states: HashMap<ChannelId, ChannelState>,
    outgoing_invites: HashSet<(ChannelId, UserId)>,
    update_channels_tx: mpsc::UnboundedSender<proto::UpdateChannels>,
-    opened_buffers: HashMap<ChannelId, OpenedModelHandle<ChannelBuffer>>,
-    opened_chats: HashMap<ChannelId, OpenedModelHandle<ChannelChat>>,
+    opened_buffers: HashMap<ChannelId, OpenEntityHandle<ChannelBuffer>>,
+    opened_chats: HashMap<ChannelId, OpenEntityHandle<ChannelChat>>,
    client: Arc<Client>,
    did_subscribe: bool,
    user_store: Entity<UserStore>,
@@ -142,7 +142,7 @@ pub enum ChannelEvent {

 impl EventEmitter<ChannelEvent> for ChannelStore {}

-enum OpenedModelHandle<E> {
+enum OpenEntityHandle<E> {
    Open(WeakEntity<E>),
    Loading(Shared<Task<Result<Entity<E>, Arc<anyhow::Error>>>>),
 }
@@ -292,7 +292,7 @@ impl ChannelStore {

    pub fn has_open_channel_buffer(&self, channel_id: ChannelId, _cx: &App) -> bool {
        if let Some(buffer) = self.opened_buffers.get(&channel_id) {
-            if let OpenedModelHandle::Open(buffer) = buffer {
+            if let OpenEntityHandle::Open(buffer) = buffer {
                return buffer.upgrade().is_some();
            }
        }
@@ -453,7 +453,7 @@ impl ChannelStore {
    fn open_channel_resource<T, F, Fut>(
        &mut self,
        channel_id: ChannelId,
-        get_map: fn(&mut Self) -> &mut HashMap<ChannelId, OpenedModelHandle<T>>,
+        get_map: fn(&mut Self) -> &mut HashMap<ChannelId, OpenEntityHandle<T>>,
        load: F,
        cx: &mut Context<Self>,
    ) -> Task<Result<Entity<T>>>
@@ -465,15 +465,15 @@ impl ChannelStore {
        let task = loop {
            match get_map(self).entry(channel_id) {
                hash_map::Entry::Occupied(e) => match e.get() {
-                    OpenedModelHandle::Open(model) => {
-                        if let Some(model) = model.upgrade() {
-                            break Task::ready(Ok(model)).shared();
+                    OpenEntityHandle::Open(entity) => {
+                        if let Some(entity) = entity.upgrade() {
+                            break Task::ready(Ok(entity)).shared();
                        } else {
                            get_map(self).remove(&channel_id);
                            continue;
                        }
                    }
-                    OpenedModelHandle::Loading(task) => {
+                    OpenEntityHandle::Loading(task) => {
                        break task.clone();
                    }
                },
@@ -490,7 +490,7 @@ impl ChannelStore {
                        })
                        .shared();

-                    e.insert(OpenedModelHandle::Loading(task.clone()));
+                    e.insert(OpenEntityHandle::Loading(task.clone()));
                    cx.spawn({
                        let task = task.clone();
                        move |this, mut cx| async move {
@@ -499,7 +499,7 @@ impl ChannelStore {
                                Ok(model) => {
                                    get_map(this).insert(
                                        channel_id,
-                                        OpenedModelHandle::Open(model.downgrade()),
+                                        OpenEntityHandle::Open(model.downgrade()),
                                    );
                                }
                                Err(_) => {
@@ -900,7 +900,7 @@ impl ChannelStore {
        self.disconnect_channel_buffers_task.take();

        for chat in self.opened_chats.values() {
-            if let OpenedModelHandle::Open(chat) = chat {
+            if let OpenEntityHandle::Open(chat) = chat {
                if let Some(chat) = chat.upgrade() {
                    chat.update(cx, |chat, cx| {
                        chat.rejoin(cx);
@@ -911,7 +911,7 @@ impl ChannelStore {

        let mut buffer_versions = Vec::new();
        for buffer in self.opened_buffers.values() {
-            if let OpenedModelHandle::Open(buffer) = buffer {
+            if let OpenEntityHandle::Open(buffer) = buffer {
                if let Some(buffer) = buffer.upgrade() {
                    let channel_buffer = buffer.read(cx);
                    let buffer = channel_buffer.buffer().read(cx);
@@ -937,7 +937,7 @@ impl ChannelStore {

            this.update(&mut cx, |this, cx| {
                this.opened_buffers.retain(|_, buffer| match buffer {
-                    OpenedModelHandle::Open(channel_buffer) => {
+                    OpenEntityHandle::Open(channel_buffer) => {
                        let Some(channel_buffer) = channel_buffer.upgrade() else {
                            return false;
                        };
@@ -998,7 +998,7 @@ impl ChannelStore {
                            false
                        })
                    }
-                    OpenedModelHandle::Loading(_) => true,
+                    OpenEntityHandle::Loading(_) => true,
                });
            })
            .ok();
@@ -1018,7 +1018,7 @@ impl ChannelStore {
                if let Some(this) = this.upgrade() {
                    this.update(&mut cx, |this, cx| {
                        for (_, buffer) in this.opened_buffers.drain() {
-                            if let OpenedModelHandle::Open(buffer) = buffer {
+                            if let OpenEntityHandle::Open(buffer) = buffer {
                                if let Some(buffer) = buffer.upgrade() {
                                    buffer.update(cx, |buffer, cx| buffer.disconnect(cx));
                                }
@@ -1082,7 +1082,7 @@ impl ChannelStore {
                    {
                        continue;
                    }
-                    if let Some(OpenedModelHandle::Open(buffer)) =
+                    if let Some(OpenEntityHandle::Open(buffer)) =
                        self.opened_buffers.remove(&channel_id)
                    {
                        if let Some(buffer) = buffer.upgrade() {
@@ -1098,7 +1098,7 @@ impl ChannelStore {
                let channel_changed = index.insert(channel);

                if channel_changed {
-                    if let Some(OpenedModelHandle::Open(buffer)) = self.opened_buffers.get(&id) {
+                    if let Some(OpenEntityHandle::Open(buffer)) = self.opened_buffers.get(&id) {
                        if let Some(buffer) = buffer.upgrade() {
                            buffer.update(cx, ChannelBuffer::channel_changed);
                        }
--- a/crates/cli/build.rs
+++ b/crates/cli/build.rs
@@ -1,3 +1,5 @@
+use std::process::Command;
+
 fn main() {
    if std::env::var("ZED_UPDATE_EXPLANATION").is_ok() {
        println!(r#"cargo:rustc-cfg=feature="no-bundled-uninstall""#);
@@ -8,4 +10,18 @@ fn main() {
        // Weakly link ScreenCaptureKit to ensure can be used on macOS 10.15+.
        println!("cargo:rustc-link-arg=-Wl,-weak_framework,ScreenCaptureKit");
    }
+
+    // Populate git sha environment variable if git is available
+    println!("cargo:rerun-if-changed=../../.git/logs/HEAD");
+    if let Some(output) = Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+    {
+        let git_sha = String::from_utf8_lossy(&output.stdout);
+        let git_sha = git_sha.trim();
+
+        println!("cargo:rustc-env=ZED_COMMIT_SHA={git_sha}");
+    }
 }
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -33,7 +33,19 @@ trait InstalledApp {
 #[command(
    name = "zed",
    disable_version_flag = true,
-    after_help = "To read from stdin, append '-' (e.g. 'ps axf | zed -')"
+    before_help = "The Zed CLI binary.
+This CLI is a separate binary that invokes Zed.
+
+Examples:
+    `zed`
+          Simply opens Zed
+    `zed --foreground`
+          Runs in foreground (shows all logs)
+    `zed path-to-your-project`
+          Open your project in Zed
+    `zed -n path-to-file `
+          Open file/folder in a new window",
+    after_help = "To read from stdin, append '-', e.g. 'ps axf | zed -'"
 )]
 struct Args {
    /// Wait for all of the given paths to be opened/closed before exiting.
@@ -45,10 +57,9 @@ struct Args {
    /// Create a new workspace
    #[arg(short, long, overrides_with = "add")]
    new: bool,
-    /// A sequence of space-separated paths that you want to open.
+    /// The paths to open in Zed (space-separated).
    ///
-    /// Use `path:line:row` syntax to open a file at a specific location.
-    /// Non-existing paths and directories will ignore `:line:row` suffix.
+    /// Use `path:line:column` syntax to open a file at the given line and column.
    paths_with_position: Vec<String>,
    /// Print Zed's version and the app path.
    #[arg(short, long)]
@@ -328,13 +339,17 @@ mod linux {
    impl InstalledApp for App {
        fn zed_version_string(&self) -> String {
            format!(
-                "Zed {}{} – {}",
+                "Zed {}{}{} – {}",
                if *RELEASE_CHANNEL == "stable" {
                    "".to_string()
                } else {
-                    format!(" {} ", *RELEASE_CHANNEL)
+                    format!("{} ", *RELEASE_CHANNEL)
                },
                option_env!("RELEASE_VERSION").unwrap_or_default(),
+                match option_env!("ZED_COMMIT_SHA") {
+                    Some(commit_sha) => format!(" {commit_sha} "),
+                    None => "".to_string(),
+                },
                self.0.display(),
            )
        }
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -33,8 +33,6 @@ postage.workspace = true
 rand.workspace = true
 release_channel.workspace = true
 rpc = { workspace = true, features = ["gpui"] }
-rustls-native-certs.workspace = true
-rustls.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -379,7 +379,7 @@ pub struct PendingEntitySubscription<T: 'static> {
 }

 impl<T: 'static> PendingEntitySubscription<T> {
-    pub fn set_model(mut self, model: &Entity<T>, cx: &AsyncApp) -> Subscription {
+    pub fn set_entity(mut self, entity: &Entity<T>, cx: &AsyncApp) -> Subscription {
        self.consumed = true;
        let mut handlers = self.client.handler_set.lock();
        let id = (TypeId::of::<T>(), self.remote_id);
@@ -392,7 +392,7 @@ impl<T: 'static> PendingEntitySubscription<T> {
        handlers.entities_by_type_and_remote_id.insert(
            id,
            EntityMessageSubscriber::Entity {
-                handle: model.downgrade().into(),
+                handle: entity.downgrade().into(),
            },
        );
        drop(handlers);
@@ -686,8 +686,8 @@ impl Client {
        H: 'static + Sync + Fn(Entity<E>, TypedEnvelope<M>, AsyncApp) -> F + Send + Sync,
        F: 'static + Future<Output = Result<()>>,
    {
-        self.add_message_handler_impl(entity, move |model, message, _, cx| {
-            handler(model, message, cx)
+        self.add_message_handler_impl(entity, move |entity, message, _, cx| {
+            handler(entity, message, cx)
        })
    }

@@ -709,7 +709,7 @@ impl Client {
        let message_type_id = TypeId::of::<M>();
        let mut state = self.handler_set.lock();
        state
-            .models_by_message_type
+            .entities_by_message_type
            .insert(message_type_id, entity.into());

        let prev_handler = state.message_handlers.insert(
@@ -738,7 +738,7 @@ impl Client {

    pub fn add_request_handler<M, E, H, F>(
        self: &Arc<Self>,
-        model: WeakEntity<E>,
+        entity: WeakEntity<E>,
        handler: H,
    ) -> Subscription
    where
@@ -747,7 +747,7 @@ impl Client {
        H: 'static + Sync + Fn(Entity<E>, TypedEnvelope<M>, AsyncApp) -> F + Send + Sync,
        F: 'static + Future<Output = Result<M::Response>>,
    {
-        self.add_message_handler_impl(model, move |handle, envelope, this, cx| {
+        self.add_message_handler_impl(entity, move |handle, envelope, this, cx| {
            Self::respond_to_request(envelope.receipt(), handler(handle, envelope, cx), this)
        })
    }
@@ -1124,31 +1124,11 @@ impl Client {

            match url_scheme {
                Https => {
-                    let client_config = {
-                        let mut root_store = rustls::RootCertStore::empty();
-
-                        let root_certs = rustls_native_certs::load_native_certs();
-                        for error in root_certs.errors {
-                            log::warn!("error loading native certs: {:?}", error);
-                        }
-                        root_store.add_parsable_certificates(
-                            &root_certs
-                                .certs
-                                .into_iter()
-                                .map(|cert| cert.as_ref().to_owned())
-                                .collect::<Vec<_>>(),
-                        );
-                        rustls::ClientConfig::builder()
-                            .with_safe_defaults()
-                            .with_root_certificates(root_store)
-                            .with_no_client_auth()
-                    };
-
                    let (stream, _) =
                        async_tungstenite::async_tls::client_async_tls_with_connector(
                            request,
                            stream,
-                            Some(client_config.into()),
+                            Some(http_client::tls_config().into()),
                        )
                        .await?;
                    Ok(Connection::new(
@@ -1948,9 +1928,9 @@ mod tests {

        let (done_tx1, done_rx1) = smol::channel::unbounded();
        let (done_tx2, done_rx2) = smol::channel::unbounded();
-        AnyProtoClient::from(client.clone()).add_model_message_handler(
-            move |model: Entity<TestModel>, _: TypedEnvelope<proto::JoinProject>, mut cx| {
-                match model.update(&mut cx, |model, _| model.id).unwrap() {
+        AnyProtoClient::from(client.clone()).add_entity_message_handler(
+            move |entity: Entity<TestEntity>, _: TypedEnvelope<proto::JoinProject>, mut cx| {
+                match entity.update(&mut cx, |entity, _| entity.id).unwrap() {
                    1 => done_tx1.try_send(()).unwrap(),
                    2 => done_tx2.try_send(()).unwrap(),
                    _ => unreachable!(),
@@ -1958,15 +1938,15 @@ mod tests {
                async { Ok(()) }
            },
        );
-        let model1 = cx.new(|_| TestModel {
+        let entity1 = cx.new(|_| TestEntity {
            id: 1,
            subscription: None,
        });
-        let model2 = cx.new(|_| TestModel {
+        let entity2 = cx.new(|_| TestEntity {
            id: 2,
            subscription: None,
        });
-        let model3 = cx.new(|_| TestModel {
+        let entity3 = cx.new(|_| TestEntity {
            id: 3,
            subscription: None,
        });
@@ -1974,17 +1954,17 @@ mod tests {
        let _subscription1 = client
            .subscribe_to_entity(1)
            .unwrap()
-            .set_model(&model1, &mut cx.to_async());
+            .set_entity(&entity1, &mut cx.to_async());
        let _subscription2 = client
            .subscribe_to_entity(2)
            .unwrap()
-            .set_model(&model2, &mut cx.to_async());
+            .set_entity(&entity2, &mut cx.to_async());
        // Ensure dropping a subscription for the same entity type still allows receiving of
        // messages for other entity IDs of the same type.
        let subscription3 = client
            .subscribe_to_entity(3)
            .unwrap()
-            .set_model(&model3, &mut cx.to_async());
+            .set_entity(&entity3, &mut cx.to_async());
        drop(subscription3);

        server.send(proto::JoinProject { project_id: 1 });
@@ -2006,11 +1986,11 @@ mod tests {
        });
        let server = FakeServer::for_client(user_id, &client, cx).await;

-        let model = cx.new(|_| TestModel::default());
+        let entity = cx.new(|_| TestEntity::default());
        let (done_tx1, _done_rx1) = smol::channel::unbounded();
        let (done_tx2, done_rx2) = smol::channel::unbounded();
        let subscription1 = client.add_message_handler(
-            model.downgrade(),
+            entity.downgrade(),
            move |_, _: TypedEnvelope<proto::Ping>, _| {
                done_tx1.try_send(()).unwrap();
                async { Ok(()) }
@@ -2018,7 +1998,7 @@ mod tests {
        );
        drop(subscription1);
        let _subscription2 = client.add_message_handler(
-            model.downgrade(),
+            entity.downgrade(),
            move |_, _: TypedEnvelope<proto::Ping>, _| {
                done_tx2.try_send(()).unwrap();
                async { Ok(()) }
@@ -2041,27 +2021,27 @@ mod tests {
        });
        let server = FakeServer::for_client(user_id, &client, cx).await;

-        let model = cx.new(|_| TestModel::default());
+        let entity = cx.new(|_| TestEntity::default());
        let (done_tx, done_rx) = smol::channel::unbounded();
        let subscription = client.add_message_handler(
-            model.clone().downgrade(),
-            move |model: Entity<TestModel>, _: TypedEnvelope<proto::Ping>, mut cx| {
-                model
-                    .update(&mut cx, |model, _| model.subscription.take())
+            entity.clone().downgrade(),
+            move |entity: Entity<TestEntity>, _: TypedEnvelope<proto::Ping>, mut cx| {
+                entity
+                    .update(&mut cx, |entity, _| entity.subscription.take())
                    .unwrap();
                done_tx.try_send(()).unwrap();
                async { Ok(()) }
            },
        );
-        model.update(cx, |model, _| {
-            model.subscription = Some(subscription);
+        entity.update(cx, |entity, _| {
+            entity.subscription = Some(subscription);
        });
        server.send(proto::Ping {});
        done_rx.recv().await.unwrap();
    }

    #[derive(Default)]
-    struct TestModel {
+    struct TestEntity {
        id: usize,
        subscription: Option<Subscription>,
    }
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -3,7 +3,6 @@ mod event_coalescer;
 use crate::TelemetrySettings;
 use anyhow::Result;
 use clock::SystemClock;
-use collections::{HashMap, HashSet};
 use futures::channel::mpsc;
 use futures::{Future, StreamExt};
 use gpui::{App, BackgroundExecutor, Task};
@@ -12,14 +11,13 @@ use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
 use settings::{Settings, SettingsStore};
 use sha2::{Digest, Sha256};
+use std::collections::{HashMap, HashSet};
 use std::fs::File;
 use std::io::Write;
 use std::sync::LazyLock;
 use std::time::Instant;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
-use telemetry_events::{
-    AppEvent, AssistantEvent, AssistantPhase, EditEvent, Event, EventRequestBody, EventWrapper,
-};
+use telemetry_events::{AssistantEvent, AssistantPhase, Event, EventRequestBody, EventWrapper};
 use util::{ResultExt, TryFutureExt};
 use worktree::{UpdatedEntriesSet, WorktreeId};

@@ -285,7 +283,7 @@ impl Telemetry {
    // TestAppContext ends up calling this function on shutdown and it panics when trying to find the TelemetrySettings
    #[cfg(not(any(test, feature = "test-support")))]
    fn shutdown_telemetry(self: &Arc<Self>) -> impl Future<Output = ()> {
-        self.report_app_event("close".to_string());
+        telemetry::event!("App Closed");
        // TODO: close final edit period and make sure it's sent
        Task::ready(())
    }
@@ -355,30 +353,23 @@ impl Telemetry {
        );
    }

-    pub fn report_app_event(self: &Arc<Self>, operation: String) -> Event {
-        let event = Event::App(AppEvent { operation });
-
-        self.report_event(event.clone());
-
-        event
-    }
-
    pub fn log_edit_event(self: &Arc<Self>, environment: &'static str, is_via_ssh: bool) {
        let mut state = self.state.lock();
        let period_data = state.event_coalescer.log_event(environment);
        drop(state);

        if let Some((start, end, environment)) = period_data {
-            let event = Event::Edit(EditEvent {
-                duration: end
-                    .saturating_duration_since(start)
-                    .min(Duration::from_secs(60 * 60 * 24))
-                    .as_millis() as i64,
-                environment: environment.to_string(),
-                is_via_ssh,
-            });
+            let duration = end
+                .saturating_duration_since(start)
+                .min(Duration::from_secs(60 * 60 * 24))
+                .as_millis() as i64;

-            self.report_event(event);
+            telemetry::event!(
+                "Editor Edited",
+                duration = duration,
+                environment = environment.to_string(),
+                is_via_ssh = is_via_ssh
+            );
        }
    }

@@ -422,9 +413,8 @@ impl Telemetry {
                .collect()
        };

-        // Done on purpose to avoid calling `self.state.lock()` multiple times
        for project_type_name in project_type_names {
-            self.report_app_event(format!("open {} project", project_type_name));
+            telemetry::event!("Project Opened", project_type = project_type_name);
        }
    }

@@ -590,6 +580,7 @@ mod tests {
    use clock::FakeSystemClock;
    use gpui::TestAppContext;
    use http_client::FakeHttpClient;
+    use telemetry_events::FlexibleEvent;

    #[gpui::test]
    fn test_telemetry_flush_on_max_queue_size(cx: &mut TestAppContext) {
@@ -609,15 +600,17 @@ mod tests {
            assert!(is_empty_state(&telemetry));

            let first_date_time = clock.utc_now();
-            let operation = "test".to_string();
+            let event_properties = HashMap::from_iter([(
+                "test_key".to_string(),
+                serde_json::Value::String("test_value".to_string()),
+            )]);

-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            let event = FlexibleEvent {
+                event_type: "test".to_string(),
+                event_properties,
+            };
+
+            telemetry.report_event(Event::Flexible(event.clone()));
            assert_eq!(telemetry.state.lock().events_queue.len(), 1);
            assert!(telemetry.state.lock().flush_events_task.is_some());
            assert_eq!(
@@ -627,13 +620,7 @@ mod tests {

            clock.advance(Duration::from_millis(100));

-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            telemetry.report_event(Event::Flexible(event.clone()));
            assert_eq!(telemetry.state.lock().events_queue.len(), 2);
            assert!(telemetry.state.lock().flush_events_task.is_some());
            assert_eq!(
@@ -643,13 +630,7 @@ mod tests {

            clock.advance(Duration::from_millis(100));

-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            telemetry.report_event(Event::Flexible(event.clone()));
            assert_eq!(telemetry.state.lock().events_queue.len(), 3);
            assert!(telemetry.state.lock().flush_events_task.is_some());
            assert_eq!(
@@ -660,14 +641,7 @@ mod tests {
            clock.advance(Duration::from_millis(100));

            // Adding a 4th event should cause a flush
-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
-
+            telemetry.report_event(Event::Flexible(event));
            assert!(is_empty_state(&telemetry));
        });
    }
@@ -690,17 +664,19 @@ mod tests {
            telemetry.start(system_id, installation_id, session_id, cx);

            assert!(is_empty_state(&telemetry));
-
            let first_date_time = clock.utc_now();
-            let operation = "test".to_string();

-            let event = telemetry.report_app_event(operation.clone());
-            assert_eq!(
-                event,
-                Event::App(AppEvent {
-                    operation: operation.clone(),
-                })
-            );
+            let event_properties = HashMap::from_iter([(
+                "test_key".to_string(),
+                serde_json::Value::String("test_value".to_string()),
+            )]);
+
+            let event = FlexibleEvent {
+                event_type: "test".to_string(),
+                event_properties,
+            };
+
+            telemetry.report_event(Event::Flexible(event));
            assert_eq!(telemetry.state.lock().events_queue.len(), 1);
            assert!(telemetry.state.lock().flush_events_task.is_some());
            assert_eq!(
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -201,9 +201,8 @@ impl UserStore {

                                cx.update(|cx| {
                                    if let Some(info) = info {
-                                        let disable_staff = std::env::var("ZED_DISABLE_STAFF")
-                                            .map_or(false, |v| !v.is_empty() && v != "0");
-                                        let staff = info.staff && !disable_staff;
+                                        let staff =
+                                            info.staff && !*feature_flags::ZED_DISABLE_STAFF;
                                        cx.update_flags(staff, info.flags);
                                        client.telemetry.set_authenticated_user_info(
                                            Some(info.metrics_id.clone()),
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -33,6 +33,7 @@ clock.workspace = true
 collections.workspace = true
 dashmap.workspace = true
 derive_more.workspace = true
+buffer_diff.workspace = true
 envy = "0.4.2"
 futures.workspace = true
 google_ai.workspace = true
@@ -130,7 +131,7 @@ worktree = { workspace = true, features = ["test-support"] }
 livekit_client_macos = { workspace = true, features = ["test-support"] }

 [target.'cfg(not(target_os = "macos"))'.dev-dependencies]
-livekit_client =  {workspace = true, features = ["test-support"] }
+livekit_client =  { workspace = true, features = ["test-support"] }

 [package.metadata.cargo-machete]
 ignored = ["async-stripe"]
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -100,6 +100,8 @@ CREATE TABLE "worktree_repositories" (
    "branch" VARCHAR,
    "scan_id" INTEGER NOT NULL,
    "is_deleted" BOOL NOT NULL,
+    "current_merge_conflicts" VARCHAR,
+    "branch_summary" VARCHAR,
    PRIMARY KEY(project_id, worktree_id, work_directory_id),
    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
@@ -401,6 +403,15 @@ CREATE TABLE extension_versions (
    schema_version INTEGER NOT NULL DEFAULT 0,
    wasm_api_version TEXT,
    download_count INTEGER NOT NULL DEFAULT 0,
+    provides_themes BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_icon_themes BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_languages BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_grammars BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_language_servers BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_context_servers BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_slash_commands BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_indexed_docs_providers BOOLEAN NOT NULL DEFAULT FALSE,
+    provides_snippets BOOLEAN NOT NULL DEFAULT FALSE,
    PRIMARY KEY (extension_id, version)
 );

@@ -430,6 +441,7 @@ CREATE TABLE IF NOT EXISTS billing_customers (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    user_id INTEGER NOT NULL REFERENCES users(id),
+    has_overdue_invoices BOOLEAN NOT NULL DEFAULT FALSE,
    stripe_customer_id TEXT NOT NULL
 );

--- a/crates/collab/migrations/20250204224004_add_has_overdue_invoices_to_billing_customers.sql
+++ b/crates/collab/migrations/20250204224004_add_has_overdue_invoices_to_billing_customers.sql
@@ -0,0 +1,2 @@
+alter table billing_customers
+add column has_overdue_invoices bool not null default false;
--- a/crates/collab/migrations/20250205192813_add_provides_fields_to_extension_versions.sql
+++ b/crates/collab/migrations/20250205192813_add_provides_fields_to_extension_versions.sql
@@ -0,0 +1,10 @@
+alter table extension_versions
+add column provides_themes bool not null default false,
+add column provides_icon_themes bool not null default false,
+add column provides_languages bool not null default false,
+add column provides_grammars bool not null default false,
+add column provides_language_servers bool not null default false,
+add column provides_context_servers bool not null default false,
+add column provides_slash_commands bool not null default false,
+add column provides_indexed_docs_providers bool not null default false,
+add column provides_snippets bool not null default false;
--- a/crates/collab/migrations/20250205232017_add_conflicts_to_repositories.sql
+++ b/crates/collab/migrations/20250205232017_add_conflicts_to_repositories.sql
@@ -0,0 +1,2 @@
+ALTER TABLE worktree_repositories
+ADD COLUMN current_merge_conflicts VARCHAR NULL;
--- a/crates/collab/migrations/20250210223746_add_branch_summary.sql
+++ b/crates/collab/migrations/20250210223746_add_branch_summary.sql
@@ -0,0 +1,2 @@
+ALTER TABLE worktree_repositories
+ADD COLUMN worktree_repositories VARCHAR NULL;
--- a/crates/collab/migrations/20250212060936_add_worktree_branch_summary.sql
+++ b/crates/collab/migrations/20250212060936_add_worktree_branch_summary.sql
@@ -0,0 +1 @@
+ALTER TABLE worktree_repositories ADD COLUMN branch_summary TEXT NULL;
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -249,29 +249,31 @@ async fn create_billing_subscription(
        ));
    }

-    if app.db.has_overdue_billing_subscriptions(user.id).await? {
-        return Err(Error::http(
-            StatusCode::PAYMENT_REQUIRED,
-            "user has overdue billing subscriptions".into(),
-        ));
+    let existing_billing_customer = app.db.get_billing_customer_by_user_id(user.id).await?;
+    if let Some(existing_billing_customer) = &existing_billing_customer {
+        if existing_billing_customer.has_overdue_invoices {
+            return Err(Error::http(
+                StatusCode::PAYMENT_REQUIRED,
+                "user has overdue invoices".into(),
+            ));
+        }
    }

-    let customer_id =
-        if let Some(existing_customer) = app.db.get_billing_customer_by_user_id(user.id).await? {
-            CustomerId::from_str(&existing_customer.stripe_customer_id)
-                .context("failed to parse customer ID")?
-        } else {
-            let customer = Customer::create(
-                &stripe_client,
-                CreateCustomer {
-                    email: user.email_address.as_deref(),
-                    ..Default::default()
-                },
-            )
-            .await?;
+    let customer_id = if let Some(existing_customer) = existing_billing_customer {
+        CustomerId::from_str(&existing_customer.stripe_customer_id)
+            .context("failed to parse customer ID")?
+    } else {
+        let customer = Customer::create(
+            &stripe_client,
+            CreateCustomer {
+                email: user.email_address.as_deref(),
+                ..Default::default()
+            },
+        )
+        .await?;

-            customer.id
-        };
+        customer.id
+    };

    let default_model = llm_db.model(rpc::LanguageModelProvider::Anthropic, "claude-3-5-sonnet")?;
    let stripe_model = stripe_billing.register_model(default_model).await?;
@@ -666,6 +668,27 @@ async fn handle_customer_subscription_event(
            .await?
            .ok_or_else(|| anyhow!("billing customer not found"))?;

+    let was_canceled_due_to_payment_failure = subscription.status == SubscriptionStatus::Canceled
+        && subscription
+            .cancellation_details
+            .as_ref()
+            .and_then(|details| details.reason)
+            .map_or(false, |reason| {
+                reason == CancellationDetailsReason::PaymentFailed
+            });
+
+    if was_canceled_due_to_payment_failure {
+        app.db
+            .update_billing_customer(
+                billing_customer.id,
+                &UpdateBillingCustomerParams {
+                    has_overdue_invoices: ActiveValue::set(true),
+                    ..Default::default()
+                },
+            )
+            .await?;
+    }
+
    if let Some(existing_subscription) = app
        .db
        .get_billing_subscription_by_stripe_subscription_id(&subscription.id)
--- a/crates/collab/src/api/events.rs
+++ b/crates/collab/src/api/events.rs
@@ -495,6 +495,10 @@ fn for_snowflake(
    body.events.into_iter().flat_map(move |event| {
        let timestamp =
            first_event_at + Duration::milliseconds(event.milliseconds_since_first_event);
+        // We will need to double check, but I believe all of the events that
+        // are being transformed here are now migrated over to use the
+        // telemetry::event! macro, as of this commit so this code can go away
+        // when we feel enough users have upgraded past this point.
        let (event_type, mut event_properties) = match &event.event {
            Event::Editor(e) => (
                match e.operation.as_str() {
@@ -506,7 +510,7 @@ fn for_snowflake(
            ),
            Event::InlineCompletion(e) => (
                format!(
-                    "Inline Completion {}",
+                    "Edit Prediction {}",
                    if e.suggestion_accepted {
                        "Accepted"
                    } else {
@@ -516,7 +520,7 @@ fn for_snowflake(
                serde_json::to_value(e).unwrap(),
            ),
            Event::InlineCompletionRating(e) => (
-                "Inline Completion Rated".to_string(),
+                "Edit Prediction Rated".to_string(),
                serde_json::to_value(e).unwrap(),
            ),
            Event::Call(e) => {
--- a/crates/collab/src/api/extensions.rs
+++ b/crates/collab/src/api/extensions.rs
@@ -9,10 +9,11 @@ use axum::{
    routing::get,
    Extension, Json, Router,
 };
-use collections::HashMap;
-use rpc::{ExtensionApiManifest, GetExtensionsResponse};
+use collections::{BTreeSet, HashMap};
+use rpc::{ExtensionApiManifest, ExtensionProvides, GetExtensionsResponse};
 use semantic_version::SemanticVersion;
 use serde::Deserialize;
+use std::str::FromStr;
 use std::{sync::Arc, time::Duration};
 use time::PrimitiveDateTime;
 use util::{maybe, ResultExt};
@@ -35,6 +36,14 @@ pub fn router() -> Router {
 #[derive(Debug, Deserialize)]
 struct GetExtensionsParams {
    filter: Option<String>,
+    /// A comma-delimited list of features that the extension must provide.
+    ///
+    /// For example:
+    /// - `themes`
+    /// - `themes,icon-themes`
+    /// - `languages,language-servers`
+    #[serde(default)]
+    provides: Option<String>,
    #[serde(default)]
    max_schema_version: i32,
 }
@@ -43,9 +52,22 @@ async fn get_extensions(
    Extension(app): Extension<Arc<AppState>>,
    Query(params): Query<GetExtensionsParams>,
 ) -> Result<Json<GetExtensionsResponse>> {
+    let provides_filter = params.provides.map(|provides| {
+        provides
+            .split(',')
+            .map(|value| value.trim())
+            .filter_map(|value| ExtensionProvides::from_str(value).ok())
+            .collect::<BTreeSet<_>>()
+    });
+
    let mut extensions = app
        .db
-        .get_extensions(params.filter.as_deref(), params.max_schema_version, 500)
+        .get_extensions(
+            params.filter.as_deref(),
+            provides_filter.as_ref(),
+            params.max_schema_version,
+            500,
+        )
        .await?;

    if let Some(filter) = params.filter.as_deref() {
@@ -391,6 +413,7 @@ async fn fetch_extension_manifest(
        repository: manifest.repository,
        schema_version: manifest.schema_version.unwrap_or(0),
        wasm_api_version: manifest.wasm_api_version,
+        provides: manifest.provides,
        published_at,
    })
 }
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -6,10 +6,11 @@ pub mod tests;

 use crate::{executor::Executor, Error, Result};
 use anyhow::anyhow;
-use collections::{BTreeMap, HashMap, HashSet};
+use collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use dashmap::DashMap;
 use futures::StreamExt;
 use rand::{prelude::StdRng, Rng, SeedableRng};
+use rpc::ExtensionProvides;
 use rpc::{
    proto::{self},
    ConnectionId, ExtensionMetadata,
@@ -781,6 +782,7 @@ pub struct NewExtensionVersion {
    pub repository: String,
    pub schema_version: i32,
    pub wasm_api_version: Option<String>,
+    pub provides: BTreeSet<ExtensionProvides>,
    pub published_at: PrimitiveDateTime,
 }

--- a/crates/collab/src/db/queries/billing_customers.rs
+++ b/crates/collab/src/db/queries/billing_customers.rs
@@ -10,6 +10,7 @@ pub struct CreateBillingCustomerParams {
 pub struct UpdateBillingCustomerParams {
    pub user_id: ActiveValue<UserId>,
    pub stripe_customer_id: ActiveValue<String>,
+    pub has_overdue_invoices: ActiveValue<bool>,
 }

 impl Database {
@@ -43,6 +44,7 @@ impl Database {
                id: ActiveValue::set(id),
                user_id: params.user_id.clone(),
                stripe_customer_id: params.stripe_customer_id.clone(),
+                has_overdue_invoices: params.has_overdue_invoices.clone(),
                ..Default::default()
            })
            .exec(&*tx)
--- a/crates/collab/src/db/queries/billing_subscriptions.rs
+++ b/crates/collab/src/db/queries/billing_subscriptions.rs
@@ -170,40 +170,4 @@ impl Database {
        })
        .await
    }
-
-    /// Returns whether the user has any overdue billing subscriptions.
-    pub async fn has_overdue_billing_subscriptions(&self, user_id: UserId) -> Result<bool> {
-        Ok(self.count_overdue_billing_subscriptions(user_id).await? > 0)
-    }
-
-    /// Returns the count of the overdue billing subscriptions for the user with the specified ID.
-    ///
-    /// This includes subscriptions:
-    /// - Whose status is `past_due`
-    /// - Whose status is `canceled` and the cancellation reason is `payment_failed`
-    pub async fn count_overdue_billing_subscriptions(&self, user_id: UserId) -> Result<usize> {
-        self.transaction(|tx| async move {
-            let past_due = billing_subscription::Column::StripeSubscriptionStatus
-                .eq(StripeSubscriptionStatus::PastDue);
-            let payment_failed = billing_subscription::Column::StripeSubscriptionStatus
-                .eq(StripeSubscriptionStatus::Canceled)
-                .and(
-                    billing_subscription::Column::StripeCancellationReason
-                        .eq(StripeCancellationReason::PaymentFailed),
-                );
-
-            let count = billing_subscription::Entity::find()
-                .inner_join(billing_customer::Entity)
-                .filter(
-                    billing_customer::Column::UserId
-                        .eq(user_id)
-                        .and(past_due.or(payment_failed)),
-                )
-                .count(&*tx)
-                .await?;
-
-            Ok(count as usize)
-        })
-        .await
-    }
 }
--- a/crates/collab/src/db/queries/extensions.rs
+++ b/crates/collab/src/db/queries/extensions.rs
@@ -10,6 +10,7 @@ impl Database {
    pub async fn get_extensions(
        &self,
        filter: Option<&str>,
+        provides_filter: Option<&BTreeSet<ExtensionProvides>>,
        max_schema_version: i32,
        limit: usize,
    ) -> Result<Vec<ExtensionMetadata>> {
@@ -26,6 +27,10 @@ impl Database {
                condition = condition.add(Expr::cust_with_expr("name ILIKE $1", fuzzy_name_filter));
            }

+            if let Some(provides_filter) = provides_filter {
+                condition = apply_provides_filter(condition, provides_filter);
+            }
+
            self.get_extensions_where(condition, Some(limit as u64), &tx)
                .await
        })
@@ -282,6 +287,39 @@ impl Database {
                        description: ActiveValue::Set(version.description.clone()),
                        schema_version: ActiveValue::Set(version.schema_version),
                        wasm_api_version: ActiveValue::Set(version.wasm_api_version.clone()),
+                        provides_themes: ActiveValue::Set(
+                            version.provides.contains(&ExtensionProvides::Themes),
+                        ),
+                        provides_icon_themes: ActiveValue::Set(
+                            version.provides.contains(&ExtensionProvides::IconThemes),
+                        ),
+                        provides_languages: ActiveValue::Set(
+                            version.provides.contains(&ExtensionProvides::Languages),
+                        ),
+                        provides_grammars: ActiveValue::Set(
+                            version.provides.contains(&ExtensionProvides::Grammars),
+                        ),
+                        provides_language_servers: ActiveValue::Set(
+                            version
+                                .provides
+                                .contains(&ExtensionProvides::LanguageServers),
+                        ),
+                        provides_context_servers: ActiveValue::Set(
+                            version
+                                .provides
+                                .contains(&ExtensionProvides::ContextServers),
+                        ),
+                        provides_slash_commands: ActiveValue::Set(
+                            version.provides.contains(&ExtensionProvides::SlashCommands),
+                        ),
+                        provides_indexed_docs_providers: ActiveValue::Set(
+                            version
+                                .provides
+                                .contains(&ExtensionProvides::IndexedDocsProviders),
+                        ),
+                        provides_snippets: ActiveValue::Set(
+                            version.provides.contains(&ExtensionProvides::Snippets),
+                        ),
                        download_count: ActiveValue::NotSet,
                    }
                }))
@@ -352,10 +390,55 @@ impl Database {
    }
 }

+fn apply_provides_filter(
+    mut condition: Condition,
+    provides_filter: &BTreeSet<ExtensionProvides>,
+) -> Condition {
+    if provides_filter.contains(&ExtensionProvides::Themes) {
+        condition = condition.add(extension_version::Column::ProvidesThemes.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::IconThemes) {
+        condition = condition.add(extension_version::Column::ProvidesIconThemes.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::Languages) {
+        condition = condition.add(extension_version::Column::ProvidesLanguages.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::Grammars) {
+        condition = condition.add(extension_version::Column::ProvidesGrammars.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::LanguageServers) {
+        condition = condition.add(extension_version::Column::ProvidesLanguageServers.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::ContextServers) {
+        condition = condition.add(extension_version::Column::ProvidesContextServers.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::SlashCommands) {
+        condition = condition.add(extension_version::Column::ProvidesSlashCommands.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::IndexedDocsProviders) {
+        condition = condition.add(extension_version::Column::ProvidesIndexedDocsProviders.eq(true));
+    }
+
+    if provides_filter.contains(&ExtensionProvides::Snippets) {
+        condition = condition.add(extension_version::Column::ProvidesSnippets.eq(true));
+    }
+
+    condition
+}
+
 fn metadata_from_extension_and_version(
    extension: extension::Model,
    version: extension_version::Model,
 ) -> ExtensionMetadata {
+    let provides = version.provides();
+
    ExtensionMetadata {
        id: extension.external_id.into(),
        manifest: rpc::ExtensionApiManifest {
@@ -370,6 +453,7 @@ fn metadata_from_extension_and_version(
            repository: version.repository,
            schema_version: Some(version.schema_version),
            wasm_api_version: version.wasm_api_version,
+            provides,
        },

        published_at: convert_time_to_chrono(version.published_at),
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -326,13 +326,26 @@ impl Database {

            if !update.updated_repositories.is_empty() {
                worktree_repository::Entity::insert_many(update.updated_repositories.iter().map(
-                    |repository| worktree_repository::ActiveModel {
-                        project_id: ActiveValue::set(project_id),
-                        worktree_id: ActiveValue::set(worktree_id),
-                        work_directory_id: ActiveValue::set(repository.work_directory_id as i64),
-                        scan_id: ActiveValue::set(update.scan_id as i64),
-                        branch: ActiveValue::set(repository.branch.clone()),
-                        is_deleted: ActiveValue::set(false),
+                    |repository| {
+                        worktree_repository::ActiveModel {
+                            project_id: ActiveValue::set(project_id),
+                            worktree_id: ActiveValue::set(worktree_id),
+                            work_directory_id: ActiveValue::set(
+                                repository.work_directory_id as i64,
+                            ),
+                            scan_id: ActiveValue::set(update.scan_id as i64),
+                            branch: ActiveValue::set(repository.branch.clone()),
+                            is_deleted: ActiveValue::set(false),
+                            branch_summary: ActiveValue::Set(
+                                repository
+                                    .branch_summary
+                                    .as_ref()
+                                    .map(|summary| serde_json::to_string(summary).unwrap()),
+                            ),
+                            current_merge_conflicts: ActiveValue::Set(Some(
+                                serde_json::to_string(&repository.current_merge_conflicts).unwrap(),
+                            )),
+                        }
                    },
                ))
                .on_conflict(
@@ -344,6 +357,8 @@ impl Database {
                    .update_columns([
                        worktree_repository::Column::ScanId,
                        worktree_repository::Column::Branch,
+                        worktree_repository::Column::BranchSummary,
+                        worktree_repository::Column::CurrentMergeConflicts,
                    ])
                    .to_owned(),
                )
@@ -769,6 +784,20 @@ impl Database {
                        updated_statuses.push(db_status_to_proto(status_entry)?);
                    }

+                    let current_merge_conflicts = db_repository_entry
+                        .current_merge_conflicts
+                        .as_ref()
+                        .map(|conflicts| serde_json::from_str(&conflicts))
+                        .transpose()?
+                        .unwrap_or_default();
+
+                    let branch_summary = db_repository_entry
+                        .branch_summary
+                        .as_ref()
+                        .map(|branch_summary| serde_json::from_str(&branch_summary))
+                        .transpose()?
+                        .unwrap_or_default();
+
                    worktree.repository_entries.insert(
                        db_repository_entry.work_directory_id as u64,
                        proto::RepositoryEntry {
@@ -776,6 +805,8 @@ impl Database {
                            branch: db_repository_entry.branch,
                            updated_statuses,
                            removed_statuses: Vec::new(),
+                            current_merge_conflicts,
+                            branch_summary,
                        },
                    );
                }
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -736,11 +736,27 @@ impl Database {
                            }
                        }

+                        let current_merge_conflicts = db_repository
+                            .current_merge_conflicts
+                            .as_ref()
+                            .map(|conflicts| serde_json::from_str(&conflicts))
+                            .transpose()?
+                            .unwrap_or_default();
+
+                        let branch_summary = db_repository
+                            .branch_summary
+                            .as_ref()
+                            .map(|branch_summary| serde_json::from_str(&branch_summary))
+                            .transpose()?
+                            .unwrap_or_default();
+
                        worktree.updated_repositories.push(proto::RepositoryEntry {
                            work_directory_id: db_repository.work_directory_id as u64,
                            branch: db_repository.branch,
                            updated_statuses,
                            removed_statuses,
+                            current_merge_conflicts,
+                            branch_summary,
                        });
                    }
                }
--- a/crates/collab/src/db/queries/users.rs
+++ b/crates/collab/src/db/queries/users.rs
@@ -133,26 +133,23 @@ impl Database {
        initial_channel_id: Option<ChannelId>,
        tx: &DatabaseTransaction,
    ) -> Result<User> {
-        if let Some(user_by_github_user_id) = user::Entity::find()
-            .filter(user::Column::GithubUserId.eq(github_user_id))
-            .one(tx)
+        if let Some(existing_user) = self
+            .get_user_by_github_user_id_or_github_login(github_user_id, github_login, tx)
            .await?
        {
-            let mut user_by_github_user_id = user_by_github_user_id.into_active_model();
-            user_by_github_user_id.github_login = ActiveValue::set(github_login.into());
-            user_by_github_user_id.github_user_created_at =
-                ActiveValue::set(Some(github_user_created_at));
-            Ok(user_by_github_user_id.update(tx).await?)
-        } else if let Some(user_by_github_login) = user::Entity::find()
-            .filter(user::Column::GithubLogin.eq(github_login))
-            .one(tx)
-            .await?
-        {
-            let mut user_by_github_login = user_by_github_login.into_active_model();
-            user_by_github_login.github_user_id = ActiveValue::set(github_user_id);
-            user_by_github_login.github_user_created_at =
-                ActiveValue::set(Some(github_user_created_at));
-            Ok(user_by_github_login.update(tx).await?)
+            let mut existing_user = existing_user.into_active_model();
+            existing_user.github_login = ActiveValue::set(github_login.into());
+            existing_user.github_user_created_at = ActiveValue::set(Some(github_user_created_at));
+
+            if let Some(github_email) = github_email {
+                existing_user.email_address = ActiveValue::set(Some(github_email.into()));
+            }
+
+            if let Some(github_name) = github_name {
+                existing_user.name = ActiveValue::set(Some(github_name.into()));
+            }
+
+            Ok(existing_user.update(tx).await?)
        } else {
            let user = user::Entity::insert(user::ActiveModel {
                email_address: ActiveValue::set(github_email.map(|email| email.into())),
@@ -183,6 +180,34 @@ impl Database {
        }
    }

+    /// Tries to retrieve a user, first by their GitHub user ID, and then by their GitHub login.
+    ///
+    /// Returns `None` if a user is not found with this GitHub user ID or GitHub login.
+    pub async fn get_user_by_github_user_id_or_github_login(
+        &self,
+        github_user_id: i32,
+        github_login: &str,
+        tx: &DatabaseTransaction,
+    ) -> Result<Option<User>> {
+        if let Some(user_by_github_user_id) = user::Entity::find()
+            .filter(user::Column::GithubUserId.eq(github_user_id))
+            .one(tx)
+            .await?
+        {
+            return Ok(Some(user_by_github_user_id));
+        }
+
+        if let Some(user_by_github_login) = user::Entity::find()
+            .filter(user::Column::GithubLogin.eq(github_login))
+            .one(tx)
+            .await?
+        {
+            return Ok(Some(user_by_github_login));
+        }
+
+        Ok(None)
+    }
+
    /// get_all_users returns the next page of users. To get more call again with
    /// the same limit and the page incremented by 1.
    pub async fn get_all_users(&self, page: u32, limit: u32) -> Result<Vec<User>> {
--- a/crates/collab/src/db/tables/billing_customer.rs
+++ b/crates/collab/src/db/tables/billing_customer.rs
@@ -9,6 +9,7 @@ pub struct Model {
    pub id: BillingCustomerId,
    pub user_id: UserId,
    pub stripe_customer_id: String,
+    pub has_overdue_invoices: bool,
    pub created_at: DateTime,
 }

--- a/crates/collab/src/db/tables/extension_version.rs
+++ b/crates/collab/src/db/tables/extension_version.rs
@@ -1,4 +1,6 @@
 use crate::db::ExtensionId;
+use collections::BTreeSet;
+use rpc::ExtensionProvides;
 use sea_orm::entity::prelude::*;
 use time::PrimitiveDateTime;

@@ -16,6 +18,58 @@ pub struct Model {
    pub schema_version: i32,
    pub wasm_api_version: Option<String>,
    pub download_count: i64,
+    pub provides_themes: bool,
+    pub provides_icon_themes: bool,
+    pub provides_languages: bool,
+    pub provides_grammars: bool,
+    pub provides_language_servers: bool,
+    pub provides_context_servers: bool,
+    pub provides_slash_commands: bool,
+    pub provides_indexed_docs_providers: bool,
+    pub provides_snippets: bool,
+}
+
+impl Model {
+    pub fn provides(&self) -> BTreeSet<ExtensionProvides> {
+        let mut provides = BTreeSet::default();
+        if self.provides_themes {
+            provides.insert(ExtensionProvides::Themes);
+        }
+
+        if self.provides_icon_themes {
+            provides.insert(ExtensionProvides::IconThemes);
+        }
+
+        if self.provides_languages {
+            provides.insert(ExtensionProvides::Languages);
+        }
+
+        if self.provides_grammars {
+            provides.insert(ExtensionProvides::Grammars);
+        }
+
+        if self.provides_language_servers {
+            provides.insert(ExtensionProvides::LanguageServers);
+        }
+
+        if self.provides_context_servers {
+            provides.insert(ExtensionProvides::ContextServers);
+        }
+
+        if self.provides_slash_commands {
+            provides.insert(ExtensionProvides::SlashCommands);
+        }
+
+        if self.provides_indexed_docs_providers {
+            provides.insert(ExtensionProvides::IndexedDocsProviders);
+        }
+
+        if self.provides_snippets {
+            provides.insert(ExtensionProvides::Snippets);
+        }
+
+        provides
+    }
 }

 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
--- a/crates/collab/src/db/tables/worktree_repository.rs
+++ b/crates/collab/src/db/tables/worktree_repository.rs
@@ -13,6 +13,10 @@ pub struct Model {
    pub scan_id: i64,
    pub branch: Option<String>,
    pub is_deleted: bool,
+    // JSON array typed string
+    pub current_merge_conflicts: Option<String>,
+    // A JSON object representing the current Branch values
+    pub branch_summary: Option<String>,
 }

 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
--- a/crates/collab/src/db/tests/billing_subscription_tests.rs
+++ b/crates/collab/src/db/tests/billing_subscription_tests.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;

-use crate::db::billing_subscription::{StripeCancellationReason, StripeSubscriptionStatus};
+use crate::db::billing_subscription::StripeSubscriptionStatus;
 use crate::db::tests::new_test_user;
 use crate::db::{CreateBillingCustomerParams, CreateBillingSubscriptionParams};
 use crate::test_both_dbs;
@@ -88,113 +88,3 @@ async fn test_get_active_billing_subscriptions(db: &Arc<Database>) {
        assert_eq!(subscription_count, 0);
    }
 }
-
-test_both_dbs!(
-    test_count_overdue_billing_subscriptions,
-    test_count_overdue_billing_subscriptions_postgres,
-    test_count_overdue_billing_subscriptions_sqlite
-);
-
-async fn test_count_overdue_billing_subscriptions(db: &Arc<Database>) {
-    // A user with no subscription has no overdue billing subscriptions.
-    {
-        let user_id = new_test_user(db, "no-subscription-user@example.com").await;
-        let subscription_count = db
-            .count_overdue_billing_subscriptions(user_id)
-            .await
-            .unwrap();
-
-        assert_eq!(subscription_count, 0);
-    }
-
-    // A user with a past-due subscription has an overdue billing subscription.
-    {
-        let user_id = new_test_user(db, "past-due-user@example.com").await;
-        let customer = db
-            .create_billing_customer(&CreateBillingCustomerParams {
-                user_id,
-                stripe_customer_id: "cus_past_due_user".into(),
-            })
-            .await
-            .unwrap();
-        assert_eq!(customer.stripe_customer_id, "cus_past_due_user".to_string());
-
-        db.create_billing_subscription(&CreateBillingSubscriptionParams {
-            billing_customer_id: customer.id,
-            stripe_subscription_id: "sub_past_due_user".into(),
-            stripe_subscription_status: StripeSubscriptionStatus::PastDue,
-            stripe_cancellation_reason: None,
-        })
-        .await
-        .unwrap();
-
-        let subscription_count = db
-            .count_overdue_billing_subscriptions(user_id)
-            .await
-            .unwrap();
-        assert_eq!(subscription_count, 1);
-    }
-
-    // A user with a canceled subscription with a reason of `payment_failed` has an overdue billing subscription.
-    {
-        let user_id =
-            new_test_user(db, "canceled-subscription-payment-failed-user@example.com").await;
-        let customer = db
-            .create_billing_customer(&CreateBillingCustomerParams {
-                user_id,
-                stripe_customer_id: "cus_canceled_subscription_payment_failed_user".into(),
-            })
-            .await
-            .unwrap();
-        assert_eq!(
-            customer.stripe_customer_id,
-            "cus_canceled_subscription_payment_failed_user".to_string()
-        );
-
-        db.create_billing_subscription(&CreateBillingSubscriptionParams {
-            billing_customer_id: customer.id,
-            stripe_subscription_id: "sub_canceled_subscription_payment_failed_user".into(),
-            stripe_subscription_status: StripeSubscriptionStatus::Canceled,
-            stripe_cancellation_reason: Some(StripeCancellationReason::PaymentFailed),
-        })
-        .await
-        .unwrap();
-
-        let subscription_count = db
-            .count_overdue_billing_subscriptions(user_id)
-            .await
-            .unwrap();
-        assert_eq!(subscription_count, 1);
-    }
-
-    // A user with a canceled subscription with a reason of `cancellation_requested` has no overdue billing subscriptions.
-    {
-        let user_id = new_test_user(db, "canceled-subscription-user@example.com").await;
-        let customer = db
-            .create_billing_customer(&CreateBillingCustomerParams {
-                user_id,
-                stripe_customer_id: "cus_canceled_subscription_user".into(),
-            })
-            .await
-            .unwrap();
-        assert_eq!(
-            customer.stripe_customer_id,
-            "cus_canceled_subscription_user".to_string()
-        );
-
-        db.create_billing_subscription(&CreateBillingSubscriptionParams {
-            billing_customer_id: customer.id,
-            stripe_subscription_id: "sub_canceled_subscription_user".into(),
-            stripe_subscription_status: StripeSubscriptionStatus::Canceled,
-            stripe_cancellation_reason: Some(StripeCancellationReason::CancellationRequested),
-        })
-        .await
-        .unwrap();
-
-        let subscription_count = db
-            .count_overdue_billing_subscriptions(user_id)
-            .await
-            .unwrap();
-        assert_eq!(subscription_count, 0);
-    }
-}
--- a/crates/collab/src/db/tests/extension_tests.rs
+++ b/crates/collab/src/db/tests/extension_tests.rs
@@ -1,10 +1,14 @@
+use std::collections::BTreeSet;
+use std::sync::Arc;
+
+use rpc::ExtensionProvides;
+
 use super::Database;
 use crate::db::ExtensionVersionConstraints;
 use crate::{
    db::{queries::extensions::convert_time_to_chrono, ExtensionMetadata, NewExtensionVersion},
    test_both_dbs,
 };
-use std::sync::Arc;

 test_both_dbs!(
    test_extensions,
@@ -16,7 +20,7 @@ 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, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
    assert!(extensions.is_empty());

    let t0 = time::OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
@@ -37,6 +41,7 @@ async fn test_extensions(db: &Arc<Database>) {
                        repository: "ext1/repo".into(),
                        schema_version: 1,
                        wasm_api_version: None,
+                        provides: BTreeSet::default(),
                        published_at: t0,
                    },
                    NewExtensionVersion {
@@ -47,6 +52,7 @@ async fn test_extensions(db: &Arc<Database>) {
                        repository: "ext1/repo".into(),
                        schema_version: 1,
                        wasm_api_version: None,
+                        provides: BTreeSet::default(),
                        published_at: t0,
                    },
                ],
@@ -61,6 +67,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext2/repo".into(),
                    schema_version: 0,
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                    published_at: t0,
                }],
            ),
@@ -83,7 +90,7 @@ async fn test_extensions(db: &Arc<Database>) {
    );

    // The latest version of each extension is returned.
-    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[
@@ -97,6 +104,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext1/repo".into(),
                    schema_version: Some(1),
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                },
                published_at: t0_chrono,
                download_count: 0,
@@ -111,6 +119,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext2/repo".into(),
                    schema_version: Some(0),
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                },
                published_at: t0_chrono,
                download_count: 0
@@ -119,7 +128,7 @@ async fn test_extensions(db: &Arc<Database>) {
    );

    // Extensions with too new of a schema version are excluded.
-    let extensions = db.get_extensions(None, 0, 5).await.unwrap();
+    let extensions = db.get_extensions(None, None, 0, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[ExtensionMetadata {
@@ -132,6 +141,7 @@ async fn test_extensions(db: &Arc<Database>) {
                repository: "ext2/repo".into(),
                schema_version: Some(0),
                wasm_api_version: None,
+                provides: BTreeSet::default(),
            },
            published_at: t0_chrono,
            download_count: 0
@@ -158,7 +168,7 @@ async fn test_extensions(db: &Arc<Database>) {
        .unwrap());

    // Extensions are returned in descending order of total downloads.
-    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[
@@ -172,6 +182,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext2/repo".into(),
                    schema_version: Some(0),
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                },
                published_at: t0_chrono,
                download_count: 7
@@ -186,6 +197,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext1/repo".into(),
                    schema_version: Some(1),
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                },
                published_at: t0_chrono,
                download_count: 5,
@@ -207,6 +219,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext1/repo".into(),
                    schema_version: 1,
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                    published_at: t0,
                }],
            ),
@@ -220,6 +233,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext2/repo".into(),
                    schema_version: 0,
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                    published_at: t0,
                }],
            ),
@@ -244,7 +258,7 @@ async fn test_extensions(db: &Arc<Database>) {
        .collect()
    );

-    let extensions = db.get_extensions(None, 1, 5).await.unwrap();
+    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
    assert_eq!(
        extensions,
        &[
@@ -258,6 +272,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext2/repo".into(),
                    schema_version: Some(0),
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                },
                published_at: t0_chrono,
                download_count: 7
@@ -272,6 +287,7 @@ async fn test_extensions(db: &Arc<Database>) {
                    repository: "ext1/repo".into(),
                    schema_version: Some(1),
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                },
                published_at: t0_chrono,
                download_count: 5,
@@ -290,7 +306,7 @@ 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();
+    let extensions = db.get_extensions(None, None, 1, 5).await.unwrap();
    assert!(extensions.is_empty());

    let t0 = time::OffsetDateTime::from_unix_timestamp_nanos(0).unwrap();
@@ -311,6 +327,10 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                        repository: "ext1/repo".into(),
                        schema_version: 1,
                        wasm_api_version: Some("0.0.4".into()),
+                        provides: BTreeSet::from_iter([
+                            ExtensionProvides::Grammars,
+                            ExtensionProvides::Languages,
+                        ]),
                        published_at: t0,
                    },
                    NewExtensionVersion {
@@ -321,6 +341,11 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                        repository: "ext1/repo".into(),
                        schema_version: 1,
                        wasm_api_version: Some("0.0.4".into()),
+                        provides: BTreeSet::from_iter([
+                            ExtensionProvides::Grammars,
+                            ExtensionProvides::Languages,
+                            ExtensionProvides::LanguageServers,
+                        ]),
                        published_at: t0,
                    },
                    NewExtensionVersion {
@@ -331,6 +356,11 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                        repository: "ext1/repo".into(),
                        schema_version: 1,
                        wasm_api_version: Some("0.0.5".into()),
+                        provides: BTreeSet::from_iter([
+                            ExtensionProvides::Grammars,
+                            ExtensionProvides::Languages,
+                            ExtensionProvides::LanguageServers,
+                        ]),
                        published_at: t0,
                    },
                ],
@@ -345,6 +375,7 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                    repository: "ext2/repo".into(),
                    schema_version: 0,
                    wasm_api_version: None,
+                    provides: BTreeSet::default(),
                    published_at: t0,
                }],
            ),
@@ -378,6 +409,11 @@ async fn test_extensions_by_id(db: &Arc<Database>) {
                repository: "ext1/repo".into(),
                schema_version: Some(1),
                wasm_api_version: Some("0.0.4".into()),
+                provides: BTreeSet::from_iter([
+                    ExtensionProvides::Grammars,
+                    ExtensionProvides::Languages,
+                    ExtensionProvides::LanguageServers,
+                ]),
            },
            published_at: t0_chrono,
            download_count: 0,
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -309,7 +309,8 @@ impl Server {
            .add_request_handler(forward_read_only_project_request::<proto::ResolveInlayHint>)
            .add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
            .add_request_handler(forward_read_only_project_request::<proto::GitBranches>)
-            .add_request_handler(forward_read_only_project_request::<proto::GetStagedText>)
+            .add_request_handler(forward_read_only_project_request::<proto::OpenUnstagedDiff>)
+            .add_request_handler(forward_read_only_project_request::<proto::OpenUncommittedDiff>)
            .add_request_handler(
                forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
            )
@@ -348,7 +349,7 @@ impl Server {
            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateBufferFile>)
            .add_message_handler(broadcast_project_message_from_host::<proto::BufferReloaded>)
            .add_message_handler(broadcast_project_message_from_host::<proto::BufferSaved>)
-            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBase>)
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBases>)
            .add_request_handler(get_users)
            .add_request_handler(fuzzy_search_users)
            .add_request_handler(request_contact)
@@ -394,6 +395,10 @@ impl Server {
            .add_request_handler(forward_mutating_project_request::<proto::Stage>)
            .add_request_handler(forward_mutating_project_request::<proto::Unstage>)
            .add_request_handler(forward_mutating_project_request::<proto::Commit>)
+            .add_request_handler(forward_read_only_project_request::<proto::GitShow>)
+            .add_request_handler(forward_read_only_project_request::<proto::GitReset>)
+            .add_request_handler(forward_mutating_project_request::<proto::SetIndexText>)
+            .add_request_handler(forward_mutating_project_request::<proto::OpenCommitMessageBuffer>)
            .add_message_handler(broadcast_project_message_from_host::<proto::AdvertiseContexts>)
            .add_message_handler(update_context)
            .add_request_handler({
--- a/crates/collab/src/tests/channel_buffer_tests.rs
+++ b/crates/collab/src/tests/channel_buffer_tests.rs
@@ -342,7 +342,7 @@ async fn test_multiple_handles_to_channel_buffer(
        future::try_join3(channel_buffer_1, channel_buffer_2, channel_buffer_3)
            .await
            .unwrap();
-    let channel_buffer_model_id = channel_buffer.entity_id();
+    let channel_buffer_entity_id = channel_buffer.entity_id();
    assert_eq!(channel_buffer, channel_buffer_2);
    assert_eq!(channel_buffer, channel_buffer_3);

@@ -366,7 +366,7 @@ async fn test_multiple_handles_to_channel_buffer(
        .update(cx_a, |store, cx| store.open_channel_buffer(channel_id, cx))
        .await
        .unwrap();
-    assert_ne!(channel_buffer.entity_id(), channel_buffer_model_id);
+    assert_ne!(channel_buffer.entity_id(), channel_buffer_entity_id);
    channel_buffer.update(cx_a, |buffer, cx| {
        buffer.buffer().update(cx, |buffer, _| {
            assert_eq!(buffer.text(), "hello");
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -1991,10 +1991,9 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
        .collect(),
        remote_url: Some("git@github.com:zed-industries/zed.git".to_string()),
    };
-    client_a.fs().set_blame_for_repo(
-        Path::new("/my-repo/.git"),
-        vec![(Path::new("file.txt"), blame)],
-    );
+    client_a
+        .fs()
+        .set_blame_for_repo(Path::new("/my-repo/.git"), vec![("file.txt".into(), blame)]);

    let (project_a, worktree_id) = client_a.build_local_project("/my-repo", cx_a).await;
    let project_id = active_call_a
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -8,6 +8,7 @@ use crate::{
 use anyhow::{anyhow, Result};
 use assistant_context_editor::ContextStore;
 use assistant_slash_command::SlashCommandWorkingSet;
+use buffer_diff::{assert_hunks, DiffHunkSecondaryStatus, DiffHunkStatus};
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{User, RECEIVE_TIMEOUT};
 use collections::{HashMap, HashSet};
@@ -2558,13 +2559,27 @@ async fn test_git_diff_base_change(

    let project_remote = client_b.join_remote_project(project_id, cx_b).await;

-    let diff_base = "
+    let staged_text = "
        one
        three
    "
    .unindent();

-    let new_diff_base = "
+    let committed_text = "
+        one
+        TWO
+        three
+    "
+    .unindent();
+
+    let new_committed_text = "
+        one
+        TWO_HUNDRED
+        three
+    "
+    .unindent();
+
+    let new_staged_text = "
        one
        two
    "
@@ -2572,7 +2587,11 @@ async fn test_git_diff_base_change(

    client_a.fs().set_index_for_repo(
        Path::new("/dir/.git"),
-        &[(Path::new("a.txt"), diff_base.clone())],
+        &[("a.txt".into(), staged_text.clone())],
+    );
+    client_a.fs().set_head_for_repo(
+        Path::new("/dir/.git"),
+        &[("a.txt".into(), committed_text.clone())],
    );

    // Create the buffer
@@ -2580,26 +2599,26 @@ async fn test_git_diff_base_change(
        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
        .await
        .unwrap();
-    let change_set_local_a = project_local
+    let local_unstaged_diff_a = project_local
        .update(cx_a, |p, cx| {
-            p.open_unstaged_changes(buffer_local_a.clone(), cx)
+            p.open_unstaged_diff(buffer_local_a.clone(), cx)
        })
        .await
        .unwrap();

    // Wait for it to catch up to the new diff
    executor.run_until_parked();
-    change_set_local_a.read_with(cx_a, |change_set, cx| {
+    local_unstaged_diff_a.read_with(cx_a, |diff, cx| {
        let buffer = buffer_local_a.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &diff_base,
-            &[(1..2, "", "two\n")],
+            &diff.base_text_string().unwrap(),
+            &[(1..2, "", "two\n", DiffHunkStatus::added())],
        );
    });

@@ -2608,73 +2627,123 @@ async fn test_git_diff_base_change(
        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
        .await
        .unwrap();
-    let change_set_remote_a = project_remote
+    let remote_unstaged_diff_a = project_remote
        .update(cx_b, |p, cx| {
-            p.open_unstaged_changes(buffer_remote_a.clone(), cx)
+            p.open_unstaged_diff(buffer_remote_a.clone(), cx)
        })
        .await
        .unwrap();

    // Wait remote buffer to catch up to the new diff
    executor.run_until_parked();
-    change_set_remote_a.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_diff_a.read_with(cx_b, |diff, cx| {
        let buffer = buffer_remote_a.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &diff_base,
-            &[(1..2, "", "two\n")],
+            &diff.base_text_string().unwrap(),
+            &[(1..2, "", "two\n", DiffHunkStatus::added())],
        );
    });

-    // Update the staged text of the open buffer
+    // Open uncommitted changes on the guest, without opening them on the host first
+    let remote_uncommitted_diff_a = project_remote
+        .update(cx_b, |p, cx| {
+            p.open_uncommitted_diff(buffer_remote_a.clone(), cx)
+        })
+        .await
+        .unwrap();
+    executor.run_until_parked();
+    remote_uncommitted_diff_a.read_with(cx_b, |diff, cx| {
+        let buffer = buffer_remote_a.read(cx);
+        assert_eq!(
+            diff.base_text_string().as_deref(),
+            Some(committed_text.as_str())
+        );
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
+            buffer,
+            &diff.base_text_string().unwrap(),
+            &[(
+                1..2,
+                "TWO\n",
+                "two\n",
+                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::HasSecondaryHunk),
+            )],
+        );
+    });
+
+    // Update the index text of the open buffer
    client_a.fs().set_index_for_repo(
        Path::new("/dir/.git"),
-        &[(Path::new("a.txt"), new_diff_base.clone())],
+        &[("a.txt".into(), new_staged_text.clone())],
+    );
+    client_a.fs().set_head_for_repo(
+        Path::new("/dir/.git"),
+        &[("a.txt".into(), new_committed_text.clone())],
    );

    // Wait for buffer_local_a to receive it
    executor.run_until_parked();
-    change_set_local_a.read_with(cx_a, |change_set, cx| {
+    local_unstaged_diff_a.read_with(cx_a, |diff, cx| {
        let buffer = buffer_local_a.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(new_staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &new_diff_base,
-            &[(2..3, "", "three\n")],
+            &diff.base_text_string().unwrap(),
+            &[(2..3, "", "three\n", DiffHunkStatus::added())],
        );
    });

-    change_set_remote_a.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_diff_a.read_with(cx_b, |diff, cx| {
        let buffer = buffer_remote_a.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(new_staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &new_diff_base,
-            &[(2..3, "", "three\n")],
+            &diff.base_text_string().unwrap(),
+            &[(2..3, "", "three\n", DiffHunkStatus::added())],
+        );
+    });
+
+    remote_uncommitted_diff_a.read_with(cx_b, |diff, cx| {
+        let buffer = buffer_remote_a.read(cx);
+        assert_eq!(
+            diff.base_text_string().as_deref(),
+            Some(new_committed_text.as_str())
+        );
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
+            buffer,
+            &diff.base_text_string().unwrap(),
+            &[(
+                1..2,
+                "TWO_HUNDRED\n",
+                "two\n",
+                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk),
+            )],
        );
    });

    // Nested git dir
-    let diff_base = "
+    let staged_text = "
        one
        three
    "
    .unindent();

-    let new_diff_base = "
+    let new_staged_text = "
        one
        two
    "
@@ -2682,7 +2751,7 @@ async fn test_git_diff_base_change(

    client_a.fs().set_index_for_repo(
        Path::new("/dir/sub/.git"),
-        &[(Path::new("b.txt"), diff_base.clone())],
+        &[("b.txt".into(), staged_text.clone())],
    );

    // Create the buffer
@@ -2690,26 +2759,26 @@ async fn test_git_diff_base_change(
        .update(cx_a, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
        .await
        .unwrap();
-    let change_set_local_b = project_local
+    let local_unstaged_diff_b = project_local
        .update(cx_a, |p, cx| {
-            p.open_unstaged_changes(buffer_local_b.clone(), cx)
+            p.open_unstaged_diff(buffer_local_b.clone(), cx)
        })
        .await
        .unwrap();

    // Wait for it to catch up to the new diff
    executor.run_until_parked();
-    change_set_local_b.read_with(cx_a, |change_set, cx| {
+    local_unstaged_diff_b.read_with(cx_a, |diff, cx| {
        let buffer = buffer_local_b.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &diff_base,
-            &[(1..2, "", "two\n")],
+            &diff.base_text_string().unwrap(),
+            &[(1..2, "", "two\n", DiffHunkStatus::added())],
        );
    });

@@ -2718,61 +2787,61 @@ async fn test_git_diff_base_change(
        .update(cx_b, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
        .await
        .unwrap();
-    let change_set_remote_b = project_remote
+    let remote_unstaged_diff_b = project_remote
        .update(cx_b, |p, cx| {
-            p.open_unstaged_changes(buffer_remote_b.clone(), cx)
+            p.open_unstaged_diff(buffer_remote_b.clone(), cx)
        })
        .await
        .unwrap();

    executor.run_until_parked();
-    change_set_remote_b.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_diff_b.read_with(cx_b, |diff, cx| {
        let buffer = buffer_remote_b.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &diff_base,
-            &[(1..2, "", "two\n")],
+            &staged_text,
+            &[(1..2, "", "two\n", DiffHunkStatus::added())],
        );
    });

-    // Update the staged text
+    // Updatet the staged text
    client_a.fs().set_index_for_repo(
        Path::new("/dir/sub/.git"),
-        &[(Path::new("b.txt"), new_diff_base.clone())],
+        &[("b.txt".into(), new_staged_text.clone())],
    );

    // Wait for buffer_local_b to receive it
    executor.run_until_parked();
-    change_set_local_b.read_with(cx_a, |change_set, cx| {
+    local_unstaged_diff_b.read_with(cx_a, |diff, cx| {
        let buffer = buffer_local_b.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(new_staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &new_diff_base,
-            &[(2..3, "", "three\n")],
+            &new_staged_text,
+            &[(2..3, "", "three\n", DiffHunkStatus::added())],
        );
    });

-    change_set_remote_b.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_diff_b.read_with(cx_b, |diff, cx| {
        let buffer = buffer_remote_b.read(cx);
        assert_eq!(
-            change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            diff.base_text_string().as_deref(),
+            Some(new_staged_text.as_str())
        );
-        git::diff::assert_hunks(
-            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+        assert_hunks(
+            diff.hunks_in_row_range(0..4, buffer, cx),
            buffer,
-            &new_diff_base,
-            &[(2..3, "", "three\n")],
+            &new_staged_text,
+            &[(2..3, "", "three\n", DiffHunkStatus::added())],
        );
    });
 }
@@ -2826,7 +2895,10 @@ async fn test_git_branch_name(
        assert_eq!(worktrees.len(), 1);
        let worktree = worktrees[0].clone();
        let root_entry = worktree.read(cx).snapshot().root_git_entry().unwrap();
-        assert_eq!(root_entry.branch(), branch_name.map(Into::into));
+        assert_eq!(
+            root_entry.branch().map(|branch| branch.name.to_string()),
+            branch_name
+        );
    }

    // Smoke test branch reading
@@ -6714,7 +6786,7 @@ async fn test_remote_git_branches(
        })
    });

-    assert_eq!(host_branch.as_ref(), branches[2]);
+    assert_eq!(host_branch.name, branches[2]);

    // Also try creating a new branch
    cx_b.update(|cx| {
@@ -6735,5 +6807,5 @@ async fn test_remote_git_branches(
        })
    });

-    assert_eq!(host_branch.as_ref(), "totally-new-branch");
+    assert_eq!(host_branch.name, "totally-new-branch");
 }
--- a/crates/collab/src/tests/random_project_collaboration_tests.rs
+++ b/crates/collab/src/tests/random_project_collaboration_tests.rs
@@ -953,8 +953,8 @@ impl RandomizedTest for ProjectCollaborationTest {

                    let dot_git_dir = repo_path.join(".git");
                    let contents = contents
-                        .iter()
-                        .map(|(path, contents)| (path.as_path(), contents.clone()))
+                        .into_iter()
+                        .map(|(path, contents)| (path.into(), contents))
                        .collect::<Vec<_>>();
                    if client.fs().metadata(&dot_git_dir).await?.is_none() {
                        client.fs().create_dir(&dot_git_dir).await?;
@@ -1339,7 +1339,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                        project
                            .buffer_store()
                            .read(cx)
-                            .get_unstaged_changes(host_buffer.read(cx).remote_id())
+                            .get_unstaged_diff(host_buffer.read(cx).remote_id(), cx)
                            .unwrap()
                            .read(cx)
                            .base_text_string()
@@ -1348,7 +1348,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                        project
                            .buffer_store()
                            .read(cx)
-                            .get_unstaged_changes(guest_buffer.read(cx).remote_id())
+                            .get_unstaged_diff(guest_buffer.read(cx).remote_id(), cx)
                            .unwrap()
                            .read(cx)
                            .base_text_string()
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -314,7 +314,7 @@ async fn test_ssh_collaboration_git_branches(
        })
    });

-    assert_eq!(server_branch.as_ref(), branches[2]);
+    assert_eq!(server_branch.name, branches[2]);

    // Also try creating a new branch
    cx_b.update(|cx| {
@@ -337,7 +337,7 @@ async fn test_ssh_collaboration_git_branches(
        })
    });

-    assert_eq!(server_branch.as_ref(), "totally-new-branch");
+    assert_eq!(server_branch.name, "totally-new-branch");
 }

 #[gpui::test]
--- a/crates/collab/src/tests/test_server.rs
+++ b/crates/collab/src/tests/test_server.rs
@@ -849,10 +849,10 @@ impl TestClient {
    ) -> (Entity<Workspace>, &'a mut VisualTestContext) {
        let window = cx.update(|cx| cx.active_window().unwrap().downcast::<Workspace>().unwrap());

-        let model = window.root(cx).unwrap();
+        let entity = window.root(cx).unwrap();
        let cx = VisualTestContext::from_window(*window.deref(), cx).as_mut();
        // it might be nice to try and cleanup these at the end of each test.
-        (model, cx)
+        (entity, cx)
    }
 }

@@ -861,9 +861,9 @@ pub fn open_channel_notes(
    cx: &mut VisualTestContext,
 ) -> Task<anyhow::Result<Entity<ChannelView>>> {
    let window = cx.update(|_, cx| cx.active_window().unwrap().downcast::<Workspace>().unwrap());
-    let model = window.root(cx).unwrap();
+    let entity = window.root(cx).unwrap();

-    cx.update(|window, cx| ChannelView::open(channel_id, None, model.clone(), window, cx))
+    cx.update(|window, cx| ChannelView::open(channel_id, None, entity.clone(), window, cx))
 }

 impl Drop for TestClient {
--- a/crates/collab_ui/src/channel_view.rs
+++ b/crates/collab_ui/src/channel_view.rs
@@ -461,7 +461,7 @@ impl Item for ChannelView {
            .child(
                Label::new(channel_name)
                    .color(params.text_color())
-                    .italic(params.preview),
+                    .when(params.preview, |this| this.italic()),
            )
            .when_some(status, |element, status| {
                element.child(
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -97,14 +97,14 @@ impl ChatPanel {
        });

        cx.new(|cx| {
-            let model = cx.entity().downgrade();
+            let entity = cx.entity().downgrade();
            let message_list = ListState::new(
                0,
                gpui::ListAlignment::Bottom,
                px(1000.),
                move |ix, window, cx| {
-                    if let Some(model) = model.upgrade() {
-                        model.update(cx, |this: &mut Self, cx| {
+                    if let Some(entity) = entity.upgrade() {
+                        entity.update(cx, |this: &mut Self, cx| {
                            this.render_message(ix, window, cx).into_any_element()
                        })
                    } else {
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -239,14 +239,14 @@ impl CollabPanel {
            )
            .detach();

-            let model = cx.entity().downgrade();
+            let entity = cx.entity().downgrade();
            let list_state = ListState::new(
                0,
                gpui::ListAlignment::Top,
                px(1000.),
                move |ix, window, cx| {
-                    if let Some(model) = model.upgrade() {
-                        model.update(cx, |this, cx| this.render_list_entry(ix, window, cx))
+                    if let Some(entity) = entity.upgrade() {
+                        entity.update(cx, |this, cx| this.render_list_entry(ix, window, cx))
                    } else {
                        div().into_any()
                    }
--- a/crates/collab_ui/src/notification_panel.rs
+++ b/crates/collab_ui/src/notification_panel.rs
@@ -110,13 +110,13 @@ impl NotificationPanel {
            })
            .detach();

-            let model = cx.entity().downgrade();
+            let entity = cx.entity().downgrade();
            let notification_list =
                ListState::new(0, ListAlignment::Top, px(1000.), move |ix, window, cx| {
-                    model
+                    entity
                        .upgrade()
-                        .and_then(|model| {
-                            model.update(cx, |this, cx| this.render_notification(ix, window, cx))
+                        .and_then(|entity| {
+                            entity.update(cx, |this, cx| this.render_notification(ix, window, cx))
                        })
                        .unwrap_or_else(|| div().into_any())
                });
@@ -323,9 +323,9 @@ impl NotificationPanel {
                                            .justify_end()
                                            .child(Button::new("decline", "Decline").on_click({
                                                let notification = notification.clone();
-                                                let model = cx.entity().clone();
+                                                let entity = cx.entity().clone();
                                                move |_, _, cx| {
-                                                    model.update(cx, |this, cx| {
+                                                    entity.update(cx, |this, cx| {
                                                        this.respond_to_notification(
                                                            notification.clone(),
                                                            false,
@@ -336,9 +336,9 @@ impl NotificationPanel {
                                            }))
                                            .child(Button::new("accept", "Accept").on_click({
                                                let notification = notification.clone();
-                                                let model = cx.entity().clone();
+                                                let entity = cx.entity().clone();
                                                move |_, _, cx| {
-                                                    model.update(cx, |this, cx| {
+                                                    entity.update(cx, |this, cx| {
                                                        this.respond_to_notification(
                                                            notification.clone(),
                                                            true,
--- a/crates/command_palette/src/command_palette.rs
+++ b/crates/command_palette/src/command_palette.rs
@@ -198,26 +198,29 @@ impl CommandPaletteDelegate {
    ) {
        self.updating_matches.take();

-        let mut intercept_result = CommandPaletteInterceptor::try_global(cx)
-            .and_then(|interceptor| interceptor.intercept(&query, cx));
+        let mut intercept_results = CommandPaletteInterceptor::try_global(cx)
+            .map(|interceptor| interceptor.intercept(&query, cx))
+            .unwrap_or_default();

        if parse_zed_link(&query, cx).is_some() {
-            intercept_result = Some(CommandInterceptResult {
+            intercept_results = vec![CommandInterceptResult {
                action: OpenZedUrl { url: query.clone() }.boxed_clone(),
                string: query.clone(),
                positions: vec![],
-            })
+            }]
        }

-        if let Some(CommandInterceptResult {
+        let mut new_matches = Vec::new();
+
+        for CommandInterceptResult {
            action,
            string,
            positions,
-        }) = intercept_result
+        } in intercept_results
        {
            if let Some(idx) = matches
                .iter()
-                .position(|m| commands[m.candidate_id].action.type_id() == action.type_id())
+                .position(|m| commands[m.candidate_id].action.partial_eq(&*action))
            {
                matches.remove(idx);
            }
@@ -225,18 +228,16 @@ impl CommandPaletteDelegate {
                name: string.clone(),
                action,
            });
-            matches.insert(
-                0,
-                StringMatch {
-                    candidate_id: commands.len() - 1,
-                    string,
-                    positions,
-                    score: 0.0,
-                },
-            )
+            new_matches.push(StringMatch {
+                candidate_id: commands.len() - 1,
+                string,
+                positions,
+                score: 0.0,
+            })
        }
+        new_matches.append(&mut matches);
        self.commands = commands;
-        self.matches = matches;
+        self.matches = new_matches;
        if self.matches.is_empty() {
            self.selected_ix = 0;
        } else {
--- a/crates/command_palette_hooks/src/command_palette_hooks.rs
+++ b/crates/command_palette_hooks/src/command_palette_hooks.rs
@@ -108,7 +108,7 @@ pub struct CommandInterceptResult {
 /// An interceptor for the command palette.
 #[derive(Default)]
 pub struct CommandPaletteInterceptor(
-    Option<Box<dyn Fn(&str, &App) -> Option<CommandInterceptResult>>>,
+    Option<Box<dyn Fn(&str, &App) -> Vec<CommandInterceptResult>>>,
 );

 #[derive(Default)]
@@ -132,10 +132,12 @@ impl CommandPaletteInterceptor {
    }

    /// Intercepts the given query from the command palette.
-    pub fn intercept(&self, query: &str, cx: &App) -> Option<CommandInterceptResult> {
-        let handler = self.0.as_ref()?;
-
-        (handler)(query, cx)
+    pub fn intercept(&self, query: &str, cx: &App) -> Vec<CommandInterceptResult> {
+        if let Some(handler) = self.0.as_ref() {
+            (handler)(query, cx)
+        } else {
+            Vec::new()
+        }
    }

    /// Clears the global interceptor.
@@ -146,7 +148,7 @@ impl CommandPaletteInterceptor {
    /// Sets the global interceptor.
    ///
    /// This will override the previous interceptor, if it exists.
-    pub fn set(&mut self, handler: Box<dyn Fn(&str, &App) -> Option<CommandInterceptResult>>) {
+    pub fn set(&mut self, handler: Box<dyn Fn(&str, &App) -> Vec<CommandInterceptResult>>) {
        self.0 = Some(handler);
    }
 }
--- a/crates/component/Cargo.toml
+++ b/crates/component/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "component"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/component.rs"
+
+[dependencies]
+collections.workspace = true
+gpui.workspace = true
+linkme.workspace = true
+once_cell = "1.20.3"
+parking_lot.workspace = true
+theme.workspace = true
+
+[features]
+default = []
--- a/crates/zed_predict_onboarding/LICENSE-GPL
+++ b/crates/zed_predict_onboarding/LICENSE-GPL
--- a/crates/component/src/component.rs
+++ b/crates/component/src/component.rs
@@ -0,0 +1,327 @@
+use std::ops::{Deref, DerefMut};
+
+use collections::HashMap;
+use gpui::{div, prelude::*, px, AnyElement, App, IntoElement, RenderOnce, SharedString, Window};
+use linkme::distributed_slice;
+use once_cell::sync::Lazy;
+use parking_lot::RwLock;
+use theme::ActiveTheme;
+
+pub trait Component {
+    fn scope() -> Option<&'static str>;
+    fn name() -> &'static str {
+        std::any::type_name::<Self>()
+    }
+    fn description() -> Option<&'static str> {
+        None
+    }
+}
+
+pub trait ComponentPreview: Component {
+    fn preview(_window: &mut Window, _cx: &App) -> AnyElement;
+}
+
+#[distributed_slice]
+pub static __ALL_COMPONENTS: [fn()] = [..];
+
+#[distributed_slice]
+pub static __ALL_PREVIEWS: [fn()] = [..];
+
+pub static COMPONENT_DATA: Lazy<RwLock<ComponentRegistry>> =
+    Lazy::new(|| RwLock::new(ComponentRegistry::new()));
+
+pub struct ComponentRegistry {
+    components: Vec<(Option<&'static str>, &'static str, Option<&'static str>)>,
+    previews: HashMap<&'static str, fn(&mut Window, &App) -> AnyElement>,
+}
+
+impl ComponentRegistry {
+    fn new() -> Self {
+        ComponentRegistry {
+            components: Vec::new(),
+            previews: HashMap::default(),
+        }
+    }
+}
+
+pub fn init() {
+    let component_fns: Vec<_> = __ALL_COMPONENTS.iter().cloned().collect();
+    let preview_fns: Vec<_> = __ALL_PREVIEWS.iter().cloned().collect();
+
+    for f in component_fns {
+        f();
+    }
+    for f in preview_fns {
+        f();
+    }
+}
+
+pub fn register_component<T: Component>() {
+    let component_data = (T::scope(), T::name(), T::description());
+    COMPONENT_DATA.write().components.push(component_data);
+}
+
+pub fn register_preview<T: ComponentPreview>() {
+    let preview_data = (T::name(), T::preview as fn(&mut Window, &App) -> AnyElement);
+    COMPONENT_DATA
+        .write()
+        .previews
+        .insert(preview_data.0, preview_data.1);
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ComponentId(pub &'static str);
+
+#[derive(Clone)]
+pub struct ComponentMetadata {
+    name: SharedString,
+    scope: Option<SharedString>,
+    description: Option<SharedString>,
+    preview: Option<fn(&mut Window, &App) -> AnyElement>,
+}
+
+impl ComponentMetadata {
+    pub fn name(&self) -> SharedString {
+        self.name.clone()
+    }
+
+    pub fn scope(&self) -> Option<SharedString> {
+        self.scope.clone()
+    }
+
+    pub fn description(&self) -> Option<SharedString> {
+        self.description.clone()
+    }
+
+    pub fn preview(&self) -> Option<fn(&mut Window, &App) -> AnyElement> {
+        self.preview
+    }
+}
+
+pub struct AllComponents(pub HashMap<ComponentId, ComponentMetadata>);
+
+impl AllComponents {
+    pub fn new() -> Self {
+        AllComponents(HashMap::default())
+    }
+
+    /// Returns all components with previews
+    pub fn all_previews(&self) -> Vec<&ComponentMetadata> {
+        self.0.values().filter(|c| c.preview.is_some()).collect()
+    }
+
+    /// Returns all components with previews sorted by name
+    pub fn all_previews_sorted(&self) -> Vec<ComponentMetadata> {
+        let mut previews: Vec<ComponentMetadata> =
+            self.all_previews().into_iter().cloned().collect();
+        previews.sort_by_key(|a| a.name());
+        previews
+    }
+
+    /// Returns all components
+    pub fn all(&self) -> Vec<&ComponentMetadata> {
+        self.0.values().collect()
+    }
+
+    /// Returns all components sorted by name
+    pub fn all_sorted(&self) -> Vec<ComponentMetadata> {
+        let mut components: Vec<ComponentMetadata> = self.all().into_iter().cloned().collect();
+        components.sort_by_key(|a| a.name());
+        components
+    }
+}
+
+impl Deref for AllComponents {
+    type Target = HashMap<ComponentId, ComponentMetadata>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for AllComponents {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+pub fn components() -> AllComponents {
+    let data = COMPONENT_DATA.read();
+    let mut all_components = AllComponents::new();
+
+    for &(scope, name, description) in &data.components {
+        let scope = scope.map(Into::into);
+        let preview = data.previews.get(name).cloned();
+        all_components.insert(
+            ComponentId(name),
+            ComponentMetadata {
+                name: name.into(),
+                scope,
+                description: description.map(Into::into),
+                preview,
+            },
+        );
+    }
+
+    all_components
+}
+
+/// Which side of the preview to show labels on
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ExampleLabelSide {
+    /// Left side
+    Left,
+    /// Right side
+    Right,
+    #[default]
+    /// Top side
+    Top,
+    /// Bottom side
+    Bottom,
+}
+
+/// A single example of a component.
+#[derive(IntoElement)]
+pub struct ComponentExample {
+    variant_name: SharedString,
+    element: AnyElement,
+    label_side: ExampleLabelSide,
+    grow: bool,
+}
+
+impl RenderOnce for ComponentExample {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        let base = div().flex();
+
+        let base = match self.label_side {
+            ExampleLabelSide::Right => base.flex_row(),
+            ExampleLabelSide::Left => base.flex_row_reverse(),
+            ExampleLabelSide::Bottom => base.flex_col(),
+            ExampleLabelSide::Top => base.flex_col_reverse(),
+        };
+
+        base.gap_1()
+            .p_2()
+            .text_sm()
+            .text_color(cx.theme().colors().text)
+            .when(self.grow, |this| this.flex_1())
+            .child(self.element)
+            .child(self.variant_name)
+            .into_any_element()
+    }
+}
+
+impl ComponentExample {
+    /// Create a new example with the given variant name and example value.
+    pub fn new(variant_name: impl Into<SharedString>, element: AnyElement) -> Self {
+        Self {
+            variant_name: variant_name.into(),
+            element,
+            label_side: ExampleLabelSide::default(),
+            grow: false,
+        }
+    }
+
+    /// Set the example to grow to fill the available horizontal space.
+    pub fn grow(mut self) -> Self {
+        self.grow = true;
+        self
+    }
+}
+
+/// A group of component examples.
+#[derive(IntoElement)]
+pub struct ComponentExampleGroup {
+    pub title: Option<SharedString>,
+    pub examples: Vec<ComponentExample>,
+    pub grow: bool,
+}
+
+impl RenderOnce for ComponentExampleGroup {
+    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
+        div()
+            .flex_col()
+            .text_sm()
+            .text_color(cx.theme().colors().text_muted)
+            .when(self.grow, |this| this.w_full().flex_1())
+            .when_some(self.title, |this, title| {
+                this.gap_4().pb_5().child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap_3()
+                        .child(div().h_px().w_4().bg(cx.theme().colors().border_variant))
+                        .child(
+                            div()
+                                .flex_none()
+                                .text_size(px(10.))
+                                .child(title.to_uppercase()),
+                        )
+                        .child(
+                            div()
+                                .h_px()
+                                .w_full()
+                                .flex_1()
+                                .bg(cx.theme().colors().border),
+                        ),
+                )
+            })
+            .child(
+                div()
+                    .flex()
+                    .items_start()
+                    .w_full()
+                    .gap_8()
+                    .children(self.examples)
+                    .into_any_element(),
+            )
+            .into_any_element()
+    }
+}
+
+impl ComponentExampleGroup {
+    /// Create a new group of examples with the given title.
+    pub fn new(examples: Vec<ComponentExample>) -> Self {
+        Self {
+            title: None,
+            examples,
+            grow: false,
+        }
+    }
+
+    /// Create a new group of examples with the given title.
+    pub fn with_title(title: impl Into<SharedString>, examples: Vec<ComponentExample>) -> Self {
+        Self {
+            title: Some(title.into()),
+            examples,
+            grow: false,
+        }
+    }
+
+    /// Set the group to grow to fill the available horizontal space.
+    pub fn grow(mut self) -> Self {
+        self.grow = true;
+        self
+    }
+}
+
+/// Create a single example
+pub fn single_example(
+    variant_name: impl Into<SharedString>,
+    example: AnyElement,
+) -> ComponentExample {
+    ComponentExample::new(variant_name, example)
+}
+
+/// Create a group of examples without a title
+pub fn example_group(examples: Vec<ComponentExample>) -> ComponentExampleGroup {
+    ComponentExampleGroup::new(examples)
+}
+
+/// Create a group of examples with a title
+pub fn example_group_with_title(
+    title: impl Into<SharedString>,
+    examples: Vec<ComponentExample>,
+) -> ComponentExampleGroup {
+    ComponentExampleGroup::with_title(title, examples)
+}
--- a/crates/component_preview/Cargo.toml
+++ b/crates/component_preview/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "vcs_menu"
+name = "component_preview"
 version = "0.1.0"
 edition.workspace = true
 publish.workspace = true
@@ -8,14 +8,14 @@ license = "GPL-3.0-or-later"
 [lints]
 workspace = true

+[lib]
+path = "src/component_preview.rs"
+
+[features]
+default = []
+
 [dependencies]
-anyhow.workspace = true
-fuzzy.workspace = true
-git.workspace = true
+component.workspace = true
 gpui.workspace = true
-picker.workspace = true
-project.workspace = true
 ui.workspace = true
-util.workspace = true
 workspace.workspace = true
-zed_actions.workspace = true
--- a/crates/component_preview/LICENSE-GPL
+++ b/crates/component_preview/LICENSE-GPL
@@ -0,0 +1 @@
+../../LICENSE-GPL
--- a/crates/component_preview/src/component_preview.rs
+++ b/crates/component_preview/src/component_preview.rs
@@ -0,0 +1,190 @@
+//! # Component Preview
+//!
+//! A view for exploring Zed components.
+
+use component::{components, ComponentMetadata};
+use gpui::{prelude::*, App, EventEmitter, FocusHandle, Focusable, Window};
+use ui::prelude::*;
+
+use workspace::{item::ItemEvent, Item, Workspace, WorkspaceId};
+
+pub fn init(cx: &mut App) {
+    cx.observe_new(|workspace: &mut Workspace, _, _cx| {
+        workspace.register_action(
+            |workspace, _: &workspace::OpenComponentPreview, window, cx| {
+                let component_preview = cx.new(ComponentPreview::new);
+                workspace.add_item_to_active_pane(
+                    Box::new(component_preview),
+                    None,
+                    true,
+                    window,
+                    cx,
+                )
+            },
+        );
+    })
+    .detach();
+}
+
+struct ComponentPreview {
+    focus_handle: FocusHandle,
+}
+
+impl ComponentPreview {
+    pub fn new(cx: &mut Context<Self>) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+        }
+    }
+
+    fn render_sidebar(&self, _window: &Window, _cx: &Context<Self>) -> impl IntoElement {
+        let components = components().all_sorted();
+        let sorted_components = components.clone();
+
+        v_flex()
+            .max_w_48()
+            .gap_px()
+            .p_1()
+            .children(
+                sorted_components
+                    .into_iter()
+                    .map(|component| self.render_sidebar_entry(&component, _cx)),
+            )
+            .child(
+                Label::new("These will be clickable once the layout is moved to a gpui::List.")
+                    .color(Color::Muted)
+                    .size(LabelSize::XSmall)
+                    .italic(),
+            )
+    }
+
+    fn render_sidebar_entry(
+        &self,
+        component: &ComponentMetadata,
+        _cx: &Context<Self>,
+    ) -> impl IntoElement {
+        h_flex()
+            .w_40()
+            .px_1p5()
+            .py_0p5()
+            .text_sm()
+            .child(component.name().clone())
+    }
+
+    fn render_preview(
+        &self,
+        component: &ComponentMetadata,
+        window: &mut Window,
+        cx: &Context<Self>,
+    ) -> impl IntoElement {
+        let name = component.name();
+        let scope = component.scope();
+
+        let description = component.description();
+
+        v_flex()
+            .border_b_1()
+            .border_color(cx.theme().colors().border)
+            .w_full()
+            .gap_3()
+            .py_6()
+            .child(
+                v_flex()
+                    .gap_1()
+                    .child(
+                        h_flex()
+                            .gap_1()
+                            .text_2xl()
+                            .child(div().child(name))
+                            .when_some(scope, |this, scope| {
+                                this.child(div().opacity(0.5).child(format!("({})", scope)))
+                            }),
+                    )
+                    .when_some(description, |this, description| {
+                        this.child(
+                            div()
+                                .text_ui_sm(cx)
+                                .text_color(cx.theme().colors().text_muted)
+                                .max_w(px(600.0))
+                                .child(description),
+                        )
+                    }),
+            )
+            .when_some(component.preview(), |this, preview| {
+                this.child(preview(window, cx))
+            })
+            .into_any_element()
+    }
+
+    fn render_previews(&self, window: &mut Window, cx: &Context<Self>) -> impl IntoElement {
+        v_flex()
+            .id("component-previews")
+            .size_full()
+            .overflow_y_scroll()
+            .p_4()
+            .gap_4()
+            .children(
+                components()
+                    .all_previews_sorted()
+                    .iter()
+                    .map(|component| self.render_preview(component, window, cx)),
+            )
+    }
+}
+
+impl Render for ComponentPreview {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<'_, Self>) -> impl IntoElement {
+        h_flex()
+            .id("component-preview")
+            .key_context("ComponentPreview")
+            .items_start()
+            .overflow_hidden()
+            .size_full()
+            .max_h_full()
+            .track_focus(&self.focus_handle)
+            .px_2()
+            .bg(cx.theme().colors().editor_background)
+            .child(self.render_sidebar(window, cx))
+            .child(self.render_previews(window, cx))
+    }
+}
+
+impl EventEmitter<ItemEvent> for ComponentPreview {}
+
+impl Focusable for ComponentPreview {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Item for ComponentPreview {
+    type Event = ItemEvent;
+
+    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
+        Some("Component Preview".into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn show_toolbar(&self) -> bool {
+        false
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<WorkspaceId>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<gpui::Entity<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new(Self::new))
+    }
+
+    fn to_item_events(event: &Self::Event, mut f: impl FnMut(workspace::item::ItemEvent)) {
+        f(*event)
+    }
+}
--- a/crates/copilot/Cargo.toml
+++ b/crates/copilot/Cargo.toml
@@ -59,20 +59,20 @@ workspace.workspace = true
 async-std = { version = "1.12.0", features = ["unstable"] }

 [dev-dependencies]
-indoc.workspace = true
-serde_json.workspace = true
-clock = { workspace = true, features = ["test-support"] }
 client = { workspace = true, features = ["test-support"] }
+clock = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 http_client = { workspace = true, features = ["test-support"] }
+indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
 lsp = { workspace = true, features = ["test-support"] }
 node_runtime = { workspace = true, features = ["test-support"] }
 project = { workspace = true, features = ["test-support"] }
 rpc = { workspace = true, features = ["test-support"] }
+serde_json.workspace = true
 settings = { workspace = true, features = ["test-support"] }
 theme = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -17,7 +17,7 @@ use gpui::{
 use http_client::github::get_release_by_tag_name;
 use http_client::HttpClient;
 use language::{
-    language_settings::{all_language_settings, language_settings, InlineCompletionProvider},
+    language_settings::{all_language_settings, language_settings, EditPredictionProvider},
    point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16,
    ToPointUtf16,
 };
@@ -368,8 +368,8 @@ impl Copilot {
        let server_id = self.server_id;
        let http = self.http.clone();
        let node_runtime = self.node_runtime.clone();
-        if all_language_settings(None, cx).inline_completions.provider
-            == InlineCompletionProvider::Copilot
+        if all_language_settings(None, cx).edit_predictions.provider
+            == EditPredictionProvider::Copilot
        {
            if matches!(self.server, CopilotServer::Disabled) {
                let start_task = cx
@@ -1061,6 +1061,7 @@ async fn get_copilot_lsp(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
 mod tests {
    use super::*;
    use gpui::TestAppContext;
+    use util::path;

    #[gpui::test(iterations = 10)]
    async fn test_buffer_management(cx: &mut TestAppContext) {
@@ -1123,7 +1124,7 @@ mod tests {
        buffer_1.update(cx, |buffer, cx| {
            buffer.file_updated(
                Arc::new(File {
-                    abs_path: "/root/child/buffer-1".into(),
+                    abs_path: path!("/root/child/buffer-1").into(),
                    path: Path::new("child/buffer-1").into(),
                }),
                cx,
@@ -1136,7 +1137,7 @@ mod tests {
                text_document: lsp::TextDocumentIdentifier::new(buffer_1_uri),
            }
        );
-        let buffer_1_uri = lsp::Url::from_file_path("/root/child/buffer-1").unwrap();
+        let buffer_1_uri = lsp::Url::from_file_path(path!("/root/child/buffer-1")).unwrap();
        assert_eq!(
            lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
                .await,
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -36,8 +36,8 @@ pub enum Model {
    Gpt3_5Turbo,
    #[serde(alias = "o1", rename = "o1")]
    O1,
-    #[serde(alias = "o1-mini", rename = "o1-mini")]
-    O1Mini,
+    #[serde(alias = "o1-mini", rename = "o3-mini")]
+    O3Mini,
    #[serde(alias = "claude-3-5-sonnet", rename = "claude-3.5-sonnet")]
    Claude3_5Sonnet,
 }
@@ -46,7 +46,7 @@ impl Model {
    pub fn uses_streaming(&self) -> bool {
        match self {
            Self::Gpt4o | Self::Gpt4 | Self::Gpt3_5Turbo | Self::Claude3_5Sonnet => true,
-            Self::O1Mini | Self::O1 => false,
+            Self::O3Mini | Self::O1 => false,
        }
    }

@@ -56,7 +56,7 @@ impl Model {
            "gpt-4" => Ok(Self::Gpt4),
            "gpt-3.5-turbo" => Ok(Self::Gpt3_5Turbo),
            "o1" => Ok(Self::O1),
-            "o1-mini" => Ok(Self::O1Mini),
+            "o3-mini" => Ok(Self::O3Mini),
            "claude-3-5-sonnet" => Ok(Self::Claude3_5Sonnet),
            _ => Err(anyhow!("Invalid model id: {}", id)),
        }
@@ -67,7 +67,7 @@ impl Model {
            Self::Gpt3_5Turbo => "gpt-3.5-turbo",
            Self::Gpt4 => "gpt-4",
            Self::Gpt4o => "gpt-4o",
-            Self::O1Mini => "o1-mini",
+            Self::O3Mini => "o3-mini",
            Self::O1 => "o1",
            Self::Claude3_5Sonnet => "claude-3-5-sonnet",
        }
@@ -78,7 +78,7 @@ impl Model {
            Self::Gpt3_5Turbo => "GPT-3.5",
            Self::Gpt4 => "GPT-4",
            Self::Gpt4o => "GPT-4o",
-            Self::O1Mini => "o1-mini",
+            Self::O3Mini => "o3-mini",
            Self::O1 => "o1",
            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
        }
@@ -89,7 +89,7 @@ impl Model {
            Self::Gpt4o => 64000,
            Self::Gpt4 => 32768,
            Self::Gpt3_5Turbo => 12288,
-            Self::O1Mini => 20000,
+            Self::O3Mini => 20000,
            Self::O1 => 20000,
            Self::Claude3_5Sonnet => 200_000,
        }
--- a/crates/copilot/src/copilot_completion_provider.rs
+++ b/crates/copilot/src/copilot_completion_provider.rs
@@ -1,11 +1,9 @@
 use crate::{Completion, Copilot};
 use anyhow::Result;
 use gpui::{App, Context, Entity, EntityId, Task};
-use inline_completion::{Direction, InlineCompletion, InlineCompletionProvider};
-use language::{
-    language_settings::{all_language_settings, AllLanguageSettings},
-    Buffer, OffsetRangeExt, ToOffset,
-};
+use inline_completion::{Direction, EditPredictionProvider, InlineCompletion};
+use language::{language_settings::AllLanguageSettings, Buffer, OffsetRangeExt, ToOffset};
+use project::Project;
 use settings::Settings;
 use std::{path::Path, time::Duration};

@@ -50,7 +48,7 @@ impl CopilotCompletionProvider {
    }
 }

-impl InlineCompletionProvider for CopilotCompletionProvider {
+impl EditPredictionProvider for CopilotCompletionProvider {
    fn name() -> &'static str {
        "copilot"
    }
@@ -63,33 +61,22 @@ impl InlineCompletionProvider for CopilotCompletionProvider {
        false
    }

-    fn show_completions_in_normal_mode() -> bool {
-        false
-    }
-
    fn is_refreshing(&self) -> bool {
        self.pending_refresh.is_some()
    }

    fn is_enabled(
        &self,
-        buffer: &Entity<Buffer>,
-        cursor_position: language::Anchor,
+        _buffer: &Entity<Buffer>,
+        _cursor_position: language::Anchor,
        cx: &App,
    ) -> bool {
-        if !self.copilot.read(cx).status().is_authorized() {
-            return false;
-        }
-
-        let buffer = buffer.read(cx);
-        let file = buffer.file();
-        let language = buffer.language_at(cursor_position);
-        let settings = all_language_settings(file, cx);
-        settings.inline_completions_enabled(language.as_ref(), file.map(|f| f.path().as_ref()), cx)
+        self.copilot.read(cx).status().is_authorized()
    }

    fn refresh(
        &mut self,
+        _project: Option<Entity<Project>>,
        buffer: Entity<Buffer>,
        cursor_position: language::Anchor,
        debounce: bool,
@@ -205,7 +192,7 @@ impl InlineCompletionProvider for CopilotCompletionProvider {
    fn discard(&mut self, cx: &mut Context<Self>) {
        let settings = AllLanguageSettings::get_global(cx);

-        let copilot_enabled = settings.inline_completions_enabled(None, None, cx);
+        let copilot_enabled = settings.show_inline_completions(None, cx);

        if !copilot_enabled {
            return;
@@ -255,6 +242,7 @@ impl InlineCompletionProvider for CopilotCompletionProvider {
            } else {
                let position = cursor_position.bias_right(buffer);
                Some(InlineCompletion {
+                    id: None,
                    edits: vec![(position..position, completion_text.into())],
                    edit_preview: None,
                })
@@ -290,7 +278,10 @@ mod tests {
    use serde_json::json;
    use settings::SettingsStore;
    use std::future::Future;
-    use util::test::{marked_text_ranges_by, TextRangeMarker};
+    use util::{
+        path,
+        test::{marked_text_ranges_by, TextRangeMarker},
+    };

    #[gpui::test(iterations = 10)]
    async fn test_copilot(executor: BackgroundExecutor, cx: &mut TestAppContext) {
@@ -311,7 +302,7 @@ mod tests {
        .await;
        let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
        cx.update_editor(|editor, window, cx| {
-            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
+            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
        });

        cx.set_state(indoc! {"
@@ -341,7 +332,6 @@ mod tests {
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, window, cx| {
            assert!(editor.context_menu_visible());
-            assert!(!editor.context_menu_contains_inline_completion());
            assert!(!editor.has_active_inline_completion());
            // Since we have both, the copilot suggestion is not shown inline
            assert_eq!(editor.text(cx), "one.\ntwo\nthree\n");
@@ -394,12 +384,11 @@ mod tests {
            assert_eq!(editor.text(cx), "one.\ntwo\nthree\n");
        });

-        // Ensure existing inline completion is interpolated when inserting again.
+        // Ensure existing edit prediction is interpolated when inserting again.
        cx.simulate_keystroke("c");
        executor.run_until_parked();
        cx.update_editor(|editor, _, cx| {
            assert!(!editor.context_menu_visible());
-            assert!(!editor.context_menu_contains_inline_completion());
            assert!(editor.has_active_inline_completion());
            assert_eq!(editor.display_text(cx), "one.copilot1\ntwo\nthree\n");
            assert_eq!(editor.text(cx), "one.c\ntwo\nthree\n");
@@ -419,7 +408,6 @@ mod tests {
        cx.update_editor(|editor, window, cx| {
            assert!(!editor.context_menu_visible());
            assert!(editor.has_active_inline_completion());
-            assert!(!editor.context_menu_contains_inline_completion());
            assert_eq!(editor.display_text(cx), "one.copilot2\ntwo\nthree\n");
            assert_eq!(editor.text(cx), "one.c\ntwo\nthree\n");

@@ -449,8 +437,8 @@ mod tests {
            assert_eq!(editor.display_text(cx), "one.copilot2\ntwo\nthree\n");
            assert_eq!(editor.text(cx), "one.co\ntwo\nthree\n");

-            // AcceptInlineCompletion when there is an active suggestion inserts it.
-            editor.accept_inline_completion(&Default::default(), window, cx);
+            // AcceptEditPrediction when there is an active suggestion inserts it.
+            editor.accept_edit_prediction(&Default::default(), window, cx);
            assert!(!editor.has_active_inline_completion());
            assert_eq!(editor.display_text(cx), "one.copilot2\ntwo\nthree\n");
            assert_eq!(editor.text(cx), "one.copilot2\ntwo\nthree\n");
@@ -495,7 +483,7 @@ mod tests {
        );

        cx.update_editor(|editor, window, cx| {
-            editor.next_inline_completion(&Default::default(), window, cx)
+            editor.next_edit_prediction(&Default::default(), window, cx)
        });
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, window, cx| {
@@ -509,8 +497,8 @@ mod tests {
            assert_eq!(editor.text(cx), "fn foo() {\n    \n}");
            assert_eq!(editor.display_text(cx), "fn foo() {\n    let x = 4;\n}");

-            // Using AcceptInlineCompletion again accepts the suggestion.
-            editor.accept_inline_completion(&Default::default(), window, cx);
+            // Using AcceptEditPrediction again accepts the suggestion.
+            editor.accept_edit_prediction(&Default::default(), window, cx);
            assert!(!editor.has_active_inline_completion());
            assert_eq!(editor.text(cx), "fn foo() {\n    let x = 4;\n}");
            assert_eq!(editor.display_text(cx), "fn foo() {\n    let x = 4;\n}");
@@ -539,7 +527,7 @@ mod tests {
        .await;
        let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
        cx.update_editor(|editor, window, cx| {
-            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
+            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
        });

        // Setup the editor with a completion request.
@@ -663,7 +651,7 @@ mod tests {
        .await;
        let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
        cx.update_editor(|editor, window, cx| {
-            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
+            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
        });

        cx.set_state(indoc! {"
@@ -682,7 +670,7 @@ mod tests {
            vec![],
        );
        cx.update_editor(|editor, window, cx| {
-            editor.next_inline_completion(&Default::default(), window, cx)
+            editor.next_edit_prediction(&Default::default(), window, cx)
        });
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, window, cx| {
@@ -753,7 +741,7 @@ mod tests {
        let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
        editor
            .update(cx, |editor, window, cx| {
-                editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
+                editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
            })
            .unwrap();

@@ -771,7 +759,7 @@ mod tests {
            editor.change_selections(None, window, cx, |s| {
                s.select_ranges([Point::new(1, 5)..Point::new(1, 5)])
            });
-            editor.next_inline_completion(&Default::default(), window, cx);
+            editor.next_edit_prediction(&Default::default(), window, cx);
        });
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        _ = editor.update(cx, |editor, _, cx| {
@@ -847,7 +835,7 @@ mod tests {
        .await;
        let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
        cx.update_editor(|editor, window, cx| {
-            editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
+            editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
        });

        cx.set_state(indoc! {"
@@ -875,7 +863,7 @@ mod tests {
            vec![],
        );
        cx.update_editor(|editor, window, cx| {
-            editor.next_inline_completion(&Default::default(), window, cx)
+            editor.next_edit_prediction(&Default::default(), window, cx)
        });
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, _, cx| {
@@ -934,7 +922,6 @@ mod tests {
        executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT);
        cx.update_editor(|editor, _, cx| {
            assert!(editor.context_menu_visible());
-            assert!(!editor.context_menu_contains_inline_completion());
            assert!(!editor.has_active_inline_completion(),);
            assert_eq!(editor.text(cx), "one\ntwo.\nthree\n");
        });
@@ -944,7 +931,7 @@ mod tests {
    async fn test_copilot_disabled_globs(executor: BackgroundExecutor, cx: &mut TestAppContext) {
        init_test(cx, |settings| {
            settings
-                .inline_completions
+                .edit_predictions
                .get_or_insert(Default::default())
                .disabled_globs = Some(vec![".env*".to_string()]);
        });
@@ -953,24 +940,24 @@ mod tests {

        let fs = FakeFs::new(cx.executor());
        fs.insert_tree(
-            "/test",
+            path!("/test"),
            json!({
                ".env": "SECRET=something\n",
                "README.md": "hello\nworld\nhow\nare\nyou\ntoday"
            }),
        )
        .await;
-        let project = Project::test(fs, ["/test".as_ref()], cx).await;
+        let project = Project::test(fs, [path!("/test").as_ref()], cx).await;

        let private_buffer = project
            .update(cx, |project, cx| {
-                project.open_local_buffer("/test/.env", cx)
+                project.open_local_buffer(path!("/test/.env"), cx)
            })
            .await
            .unwrap();
        let public_buffer = project
            .update(cx, |project, cx| {
-                project.open_local_buffer("/test/README.md", cx)
+                project.open_local_buffer(path!("/test/README.md"), cx)
            })
            .await
            .unwrap();
@@ -1006,7 +993,7 @@ mod tests {
        let copilot_provider = cx.new(|_| CopilotCompletionProvider::new(copilot));
        editor
            .update(cx, |editor, window, cx| {
-                editor.set_inline_completion_provider(Some(copilot_provider), window, cx)
+                editor.set_edit_prediction_provider(Some(copilot_provider), window, cx)
            })
            .unwrap();

--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -750,7 +750,7 @@ impl Item for ProjectDiagnosticsEditor {
    }

    fn telemetry_event_text(&self) -> Option<&'static str> {
-        Some("project diagnostics")
+        Some("Project Diagnostics Opened")
    }

    fn for_each_project_item(
@@ -933,7 +933,7 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
                            .when_some(diagnostic.code.as_ref(), |stack, code| {
                                stack.child(
                                    div()
-                                        .child(SharedString::from(format!("({code})")))
+                                        .child(SharedString::from(format!("({code:?})")))
                                        .text_color(color.text_muted),
                                )
                            }),
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg"><circle cx="7.25" cy="7.25" r="3" fill="currentColor"></circle></svg>`
				`@@ -0,0 +1 @@`
				`ALTER TABLE worktree_repositories ADD COLUMN branch_summary TEXT NULL;`