WIP: start using replace blocks for patches

Fix BlockMap::buffer_rows now that we have replacement blocks
Ensure clipping BlockPoints right works correctly
2024-10-24 16:33:15 +02:00 · 2024-10-24 12:41:26 +02:00 · 2024-10-24 12:17:35 +02:00 · 2024-10-24 11:46:14 +02:00 · 2024-10-23 17:08:18 +02:00 · 2024-10-23 14:48:09 +02:00
420 changed files with 12847 additions and 21012 deletions
--- a/.github/actions/run_tests/action.yml
+++ b/.github/actions/run_tests/action.yml
@@ -10,7 +10,7 @@ runs:
        cargo install cargo-nextest

    - name: Install Node
-      uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+      uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
      with:
        node-version: "18"

--- a/.github/workflows/bump_collab_staging.yml
+++ b/.github/workflows/bump_collab_staging.yml
@@ -11,7 +11,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          fetch-depth: 0

--- a/.github/workflows/bump_patch_version.yml
+++ b/.github/workflows/bump_patch_version.yml
@@ -18,7 +18,7 @@ jobs:
      - buildjet-16vcpu-ubuntu-2204
    steps:
      - name: Checkout code
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          ref: ${{ github.event.inputs.branch }}
          ssh-key: ${{ secrets.ZED_BOT_DEPLOY_KEY }}
@@ -43,8 +43,6 @@ jobs:
          esac
          which cargo-set-version > /dev/null || cargo install cargo-edit
          output=$(cargo set-version -p zed --bump patch 2>&1 | sed 's/.* //')
-          export GIT_COMMITTER_NAME="Zed Bot"
-          export GIT_COMMITTER_EMAIL="hi@zed.dev"
          git commit -am "Bump to $output for @$GITHUB_ACTOR" --author "Zed Bot <hi@zed.dev>"
          git tag v${output}${tag_suffix}
          git push origin HEAD v${output}${tag_suffix}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -25,7 +25,6 @@ env:
  CARGO_TERM_COLOR: always
  CARGO_INCREMENTAL: 0
  RUST_BACKTRACE: 1
-  RUSTFLAGS: "-D warnings"

 jobs:
  migration_checks:
@@ -37,7 +36,7 @@ jobs:
      - test
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false
          fetch-depth: 0 # fetch full history
@@ -79,26 +78,25 @@ jobs:
      - buildjet-8vcpu-ubuntu-2204
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4

      - name: Run style checks
        uses: ./.github/actions/check_style

      - name: Check for typos
-        uses: crate-ci/typos@8e6a4285bcbde632c5d79900a7779746e8b7ea3f # v1.24.6
+        uses: crate-ci/typos@v1.24.6
        with:
          config: ./typos.toml

  macos_tests:
    timeout-minutes: 60
    name: (macOS) Run Clippy and tests
-    if: github.repository_owner == 'zed-industries'
    runs-on:
      - self-hosted
      - test
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -117,18 +115,17 @@ jobs:
        uses: ./.github/actions/run_tests

      - name: Build collab
-        run: cargo build -p collab
+        run: RUSTFLAGS="-D warnings" cargo build -p collab

      - name: Build other binaries and features
        run: |
-          cargo build --workspace --bins --all-features
+          RUSTFLAGS="-D warnings" cargo build --workspace --bins --all-features
          cargo check -p gpui --features "macos-blade"
-          cargo build -p remote_server
+          RUSTFLAGS="-D warnings" cargo build -p remote_server

  linux_tests:
    timeout-minutes: 60
    name: (Linux) Run Clippy and tests
-    if: github.repository_owner == 'zed-industries'
    runs-on:
      - buildjet-16vcpu-ubuntu-2204
    steps:
@@ -136,7 +133,7 @@ jobs:
        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH

      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -156,12 +153,11 @@ jobs:
        uses: ./.github/actions/run_tests

      - name: Build Zed
-        run: cargo build -p zed
+        run: RUSTFLAGS="-D warnings" cargo build -p zed

  build_remote_server:
    timeout-minutes: 60
    name: (Linux) Build Remote Server
-    if: github.repository_owner == 'zed-industries'
    runs-on:
      - buildjet-16vcpu-ubuntu-2204
    steps:
@@ -169,7 +165,7 @@ jobs:
        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH

      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -183,20 +179,16 @@ jobs:
        run: ./script/remote-server && ./script/install-mold 2.34.0

      - name: Build Remote Server
-        run: cargo build -p remote_server
+        run: RUSTFLAGS="-D warnings" cargo build -p remote_server

  # todo(windows): Actually run the tests
  windows_tests:
    timeout-minutes: 60
    name: (Windows) Run Clippy and tests
-    if: github.repository_owner == 'zed-industries'
    runs-on: hosted-windows-1
    steps:
-      # 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
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -211,7 +203,7 @@ jobs:
        run: cargo xtask clippy

      - name: Build Zed
-        run: cargo build
+        run: $env:RUSTFLAGS="-D warnings"; cargo build

  bundle-mac:
    timeout-minutes: 60
@@ -232,12 +224,12 @@ jobs:
      DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
    steps:
      - name: Install Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "18"

      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          # We need to fetch more than one commit so that `script/draft-release-notes`
          # is able to diff between the current and previous tag.
@@ -322,7 +314,7 @@ jobs:
      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -369,7 +361,7 @@ jobs:
      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

--- a/.github/workflows/community_update_all_top_ranking_issues.yml
+++ b/.github/workflows/community_update_all_top_ranking_issues.yml
@@ -10,7 +10,7 @@ jobs:
    runs-on: ubuntu-latest
    if: github.repository_owner == 'zed-industries'
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
      - name: Set up uv
        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
        with:
--- a/.github/workflows/community_update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/community_update_weekly_top_ranking_issues.yml
@@ -10,7 +10,7 @@ jobs:
    runs-on: ubuntu-latest
    if: github.repository_owner == 'zed-industries'
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
      - name: Set up uv
        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
        with:
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -14,14 +14,14 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4

      - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
        with:
          version: 9

      - name: Setup Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "20"
          cache: "pnpm"
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -13,7 +13,7 @@ jobs:

    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -37,28 +37,28 @@ jobs:
          mdbook build ./docs --dest-dir=../target/deploy/docs/

      - name: Deploy Docs
-        uses: cloudflare/wrangler-action@b2a0191ce60d21388e1a8dcc968b4e9966f938e1 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # 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@b2a0191ce60d21388e1a8dcc968b4e9966f938e1 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # 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@b2a0191ce60d21388e1a8dcc968b4e9966f938e1 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # 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@b2a0191ce60d21388e1a8dcc968b4e9966f938e1 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
--- a/.github/workflows/deploy_collab.yml
+++ b/.github/workflows/deploy_collab.yml
@@ -17,7 +17,7 @@ jobs:
      - test
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false
          fetch-depth: 0
@@ -36,7 +36,7 @@ jobs:
    needs: style
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false
          fetch-depth: 0
@@ -71,7 +71,7 @@ jobs:
        run: doctl registry login

      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -97,7 +97,7 @@ jobs:

    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -15,7 +15,7 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4

      - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
        with:
@@ -31,7 +31,7 @@ jobs:
          }

      - name: Check for Typos with Typos-CLI
-        uses: crate-ci/typos@8e6a4285bcbde632c5d79900a7779746e8b7ea3f # v1.24.6
+        uses: crate-ci/typos@v1.24.6
        with:
          config: ./typos.toml
          files: ./docs/
--- a/.github/workflows/publish_extension_cli.yml
+++ b/.github/workflows/publish_extension_cli.yml
@@ -16,7 +16,7 @@ jobs:
      - ubuntu-latest
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -22,12 +22,12 @@ jobs:
      - buildjet-16vcpu-ubuntu-2204
    steps:
      - name: Install Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "18"

      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -23,7 +23,7 @@ jobs:
      - test
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false
          fetch-depth: 0
@@ -44,7 +44,7 @@ jobs:
    needs: style
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -70,12 +70,12 @@ jobs:
      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
    steps:
      - name: Install Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "18"

      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -109,7 +109,7 @@ jobs:
      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -149,7 +149,7 @@ jobs:
      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          clean: false

@@ -182,7 +182,7 @@ jobs:
      - bundle-linux-arm
    steps:
      - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4
        with:
          fetch-depth: 0

--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,3 +1,3 @@
 # Code of Conduct

-The Code of Conduct for this repository can be found online at [zed.dev/code-of-conduct](https://zed.dev/code-of-conduct).
+The Code of Conduct for this repository can be found online at [zed.dev/docs/code-of-conduct](https://zed.dev/docs/code-of-conduct).
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,7 +2,7 @@

 Thanks for your interest in contributing to Zed, the collaborative platform that is also a code editor!

-All activity in Zed forums is subject to our [Code of Conduct](https://zed.dev/code-of-conduct). Additionally, contributors must sign our [Contributor License Agreement](https://zed.dev/cla) before their contributions can be merged.
+All activity in Zed forums is subject to our [Code of Conduct](https://zed.dev/docs/code-of-conduct). Additionally, contributors must sign our [Contributor License Agreement](https://zed.dev/cla) before their contributions can be merged.

 ## Contribution ideas

--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,6 +23,7 @@ members = [
    "crates/context_servers",
    "crates/copilot",
    "crates/db",
+    "crates/dev_server_projects",
    "crates/diagnostics",
    "crates/docs_preprocessor",
    "crates/editor",
@@ -30,7 +31,6 @@ members = [
    "crates/extension",
    "crates/extension_api",
    "crates/extension_cli",
-    "crates/extension_host",
    "crates/extensions_ui",
    "crates/feature_flags",
    "crates/feedback",
@@ -45,6 +45,7 @@ members = [
    "crates/google_ai",
    "crates/gpui",
    "crates/gpui_macros",
+    "crates/headless",
    "crates/html_to_markdown",
    "crates/http_client",
    "crates/image_viewer",
@@ -118,7 +119,6 @@ members = [
    "crates/theme_selector",
    "crates/time_format",
    "crates/title_bar",
-    "crates/toolchain_selector",
    "crates/ui",
    "crates/ui_input",
    "crates/ui_macros",
@@ -139,6 +139,7 @@ members = [
    "extensions/astro",
    "extensions/clojure",
    "extensions/csharp",
+    "extensions/dart",
    "extensions/deno",
    "extensions/elixir",
    "extensions/elm",
@@ -200,10 +201,10 @@ command_palette_hooks = { path = "crates/command_palette_hooks" }
 context_servers = { path = "crates/context_servers" }
 copilot = { path = "crates/copilot" }
 db = { path = "crates/db" }
+dev_server_projects = { path = "crates/dev_server_projects" }
 diagnostics = { path = "crates/diagnostics" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
-extension_host = { path = "crates/extension_host" }
 extensions_ui = { path = "crates/extensions_ui" }
 feature_flags = { path = "crates/feature_flags" }
 feedback = { path = "crates/feedback" }
@@ -218,6 +219,7 @@ go_to_line = { path = "crates/go_to_line" }
 google_ai = { path = "crates/google_ai" }
 gpui = { path = "crates/gpui", default-features = false, features = ["http_client"]}
 gpui_macros = { path = "crates/gpui_macros" }
+headless = { path = "crates/headless" }
 html_to_markdown = { path = "crates/html_to_markdown" }
 http_client = { path = "crates/http_client" }
 image_viewer = { path = "crates/image_viewer" }
@@ -292,7 +294,6 @@ theme_importer = { path = "crates/theme_importer" }
 theme_selector = { path = "crates/theme_selector" }
 time_format = { path = "crates/time_format" }
 title_bar = { path = "crates/title_bar" }
-toolchain_selector = { path = "crates/toolchain_selector" }
 ui = { path = "crates/ui" }
 ui_input = { path = "crates/ui_input" }
 ui_macros = { path = "crates/ui_macros" }
@@ -372,7 +373,6 @@ linkify = "0.10.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
-nbformat = "0.3.2"
 nix = "0.29"
 num-format = "0.4.4"
 once_cell = "1.19.0"
@@ -380,11 +380,6 @@ ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
 pathdiff = "0.2"
-pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c" }
-pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
-pet-core = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
-pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
-pet-reporter = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
 postage = { version = "0.5", features = ["futures-traits"] }
 pretty_assertions = "1.3.0"
 profiling = "1"
@@ -393,7 +388,6 @@ prost-build = "0.9"
 prost-types = "0.9"
 pulldown-cmark = { version = "0.12.0", default-features = false }
 rand = "0.8.5"
-rayon = "1.8"
 regex = "1.5"
 repair_json = "0.1.0"
 reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f6998da16bbca97b6dddda9be7827c50e29", default-features = false, features = [
@@ -405,7 +399,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f
    "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { version = "0.16.1", default-features = false, features = [
+runtimelib = { version = "0.15", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
@@ -474,7 +468,7 @@ tree-sitter-typescript = "0.23"
 tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml", rev = "baff0b51c64ef6a1fb1f8390f3ad6015b83ec13a" }
 unicase = "2.6"
 unindent = "0.1.7"
-unicode-segmentation = "1.10"
+unicode-segmentation = "1.11"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "serde"] }
 wasmparser = "0.215"
--- a/assets/icons/file_icons/file_types.json
+++ b/assets/icons/file_icons/file_types.json
@@ -58,7 +58,6 @@
    "gitignore": "vcs",
    "gitkeep": "vcs",
    "gitmodules": "vcs",
-    "gleam": "gleam",
    "go": "go",
    "gql": "graphql",
    "graphql": "graphql",
@@ -84,7 +83,6 @@
    "j2k": "image",
    "java": "java",
    "jfif": "image",
-    "jl": "julia",
    "jp2": "image",
    "jpeg": "image",
    "jpg": "image",
@@ -92,6 +90,7 @@
    "json": "storage",
    "jsonc": "storage",
    "jsx": "react",
+    "julia": "julia",
    "jxl": "image",
    "kt": "kotlin",
    "ldf": "storage",
@@ -265,9 +264,6 @@
    "fsharp": {
      "icon": "icons/file_icons/fsharp.svg"
    },
-    "gleam": {
-      "icon": "icons/file_icons/gleam.svg"
-    },
    "go": {
      "icon": "icons/file_icons/go.svg"
    },
--- a/assets/icons/file_icons/gleam.svg
+++ b/assets/icons/file_icons/gleam.svg
@@ -1,7 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7.3848 9.30444C7.3848 9.30444 7.53254 10.2646 8.53248 10.0882C9.53242 9.91193 9.36378 8.95549 9.36378 8.95549" stroke="black" stroke-width="1.25" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M5.54155 5.54157C6.12355 4.90104 6.01688 2.62541 7.22875 2.3985C8.44063 2.17158 9.19097 4.33148 9.91982 4.6814C10.6487 5.03133 12.8517 4.3028 13.4381 5.38734C14.0244 6.47188 12.1395 7.95973 12.026 8.64088C11.9126 9.32203 13.3614 11.2416 12.4675 12.1701C11.5736 13.0986 9.73005 11.7545 8.90486 11.8834C8.07966 12.0123 6.79244 13.9095 5.67367 13.3502C4.55491 12.7909 5.16702 10.5455 4.82437 9.87612C4.48171 9.20673 2.34028 8.54978 2.4525 7.35049C2.56471 6.15121 4.95956 6.1821 5.54155 5.54157Z" stroke="#FF7676" stroke-opacity="0.52" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M5.54155 5.54157C6.12355 4.90104 6.01688 2.62541 7.22875 2.3985C8.44063 2.17158 9.19097 4.33148 9.91982 4.6814C10.6487 5.03133 12.8517 4.3028 13.4381 5.38734C14.0244 6.47188 12.1395 7.95973 12.026 8.64088C11.9126 9.32203 13.3614 11.2416 12.4675 12.1701C11.5736 13.0986 9.73005 11.7545 8.90486 11.8834C8.07966 12.0123 6.79244 13.9095 5.67367 13.3502C4.55491 12.7909 5.16702 10.5455 4.82437 9.87612C4.48171 9.20673 2.34028 8.54978 2.4525 7.35049C2.56471 6.15121 4.95956 6.1821 5.54155 5.54157Z" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
-<circle cx="6.25098" cy="7.75" r="0.75" fill="black"/>
-<circle cx="10.1035" cy="7.25" r="0.75" fill="black"/>
-</svg>
--- a/assets/icons/list_x.svg
+++ b/assets/icons/list_x.svg
@@ -1,7 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8.33333 8H3" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M11.6667 4H3" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M11.6667 12H3" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M13.6667 6.66663L11 9.33329" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M11 6.66663L13.6667 9.33329" stroke="#FBF1C7" stroke-linecap="round" stroke-linejoin="round"/>
-</svg>
--- a/assets/icons/wand.svg
+++ b/assets/icons/wand.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-wand"><path d="M15 4V2"/><path d="M15 16v-2"/><path d="M8 9h2"/><path d="M20 9h2"/><path d="M17.8 11.8 19 13"/><path d="M15 9h.01"/><path d="M17.8 6.2 19 5"/><path d="m3 21 9-9"/><path d="M12.2 6.2 11 5"/></svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -313,15 +313,6 @@
      "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-0": "editor::FoldAll",
      "ctrl-k ctrl-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
@@ -514,13 +505,6 @@
      "ctrl-enter": "assistant::InlineAssist"
    }
  },
-  {
-    "context": "ProposedChangesEditor",
-    "bindings": {
-      "ctrl-shift-y": "editor::ApplyDiffHunk",
-      "ctrl-alt-a": "editor::ApplyAllDiffHunks"
-    }
-  },
  {
    "context": "Editor && jupyter && !ContextEditor",
    "bindings": {
@@ -532,7 +516,6 @@
    "context": "ContextEditor > Editor",
    "bindings": {
      "ctrl-enter": "assistant::Assist",
-      "ctrl-shift-enter": "assistant::Edit",
      "ctrl-s": "workspace::Save",
      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -201,7 +201,6 @@
    "context": "ContextEditor > Editor",
    "bindings": {
      "cmd-enter": "assistant::Assist",
-      "cmd-shift-enter": "assistant::Edit",
      "cmd-s": "workspace::Save",
      "cmd->": "assistant::QuoteSelection",
      "cmd-<": "assistant::InsertIntoEditor",
@@ -351,15 +350,6 @@
      "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-0": "editor::FoldAll",
      "cmd-k cmd-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
@@ -548,13 +538,6 @@
      "ctrl-enter": "assistant::InlineAssist"
    }
  },
-  {
-    "context": "ProposedChangesEditor",
-    "bindings": {
-      "cmd-shift-y": "editor::ApplyDiffHunk",
-      "cmd-shift-a": "editor::ApplyAllDiffHunks"
-    }
-  },
  {
    "context": "PromptEditor",
    "bindings": {
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -157,6 +157,51 @@
      "7": ["vim::Number", 7],
      "8": ["vim::Number", 8],
      "9": ["vim::Number", 9],
+      // 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 h": ["workspace::ActivatePaneInDirection", "Left"],
+      "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
+      "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
+      "ctrl-w j": ["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 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 g t": "pane::ActivateNextItem",
+      "ctrl-w ctrl-g t": "pane::ActivateNextItem",
+      "ctrl-w g shift-t": "pane::ActivatePrevItem",
+      "ctrl-w ctrl-g shift-t": "pane::ActivatePrevItem",
+      "ctrl-w w": "workspace::ActivateNextPane",
+      "ctrl-w ctrl-w": "workspace::ActivateNextPane",
+      "ctrl-w p": "workspace::ActivatePreviousPane",
+      "ctrl-w ctrl-p": "workspace::ActivatePreviousPane",
+      "ctrl-w shift-w": "workspace::ActivatePreviousPane",
+      "ctrl-w ctrl-shift-w": "workspace::ActivatePreviousPane",
+      "ctrl-w v": "pane::SplitVertical",
+      "ctrl-w ctrl-v": "pane::SplitVertical",
+      "ctrl-w s": "pane::SplitHorizontal",
+      "ctrl-w shift-s": "pane::SplitHorizontal",
+      "ctrl-w ctrl-s": "pane::SplitHorizontal",
+      "ctrl-w c": "pane::CloseAllItems",
+      "ctrl-w ctrl-c": "pane::CloseAllItems",
+      "ctrl-w q": "pane::CloseAllItems",
+      "ctrl-w ctrl-q": "pane::CloseAllItems",
+      "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
+      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
+      "ctrl-w n": "workspace::NewFileSplitHorizontal",
+      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal",
      "ctrl-w d": "editor::GoToDefinitionSplit",
      "ctrl-w g d": "editor::GoToDefinitionSplit",
      "ctrl-w shift-d": "editor::GoToTypeDefinitionSplit",
@@ -294,10 +339,6 @@
      "ctrl-t": "vim::Indent",
      "ctrl-d": "vim::Outdent",
      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "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"],
      "insert": "vim::ToggleReplace"
    }
@@ -316,10 +357,6 @@
      "ctrl-c": "vim::NormalBefore",
      "ctrl-[": "vim::NormalBefore",
      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "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": {} }],
      "backspace": "vim::UndoReplace",
      "tab": "vim::Tab",
      "enter": "vim::Enter",
@@ -334,9 +371,7 @@
      "escape": "vim::ClearOperators",
      "ctrl-c": "vim::ClearOperators",
      "ctrl-[": "vim::ClearOperators",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }]
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }]
    }
  },
  {
@@ -450,49 +485,6 @@
      "c": "vim::CurrentLine"
    }
  },
-  {
-    "context": "vim_mode == literal",
-    "bindings": {
-      "ctrl-@": ["vim::Literal", ["ctrl-@", "\u0000"]],
-      "ctrl-a": ["vim::Literal", ["ctrl-a", "\u0001"]],
-      "ctrl-b": ["vim::Literal", ["ctrl-b", "\u0002"]],
-      "ctrl-c": ["vim::Literal", ["ctrl-c", "\u0003"]],
-      "ctrl-d": ["vim::Literal", ["ctrl-d", "\u0004"]],
-      "ctrl-e": ["vim::Literal", ["ctrl-e", "\u0005"]],
-      "ctrl-f": ["vim::Literal", ["ctrl-f", "\u0006"]],
-      "ctrl-g": ["vim::Literal", ["ctrl-g", "\u0007"]],
-      "ctrl-h": ["vim::Literal", ["ctrl-h", "\u0008"]],
-      "ctrl-i": ["vim::Literal", ["ctrl-i", "\u0009"]],
-      "ctrl-j": ["vim::Literal", ["ctrl-j", "\u000A"]],
-      "ctrl-k": ["vim::Literal", ["ctrl-k", "\u000B"]],
-      "ctrl-l": ["vim::Literal", ["ctrl-l", "\u000C"]],
-      "ctrl-m": ["vim::Literal", ["ctrl-m", "\u000D"]],
-      "ctrl-n": ["vim::Literal", ["ctrl-n", "\u000E"]],
-      "ctrl-o": ["vim::Literal", ["ctrl-o", "\u000F"]],
-      "ctrl-p": ["vim::Literal", ["ctrl-p", "\u0010"]],
-      "ctrl-q": ["vim::Literal", ["ctrl-q", "\u0011"]],
-      "ctrl-r": ["vim::Literal", ["ctrl-r", "\u0012"]],
-      "ctrl-s": ["vim::Literal", ["ctrl-s", "\u0013"]],
-      "ctrl-t": ["vim::Literal", ["ctrl-t", "\u0014"]],
-      "ctrl-u": ["vim::Literal", ["ctrl-u", "\u0015"]],
-      "ctrl-v": ["vim::Literal", ["ctrl-v", "\u0016"]],
-      "ctrl-w": ["vim::Literal", ["ctrl-w", "\u0017"]],
-      "ctrl-x": ["vim::Literal", ["ctrl-x", "\u0018"]],
-      "ctrl-y": ["vim::Literal", ["ctrl-y", "\u0019"]],
-      "ctrl-z": ["vim::Literal", ["ctrl-z", "\u001A"]],
-      "ctrl-[": ["vim::Literal", ["ctrl-[", "\u001B"]],
-      "ctrl-\\": ["vim::Literal", ["ctrl-\\", "\u001C"]],
-      "ctrl-]": ["vim::Literal", ["ctrl-]", "\u001D"]],
-      "ctrl-^": ["vim::Literal", ["ctrl-^", "\u001E"]],
-      "ctrl-_": ["vim::Literal", ["ctrl-_", "\u001F"]],
-      "escape": ["vim::Literal", ["escape", "\u001B"]],
-      "enter": ["vim::Literal", ["enter", "\u000D"]],
-      "tab": ["vim::Literal", ["tab", "\u0009"]],
-      // zed extensions:
-      "backspace": ["vim::Literal", ["backspace", "\u0008"]],
-      "delete": ["vim::Literal", ["delete", "\u007F"]]
-    }
-  },
  {
    "context": "BufferSearchBar && !in_replace",
    "bindings": {
@@ -501,57 +493,7 @@
    }
  },
  {
-    "context": "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 h": ["workspace::ActivatePaneInDirection", "Left"],
-      "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
-      "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
-      "ctrl-w j": ["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 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 g t": "pane::ActivateNextItem",
-      "ctrl-w ctrl-g t": "pane::ActivateNextItem",
-      "ctrl-w g shift-t": "pane::ActivatePrevItem",
-      "ctrl-w ctrl-g shift-t": "pane::ActivatePrevItem",
-      "ctrl-w w": "workspace::ActivateNextPane",
-      "ctrl-w ctrl-w": "workspace::ActivateNextPane",
-      "ctrl-w p": "workspace::ActivatePreviousPane",
-      "ctrl-w ctrl-p": "workspace::ActivatePreviousPane",
-      "ctrl-w shift-w": "workspace::ActivatePreviousPane",
-      "ctrl-w ctrl-shift-w": "workspace::ActivatePreviousPane",
-      "ctrl-w v": "pane::SplitVertical",
-      "ctrl-w ctrl-v": "pane::SplitVertical",
-      "ctrl-w s": "pane::SplitHorizontal",
-      "ctrl-w shift-s": "pane::SplitHorizontal",
-      "ctrl-w ctrl-s": "pane::SplitHorizontal",
-      "ctrl-w c": "pane::CloseAllItems",
-      "ctrl-w ctrl-c": "pane::CloseAllItems",
-      "ctrl-w q": "pane::CloseAllItems",
-      "ctrl-w ctrl-q": "pane::CloseAllItems",
-      "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-w n": "workspace::NewFileSplitHorizontal",
-      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal"
-    }
-  },
-  {
-    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
+    "context": "EmptyPane || SharedScreen",
    "bindings": {
      ":": "command_palette::Toggle",
      "g /": "pane::DeploySearch"
--- a/assets/prompts/edit_workflow.hbs
+++ b/assets/prompts/edit_workflow.hbs
@@ -88,6 +88,7 @@ origin: (f64, f64),

 <edit>
 <path>src/shapes/rectangle.rs</path>
+<description>Update the Rectangle's new function to take an origin parameter</description>
 <operation>update</operation>
 <old_text>
 fn new(width: f64, height: f64) -> Self {
@@ -116,6 +117,7 @@ pub struct Circle {

 <edit>
 <path>src/shapes/circle.rs</path>
+<description>Update the Circle's new function to take an origin parameter</description>
 <operation>update</operation>
 <old_text>
 fn new(radius: f64) -> Self {
@@ -132,6 +134,7 @@ fn new(origin: (f64, f64), radius: f64) -> Self {

 <edit>
 <path>src/shapes/rectangle.rs</path>
+<description>Add an import for the std::fmt module</description>
 <operation>insert_before</operation>
 <old_text>
 struct Rectangle {
@@ -144,10 +147,7 @@ use std::fmt;

 <edit>
 <path>src/shapes/rectangle.rs</path>
-<description>
-Add a manual Display implementation for Rectangle.
-Currently, this is the same as a derived Display implementation.
-</description>
+<description>Add a Display implementation for Rectangle</description>
 <operation>insert_after</operation>
 <old_text>
        Rectangle { width, height }
@@ -169,6 +169,7 @@ impl fmt::Display for Rectangle {

 <edit>
 <path>src/shapes/circle.rs</path>
+<description>Add an import for the `std::fmt` module</description>
 <operation>insert_before</operation>
 <old_text>
 struct Circle {
@@ -180,6 +181,7 @@ use std::fmt;

 <edit>
 <path>src/shapes/circle.rs</path>
+<description>Add a Display implementation for Circle</description>
 <operation>insert_after</operation>
 <old_text>
        Circle { radius }
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -369,17 +369,6 @@
      /// 5. Never show the scrollbar:
      ///    "never"
      "show": null
-    },
-    // Settings related to indent guides in the project panel.
-    "indent_guides": {
-      // When to show indent guides in the project panel.
-      // This setting can take two values:
-      //
-      // 1. Always show indent guides:
-      //    "always"
-      // 2. Never show indent guides:
-      //    "never"
-      "show": "always"
    }
  },
  "outline_panel": {
@@ -403,35 +392,7 @@
    "auto_reveal_entries": true,
    /// Whether to fold directories automatically
    /// when a directory has only one directory inside.
-    "auto_fold_dirs": true,
-    // Settings related to indent guides in the outline panel.
-    "indent_guides": {
-      // When to show indent guides in the outline panel.
-      // This setting can take two values:
-      //
-      // 1. Always show indent guides:
-      //    "always"
-      // 2. Never show indent guides:
-      //    "never"
-      "show": "always"
-    },
-    /// Scrollbar-related settings
-    "scrollbar": {
-      /// When to show the scrollbar in the project panel.
-      /// This setting can take four values:
-      ///
-      /// 1. null (default): Inherit editor settings
-      /// 2. Show the scrollbar if there's important information or
-      ///    follow the system's configured behavior (default):
-      ///   "auto"
-      /// 3. Match the system's configured behavior:
-      ///    "system"
-      /// 4. Always show the scrollbar:
-      ///    "always"
-      /// 5. Never show the scrollbar:
-      ///    "never"
-      "show": null
-    }
+    "auto_fold_dirs": true
  },
  "collaboration_panel": {
    // Whether to show the collaboration panel button in the status bar.
@@ -652,12 +613,6 @@
      // Sets a delay after which the inline blame information is shown.
      // Delay is restarted with every cursor movement.
      // "delay_ms": 600
-      //
-      // Whether or not do display the git commit summary on the same line.
-      // "show_commit_summary": false
-      //
-      // The minimum column number to show the inline blame information at
-      // "min_column": 0
    }
  },
  // Configuration for how direnv configuration should be loaded. May take 2 values:
@@ -820,7 +775,6 @@
  "tasks": {
    "variables": {}
  },
-  "toolchain": { "name": "default", "path": "default" },
  // An object whose keys are language names, and whose values
  // are arrays of filenames or extensions of files that should
  // use those languages.
@@ -849,7 +803,7 @@
  /// You can override this to use a version of node that is not in $PATH with:
  /// {
  ///   "node": {
-  ///     "path": "/path/to/node"
+  ///     "node_path": "/path/to/node"
  ///     "npm_path": "/path/to/npm" (defaults to node_path/../npm)
  ///   }
  /// }
@@ -1145,13 +1099,13 @@
  // }
  "command_aliases": {},
  // ssh_connections is an array of ssh connections.
+  // By default this setting is null, which disables the direct ssh connection support.
  // You can configure these from `project: Open Remote` in the command palette.
  // Zed's ssh support will pull configuration from your ~/.ssh too.
  // Examples:
  // [
  //   {
  //     "host": "example-box",
-  //     // "port": 22, "username": "test", "args": ["-i", "/home/user/.ssh/id_rsa"]
  //     "projects": [
  //       {
  //         "paths": ["/home/user/code/zed"]
@@ -1159,7 +1113,7 @@
  //     ]
  //   }
  // ]
-  "ssh_connections": [],
+  "ssh_connections": null,
  // Configures the Context Server Protocol binaries
  //
  // Examples:
--- a/assets/settings/initial_tasks.json
+++ b/assets/settings/initial_tasks.json
@@ -16,7 +16,6 @@
    "allow_concurrent_runs": false,
    // What to do with the terminal pane and tab, after the command was started:
    // * `always` — always show the terminal pane, add and focus the corresponding task's tab in it (default)
-    // * `no_focus` — always show the terminal pane, add/reuse the task's tab there, but don't focus it
    // * `never` — avoid changing current terminal pane focus, but still add/reuse the task's tab there
    "reveal": "always",
    // What to do with the terminal pane and tab, after the command had finished:
--- a/crates/activity_indicator/Cargo.toml
+++ b/crates/activity_indicator/Cargo.toml
@@ -16,14 +16,13 @@ doctest = false
 anyhow.workspace = true
 auto_update.workspace = true
 editor.workspace = true
-extension_host.workspace = true
+extension.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 project.workspace = true
 smallvec.workspace = true
 ui.workspace = true
-util.workspace = true
 workspace.workspace = true

 [dev-dependencies]
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -1,6 +1,6 @@
 use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
 use editor::Editor;
-use extension_host::ExtensionStore;
+use extension::ExtensionStore;
 use futures::StreamExt;
 use gpui::{
    actions, percentage, Animation, AnimationExt as _, AppContext, CursorStyle, EventEmitter,
@@ -13,8 +13,7 @@ use language::{
 use project::{EnvironmentErrorMessage, LanguageServerProgress, Project, WorktreeId};
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
-use ui::{prelude::*, ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip};
-use util::truncate_and_trailoff;
+use ui::{prelude::*, ButtonLike, ContextMenu, PopoverMenu, PopoverMenuHandle};
 use workspace::{item::ItemHandle, StatusItemView, Workspace};

 actions!(activity_indicator, [ShowErrorMessage]);
@@ -352,10 +351,7 @@ impl ActivityIndicator {
                        .into_any_element(),
                ),
                message: format!("Formatting failed: {}. Click to see logs.", failure),
-                on_click: Some(Arc::new(|indicator, cx| {
-                    indicator.project.update(cx, |project, cx| {
-                        project.reset_last_formatting_failure(cx);
-                    });
+                on_click: Some(Arc::new(|_, cx| {
                    cx.dispatch_action(Box::new(workspace::OpenLog));
                })),
            });
@@ -450,8 +446,6 @@ impl ActivityIndicator {

 impl EventEmitter<Event> for ActivityIndicator {}

-const MAX_MESSAGE_LEN: usize = 50;
-
 impl Render for ActivityIndicator {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let result = h_flex()
@@ -462,7 +456,6 @@ impl Render for ActivityIndicator {
            return result;
        };
        let this = cx.view().downgrade();
-        let truncate_content = content.message.len() > MAX_MESSAGE_LEN;
        result.gap_2().child(
            PopoverMenu::new("activity-indicator-popover")
                .trigger(
@@ -471,21 +464,7 @@ impl Render for ActivityIndicator {
                            .id("activity-indicator-status")
                            .gap_2()
                            .children(content.icon)
-                            .map(|button| {
-                                if truncate_content {
-                                    button
-                                        .child(
-                                            Label::new(truncate_and_trailoff(
-                                                &content.message,
-                                                MAX_MESSAGE_LEN,
-                                            ))
-                                            .size(LabelSize::Small),
-                                        )
-                                        .tooltip(move |cx| Tooltip::text(&content.message, cx))
-                                } else {
-                                    button.child(Label::new(content.message).size(LabelSize::Small))
-                                }
-                            })
+                            .child(Label::new(content.message).size(LabelSize::Small))
                            .when_some(content.on_click, |this, handler| {
                                this.on_click(cx.listener(move |this, _, cx| {
                                    handler(this, cx);
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -29,13 +29,13 @@ pub struct AnthropicModelCacheConfiguration {
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
 pub enum Model {
    #[default]
-    #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-latest")]
+    #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-20240620")]
    Claude3_5Sonnet,
-    #[serde(rename = "claude-3-opus", alias = "claude-3-opus-latest")]
+    #[serde(rename = "claude-3-opus", alias = "claude-3-opus-20240229")]
    Claude3Opus,
-    #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-latest")]
+    #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-20240229")]
    Claude3Sonnet,
-    #[serde(rename = "claude-3-haiku", alias = "claude-3-haiku-latest")]
+    #[serde(rename = "claude-3-haiku", alias = "claude-3-haiku-20240307")]
    Claude3Haiku,
    #[serde(rename = "custom")]
    Custom {
@@ -69,10 +69,10 @@ impl Model {

    pub fn id(&self) -> &str {
        match self {
-            Model::Claude3_5Sonnet => "claude-3-5-sonnet-latest",
-            Model::Claude3Opus => "claude-3-opus-latest",
-            Model::Claude3Sonnet => "claude-3-sonnet-latest",
-            Model::Claude3Haiku => "claude-3-haiku-latest",
+            Model::Claude3_5Sonnet => "claude-3-5-sonnet-20240620",
+            Model::Claude3Opus => "claude-3-opus-20240229",
+            Model::Claude3Sonnet => "claude-3-sonnet-20240229",
+            Model::Claude3Haiku => "claude-3-haiku-20240307",
            Self::Custom { name, .. } => name,
        }
    }
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -41,24 +41,24 @@ use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
+use slash_command::workflow_command::WorkflowSlashCommand;
 use slash_command::{
    auto_command, cargo_workspace_command, context_server_command, default_command, delta_command,
    diagnostics_command, docs_command, fetch_command, file_command, now_command, project_command,
    prompt_command, search_command, symbols_command, tab_command, terminal_command,
+    workflow_command,
 };
 use std::path::PathBuf;
 use std::sync::Arc;
 pub(crate) use streaming_diff::*;
 use util::ResultExt;

-use crate::slash_command::streaming_example_command;
 use crate::slash_command_settings::SlashCommandSettings;

 actions!(
    assistant,
    [
        Assist,
-        Edit,
        Split,
        CopyCode,
        CycleMessageRole,
@@ -298,64 +298,25 @@ fn register_context_server_handlers(cx: &mut AppContext) {
                                    return;
                                };

-                                if protocol.capable(context_servers::protocol::ServerCapability::Prompts) {
-                                    if let Some(prompts) = protocol.list_prompts().await.log_err() {
-                                        for prompt in prompts
-                                            .into_iter()
-                                            .filter(context_server_command::acceptable_prompt)
-                                        {
-                                            log::info!(
-                                                "registering context server command: {:?}",
-                                                prompt.name
-                                            );
-                                            context_server_registry.register_command(
-                                                server.id.clone(),
-                                                prompt.name.as_str(),
-                                            );
-                                            slash_command_registry.register_command(
-                                                context_server_command::ContextServerSlashCommand::new(
-                                                    &server, prompt,
-                                                ),
-                                                true,
-                                            );
-                                        }
-                                    }
-                                }
-                            })
-                            .detach();
-                        }
-                    },
-                );
-
-                cx.update_model(
-                    &manager,
-                    |manager: &mut context_servers::manager::ContextServerManager, cx| {
-                        let tool_registry = ToolRegistry::global(cx);
-                        let context_server_registry = ContextServerRegistry::global(cx);
-                        if let Some(server) = manager.get_server(server_id) {
-                            cx.spawn(|_, _| async move {
-                                let Some(protocol) = server.client.read().clone() else {
-                                    return;
-                                };
-
-                                if protocol.capable(context_servers::protocol::ServerCapability::Tools) {
-                                    if let Some(tools) = protocol.list_tools().await.log_err() {
-                                        for tool in tools.tools {
-                                            log::info!(
-                                                "registering context server tool: {:?}",
-                                                tool.name
-                                            );
-                                            context_server_registry.register_tool(
-                                                server.id.clone(),
-                                                tool.name.as_str(),
-                                            );
-                                            tool_registry.register_tool(
-                                                tools::context_server_tool::ContextServerTool::new(
-                                                    server.id.clone(),
-                                                    tool
-                                                ),
-                                            );
-                                        }
+                                if let Some(prompts) = protocol.list_prompts().await.log_err() {
+                                    for prompt in prompts
+                                        .into_iter()
+                                        .filter(context_server_command::acceptable_prompt)
+                                    {
+                                        log::info!(
+                                            "registering context server command: {:?}",
+                                            prompt.name
+                                        );
+                                        context_server_registry.register_command(
+                                            server.id.clone(),
+                                            prompt.name.as_str(),
+                                        );
+                                        slash_command_registry.register_command(
+                                            context_server_command::ContextServerSlashCommand::new(
+                                                &server, prompt,
+                                            ),
+                                            true,
+                                        );
                                    }
                                }
                            })
@@ -373,14 +334,6 @@ fn register_context_server_handlers(cx: &mut AppContext) {
                        context_server_registry.unregister_command(&server_id, &command_name);
                    }
                }
-
-                if let Some(tools) = context_server_registry.get_tools(server_id) {
-                    let tool_registry = ToolRegistry::global(cx);
-                    for tool_name in tools {
-                        tool_registry.unregister_tool_by_name(&tool_name);
-                        context_server_registry.unregister_tool(&server_id, &tool_name);
-                    }
-                }
            }
        },
    )
@@ -444,6 +397,22 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
    slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);

    if let Some(prompt_builder) = prompt_builder {
+        cx.observe_global::<SettingsStore>({
+            let slash_command_registry = slash_command_registry.clone();
+            let prompt_builder = prompt_builder.clone();
+            move |cx| {
+                if AssistantSettings::get_global(cx).are_live_diffs_enabled(cx) {
+                    slash_command_registry.register_command(
+                        workflow_command::WorkflowSlashCommand::new(prompt_builder.clone()),
+                        true,
+                    );
+                } else {
+                    slash_command_registry.unregister_command_by_name(WorkflowSlashCommand::NAME);
+                }
+            }
+        })
+        .detach();
+
        cx.observe_flag::<project_command::ProjectSlashCommandFeatureFlag, _>({
            let slash_command_registry = slash_command_registry.clone();
            move |is_enabled, _cx| {
@@ -469,19 +438,6 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
    })
    .detach();

-    cx.observe_flag::<streaming_example_command::StreamingExampleSlashCommandFeatureFlag, _>({
-        let slash_command_registry = slash_command_registry.clone();
-        move |is_enabled, _cx| {
-            if is_enabled {
-                slash_command_registry.register_command(
-                    streaming_example_command::StreamingExampleSlashCommand,
-                    false,
-                );
-            }
-        }
-    })
-    .detach();
-
    update_slash_commands_from_settings(cx);
    cx.observe_global::<SettingsStore>(update_slash_commands_from_settings)
        .detach();
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -13,11 +13,10 @@ use crate::{
    terminal_inline_assistant::TerminalInlineAssistant,
    Assist, AssistantPatch, AssistantPatchStatus, CacheStatus, ConfirmCommand, Content, Context,
    ContextEvent, ContextId, ContextStore, ContextStoreEvent, CopyCode, CycleMessageRole,
-    DeployHistory, DeployPromptLibrary, Edit, InlineAssistant, InsertDraggedFiles,
-    InsertIntoEditor, Message, MessageId, MessageMetadata, MessageStatus, ModelPickerDelegate,
-    ModelSelector, NewContext, PendingSlashCommand, PendingSlashCommandStatus, QuoteSelection,
-    RemoteContextMetadata, RequestType, SavedContextMetadata, Split, ToggleFocus,
-    ToggleModelSelector,
+    DeployHistory, DeployPromptLibrary, InlineAssistant, InsertDraggedFiles, InsertIntoEditor,
+    Message, MessageId, MessageMetadata, MessageStatus, ModelPickerDelegate, ModelSelector,
+    NewContext, PendingSlashCommand, PendingSlashCommandStatus, QuoteSelection,
+    RemoteContextMetadata, SavedContextMetadata, Split, ToggleFocus, ToggleModelSelector,
 };
 use anyhow::Result;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection};
@@ -73,11 +72,12 @@ use std::{
 };
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
 use text::SelectionGoal;
+use ui::TintColor;
 use ui::{
    prelude::*,
    utils::{format_distance_from_now, DateTimeType},
    Avatar, ButtonLike, ContextMenu, Disclosure, ElevationIndex, KeyBinding, ListItem,
-    ListItemSpacing, PopoverMenu, PopoverMenuHandle, TintColor, Tooltip,
+    ListItemSpacing, PopoverMenu, PopoverMenuHandle, Tooltip,
 };
 use util::{maybe, ResultExt};
 use workspace::{
@@ -963,7 +963,7 @@ impl AssistantPanel {

    fn new_context(&mut self, cx: &mut ViewContext<Self>) -> Option<View<ContextEditor>> {
        let project = self.project.read(cx);
-        if project.is_via_collab() {
+        if project.is_via_collab() && project.dev_server_project_id().is_none() {
            let task = self
                .context_store
                .update(cx, |store, cx| store.create_remote_context(cx));
@@ -1446,8 +1446,8 @@ struct ScrollPosition {
 }

 struct PatchViewState {
-    footer_block_id: CustomBlockId,
-    crease_id: CreaseId,
+    block_id: CustomBlockId,
+    // crease_id: CreaseId,
    editor: Option<PatchEditorState>,
    update_task: Option<Task<()>>,
 }
@@ -1461,7 +1461,6 @@ type MessageHeader = MessageMetadata;

 #[derive(Clone)]
 enum AssistError {
-    FileRequired,
    PaymentRequired,
    MaxMonthlySpendReached,
    Message(SharedString),
@@ -1589,11 +1588,23 @@ impl ContextEditor {
    }

    fn assist(&mut self, _: &Assist, cx: &mut ViewContext<Self>) {
-        self.send_to_model(RequestType::Chat, cx);
-    }
+        let provider = LanguageModelRegistry::read_global(cx).active_provider();
+        if provider
+            .as_ref()
+            .map_or(false, |provider| provider.must_accept_terms(cx))
+        {
+            self.show_accept_terms = true;
+            cx.notify();
+            return;
+        }

-    fn edit(&mut self, _: &Edit, cx: &mut ViewContext<Self>) {
-        self.send_to_model(RequestType::SuggestEdits, cx);
+        if self.focus_active_patch(cx) {
+            return;
+        }
+
+        self.last_error = None;
+        self.send_to_model(cx);
+        cx.notify();
    }

    fn focus_active_patch(&mut self, cx: &mut ViewContext<Self>) -> bool {
@@ -1611,30 +1622,8 @@ impl ContextEditor {
        false
    }

-    fn send_to_model(&mut self, request_type: RequestType, cx: &mut ViewContext<Self>) {
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
-        if provider
-            .as_ref()
-            .map_or(false, |provider| provider.must_accept_terms(cx))
-        {
-            self.show_accept_terms = true;
-            cx.notify();
-            return;
-        }
-
-        if self.focus_active_patch(cx) {
-            return;
-        }
-
-        self.last_error = None;
-
-        if request_type == RequestType::SuggestEdits && !self.context.read(cx).contains_files(cx) {
-            self.last_error = Some(AssistError::FileRequired);
-            cx.notify();
-        } else if let Some(user_message) = self
-            .context
-            .update(cx, |context, cx| context.assist(request_type, cx))
-        {
+    fn send_to_model(&mut self, cx: &mut ViewContext<Self>) {
+        if let Some(user_message) = self.context.update(cx, |context, cx| context.assist(cx)) {
            let new_selection = {
                let cursor = user_message
                    .start
@@ -1651,8 +1640,6 @@ impl ContextEditor {
            // Avoid scrolling to the new cursor position so the assistant's output is stable.
            cx.defer(|this, _| this.scroll_position = None);
        }
-
-        cx.notify();
    }

    fn cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
@@ -1680,10 +1667,8 @@ impl ContextEditor {
        });
    }

-    fn cursors(&self, cx: &mut WindowContext) -> Vec<usize> {
-        let selections = self
-            .editor
-            .update(cx, |editor, cx| editor.selections.all::<usize>(cx));
+    fn cursors(&self, cx: &AppContext) -> Vec<usize> {
+        let selections = self.editor.read(cx).selections.all::<usize>(cx);
        selections
            .into_iter()
            .map(|selection| selection.head())
@@ -2173,8 +2158,8 @@ impl ContextEditor {
        for range in removed {
            if let Some(state) = self.patches.remove(range) {
                editors_to_close.extend(state.editor.and_then(|state| state.editor.upgrade()));
-                removed_block_ids.insert(state.footer_block_id);
-                removed_crease_ids.push(state.crease_id);
+                removed_block_ids.insert(state.block_id);
+                // removed_crease_ids.push(state.crease_id);
            }
        }

@@ -2204,7 +2189,7 @@ impl ContextEditor {
                        let gutter_width = cx.gutter_dimensions.full_width();
                        let block_id = cx.block_id;
                        this.update(&mut **cx, |this, cx| {
-                            this.render_patch_footer(
+                            this.render_patch(
                                patch_range.clone(),
                                max_width,
                                gutter_width,
@@ -2218,26 +2203,9 @@ impl ContextEditor {
                    }
                });

-                let header_placeholder = FoldPlaceholder {
-                    render: {
-                        let this = this.clone();
-                        let patch_range = range.clone();
-                        Arc::new(move |fold_id, _range, cx| {
-                            this.update(cx, |this, cx| {
-                                this.render_patch_header(patch_range.clone(), fold_id, cx)
-                            })
-                            .ok()
-                            .flatten()
-                            .unwrap_or_else(|| Empty.into_any())
-                        })
-                    },
-                    constrain_width: false,
-                    merge_adjacent: false,
-                };
-
                let should_refold;
                if let Some(state) = self.patches.get_mut(&range) {
-                    replaced_blocks.insert(state.footer_block_id, render_block);
+                    replaced_blocks.insert(state.block_id, render_block);
                    if let Some(editor_state) = &state.editor {
                        if editor_state.opened_patch != patch {
                            state.update_task = Some({
@@ -2257,30 +2225,30 @@ impl ContextEditor {
                    let block_ids = editor.insert_blocks(
                        [BlockProperties {
                            height: path_count as u32 + 1,
-                            style: BlockStyle::Flex,
+                            style: BlockStyle::Fixed,
                            render: render_block,
-                            placement: BlockPlacement::Below(patch_start),
+                            placement: BlockPlacement::Replace(patch_start..patch_end),
                            priority: 0,
                        }],
                        None,
                        cx,
                    );

-                    let new_crease_ids = editor.insert_creases(
-                        [Crease::new(
-                            patch_start..patch_end,
-                            header_placeholder.clone(),
-                            fold_toggle("patch-header"),
-                            |_, _, _| Empty.into_any_element(),
-                        )],
-                        cx,
-                    );
+                    // let new_crease_ids = editor.insert_creases(
+                    //     [Crease::new(
+                    //         patch_start..patch_end,
+                    //         header_placeholder.clone(),
+                    //         fold_toggle("patch-header"),
+                    //         |_, _, _| Empty.into_any_element(),
+                    //     )],
+                    //     cx,
+                    // );

                    self.patches.insert(
                        range.clone(),
                        PatchViewState {
-                            footer_block_id: block_ids[0],
-                            crease_id: new_crease_ids[0],
+                            block_id: block_ids[0],
+                            // crease_id: new_crease_ids[0],
                            editor: None,
                            update_task: None,
                        },
@@ -2290,8 +2258,8 @@ impl ContextEditor {
                }

                if should_refold {
-                    editor.unfold_ranges([patch_start..patch_end], true, false, cx);
-                    editor.fold_ranges([(patch_start..patch_end, header_placeholder)], false, cx);
+                    // editor.unfold_ranges([patch_start..patch_end], true, false, cx);
+                    // editor.fold_ranges([(patch_start..patch_end, header_placeholder)], false, cx);
                }
            }

@@ -2390,9 +2358,7 @@ impl ContextEditor {
    }

    fn update_active_patch(&mut self, cx: &mut ViewContext<Self>) {
-        let newest_cursor = self.editor.update(cx, |editor, cx| {
-            editor.selections.newest::<Point>(cx).head()
-        });
+        let newest_cursor = self.editor.read(cx).selections.newest::<Point>(cx).head();
        let context = self.context.read(cx);

        let new_patch = context.patch_containing(newest_cursor, cx).cloned();
@@ -2799,40 +2765,39 @@ impl ContextEditor {
    ) -> Option<(String, bool)> {
        const CODE_FENCE_DELIMITER: &'static str = "```";

-        let context_editor = context_editor_view.read(cx).editor.clone();
-        context_editor.update(cx, |context_editor, cx| {
-            if context_editor.selections.newest::<Point>(cx).is_empty() {
-                let snapshot = context_editor.buffer().read(cx).snapshot(cx);
-                let (_, _, snapshot) = snapshot.as_singleton()?;
+        let context_editor = context_editor_view.read(cx).editor.read(cx);

-                let head = context_editor.selections.newest::<Point>(cx).head();
-                let offset = snapshot.point_to_offset(head);
+        if context_editor.selections.newest::<Point>(cx).is_empty() {
+            let snapshot = context_editor.buffer().read(cx).snapshot(cx);
+            let (_, _, snapshot) = snapshot.as_singleton()?;

-                let surrounding_code_block_range = find_surrounding_code_block(snapshot, offset)?;
-                let mut text = snapshot
-                    .text_for_range(surrounding_code_block_range)
-                    .collect::<String>();
+            let head = context_editor.selections.newest::<Point>(cx).head();
+            let offset = snapshot.point_to_offset(head);

-                // If there is no newline trailing the closing three-backticks, then
-                // tree-sitter-md extends the range of the content node to include
-                // the backticks.
-                if text.ends_with(CODE_FENCE_DELIMITER) {
-                    text.drain((text.len() - CODE_FENCE_DELIMITER.len())..);
-                }
+            let surrounding_code_block_range = find_surrounding_code_block(snapshot, offset)?;
+            let mut text = snapshot
+                .text_for_range(surrounding_code_block_range)
+                .collect::<String>();

-                (!text.is_empty()).then_some((text, true))
-            } else {
-                let anchor = context_editor.selections.newest_anchor();
-                let text = context_editor
-                    .buffer()
-                    .read(cx)
-                    .read(cx)
-                    .text_for_range(anchor.range())
-                    .collect::<String>();
-
-                (!text.is_empty()).then_some((text, false))
+            // If there is no newline trailing the closing three-backticks, then
+            // tree-sitter-md extends the range of the content node to include
+            // the backticks.
+            if text.ends_with(CODE_FENCE_DELIMITER) {
+                text.drain((text.len() - CODE_FENCE_DELIMITER.len())..);
            }
-        })
+
+            (!text.is_empty()).then_some((text, true))
+        } else {
+            let anchor = context_editor.selections.newest_anchor();
+            let text = context_editor
+                .buffer()
+                .read(cx)
+                .read(cx)
+                .text_for_range(anchor.range())
+                .collect::<String>();
+
+            (!text.is_empty()).then_some((text, false))
+        }
    }

    fn insert_selection(
@@ -3449,28 +3414,7 @@ impl ContextEditor {
            .unwrap_or_else(|| Cow::Borrowed(DEFAULT_TAB_TITLE))
    }

-    fn render_patch_header(
-        &self,
-        range: Range<text::Anchor>,
-        _id: FoldId,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<AnyElement> {
-        let patch = self.context.read(cx).patch_for_range(&range, cx)?;
-        let theme = cx.theme().clone();
-        Some(
-            h_flex()
-                .px_1()
-                .py_0p5()
-                .border_b_1()
-                .border_color(theme.status().info_border)
-                .gap_1()
-                .child(Icon::new(IconName::Diff).size(IconSize::Small))
-                .child(Label::new(patch.title.clone()).size(LabelSize::Small))
-                .into_any(),
-        )
-    }
-
-    fn render_patch_footer(
+    fn render_patch(
        &mut self,
        range: Range<text::Anchor>,
        max_width: Pixels,
@@ -3486,10 +3430,6 @@ impl ContextEditor {
            .anchor_in_excerpt(excerpt_id, range.start)
            .unwrap();

-        if !snapshot.intersects_fold(anchor) {
-            return None;
-        }
-
        let patch = self.context.read(cx).patch_for_range(&range, cx)?;
        let paths = patch
            .paths()
@@ -3498,10 +3438,13 @@ impl ContextEditor {

        Some(
            v_flex()
+                .border_1()
+                .border_color(cx.theme().colors().border)
                .id(id)
-                .pl(gutter_width)
-                .w(max_width)
-                .py_2()
+                .ml(gutter_width)
+                .p_2()
+                .rounded_md()
+                .min_h(cx.line_height() * 3.)
                .cursor(CursorStyle::PointingHand)
                .on_click(cx.listener(move |this, _, cx| {
                    this.editor.update(cx, |editor, cx| {
@@ -3511,6 +3454,7 @@ impl ContextEditor {
                    });
                    this.focus_active_patch(cx);
                }))
+                .child(Label::new(patch.title.clone()))
                .children(paths.into_iter().map(|path| {
                    h_flex()
                        .pl_1()
@@ -3662,13 +3606,7 @@ impl ContextEditor {
                button.tooltip(move |_| tooltip.clone())
            })
            .layer(ElevationIndex::ModalSurface)
-            .child(Label::new(
-                if AssistantSettings::get_global(cx).are_live_diffs_enabled(cx) {
-                    "Chat"
-                } else {
-                    "Send"
-                },
-            ))
+            .child(Label::new("Send"))
            .children(
                KeyBinding::for_action_in(&Assist, &focus_handle, cx)
                    .map(|binding| binding.into_any_element()),
@@ -3678,57 +3616,6 @@ impl ContextEditor {
            })
    }

-    fn render_edit_button(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let focus_handle = self.focus_handle(cx).clone();
-
-        let (style, tooltip) = match token_state(&self.context, cx) {
-            Some(TokenState::NoTokensLeft { .. }) => (
-                ButtonStyle::Tinted(TintColor::Negative),
-                Some(Tooltip::text("Token limit reached", cx)),
-            ),
-            Some(TokenState::HasMoreTokens {
-                over_warn_threshold,
-                ..
-            }) => {
-                let (style, tooltip) = if over_warn_threshold {
-                    (
-                        ButtonStyle::Tinted(TintColor::Warning),
-                        Some(Tooltip::text("Token limit is close to exhaustion", cx)),
-                    )
-                } else {
-                    (ButtonStyle::Filled, None)
-                };
-                (style, tooltip)
-            }
-            None => (ButtonStyle::Filled, None),
-        };
-
-        let provider = LanguageModelRegistry::read_global(cx).active_provider();
-
-        let has_configuration_error = configuration_error(cx).is_some();
-        let needs_to_accept_terms = self.show_accept_terms
-            && provider
-                .as_ref()
-                .map_or(false, |provider| provider.must_accept_terms(cx));
-        let disabled = has_configuration_error || needs_to_accept_terms;
-
-        ButtonLike::new("edit_button")
-            .disabled(disabled)
-            .style(style)
-            .when_some(tooltip, |button, tooltip| {
-                button.tooltip(move |_| tooltip.clone())
-            })
-            .layer(ElevationIndex::ModalSurface)
-            .child(Label::new("Suggest Edits"))
-            .children(
-                KeyBinding::for_action_in(&Edit, &focus_handle, cx)
-                    .map(|binding| binding.into_any_element()),
-            )
-            .on_click(move |_event, cx| {
-                focus_handle.dispatch_action(&Edit, cx);
-            })
-    }
-
    fn render_last_error(&self, cx: &mut ViewContext<Self>) -> Option<AnyElement> {
        let last_error = self.last_error.as_ref()?;

@@ -3743,7 +3630,6 @@ impl ContextEditor {
                .elevation_2(cx)
                .occlude()
                .child(match last_error {
-                    AssistError::FileRequired => self.render_file_required_error(cx),
                    AssistError::PaymentRequired => self.render_payment_required_error(cx),
                    AssistError::MaxMonthlySpendReached => {
                        self.render_max_monthly_spend_reached_error(cx)
@@ -3756,41 +3642,6 @@ impl ContextEditor {
        )
    }

-    fn render_file_required_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
-        v_flex()
-            .gap_0p5()
-            .child(
-                h_flex()
-                    .gap_1p5()
-                    .items_center()
-                    .child(Icon::new(IconName::Warning).color(Color::Warning))
-                    .child(
-                        Label::new("Suggest Edits needs a file to edit").weight(FontWeight::MEDIUM),
-                    ),
-            )
-            .child(
-                div()
-                    .id("error-message")
-                    .max_h_24()
-                    .overflow_y_scroll()
-                    .child(Label::new(
-                        "To include files, type /file or /tab in your prompt.",
-                    )),
-            )
-            .child(
-                h_flex()
-                    .justify_end()
-                    .mt_1()
-                    .child(Button::new("dismiss", "Dismiss").on_click(cx.listener(
-                        |this, _, cx| {
-                            this.last_error = None;
-                            cx.notify();
-                        },
-                    ))),
-            )
-            .into_any()
-    }
-
    fn render_payment_required_error(&self, cx: &mut ViewContext<Self>) -> AnyElement {
        const ERROR_MESSAGE: &str = "Free tier exceeded. Subscribe and add payment to continue using Zed LLMs. You'll be billed at cost for tokens used.";

@@ -4005,7 +3856,13 @@ impl Render for ContextEditor {
        } else {
            None
        };
-
+        let focus_handle = self
+            .workspace
+            .update(cx, |workspace, cx| {
+                Some(workspace.active_item_as::<Editor>(cx)?.focus_handle(cx))
+            })
+            .ok()
+            .flatten();
        v_flex()
            .key_context("ContextEditor")
            .capture_action(cx.listener(ContextEditor::cancel))
@@ -4015,7 +3872,6 @@ impl Render for ContextEditor {
            .capture_action(cx.listener(ContextEditor::paste))
            .capture_action(cx.listener(ContextEditor::cycle_message_role))
            .capture_action(cx.listener(ContextEditor::confirm_command))
-            .on_action(cx.listener(ContextEditor::edit))
            .on_action(cx.listener(ContextEditor::assist))
            .on_action(cx.listener(ContextEditor::split))
            .size_full()
@@ -4052,28 +3908,35 @@ impl Render for ContextEditor {
                        .bg(cx.theme().colors().editor_background)
                        .child(
                            h_flex()
-                                .gap_1()
-                                .child(render_inject_context_menu(cx.view().downgrade(), cx)),
+                                .gap_2()
+                                .child(render_inject_context_menu(cx.view().downgrade(), cx))
+                                .child(
+                                    IconButton::new("quote-button", IconName::Quote)
+                                        .icon_size(IconSize::Small)
+                                        .on_click(|_, cx| {
+                                            cx.dispatch_action(QuoteSelection.boxed_clone());
+                                        })
+                                        .tooltip(move |cx| {
+                                            cx.new_view(|cx| {
+                                                Tooltip::new("Insert Selection").key_binding(
+                                                    focus_handle.as_ref().and_then(|handle| {
+                                                        KeyBinding::for_action_in(
+                                                            &QuoteSelection,
+                                                            &handle,
+                                                            cx,
+                                                        )
+                                                    }),
+                                                )
+                                            })
+                                            .into()
+                                        }),
+                                ),
                        )
                        .child(
                            h_flex()
                                .w_full()
                                .justify_end()
-                                .when(
-                                    AssistantSettings::get_global(cx).are_live_diffs_enabled(cx),
-                                    |buttons| {
-                                        buttons
-                                            .items_center()
-                                            .gap_1p5()
-                                            .child(self.render_edit_button(cx))
-                                            .child(
-                                                Label::new("or")
-                                                    .size(LabelSize::Small)
-                                                    .color(Color::Muted),
-                                            )
-                                    },
-                                )
-                                .child(self.render_send_button(cx)),
+                                .child(div().child(self.render_send_button(cx))),
                        ),
                ),
            )
@@ -4345,12 +4208,11 @@ fn render_inject_context_menu(
    slash_command_picker::SlashCommandSelector::new(
        commands.clone(),
        active_context_editor,
-        Button::new("trigger", "Add Context")
-            .icon(IconName::Plus)
+        IconButton::new("trigger", IconName::SlashSquare)
            .icon_size(IconSize::Small)
-            .icon_color(Color::Muted)
-            .icon_position(IconPosition::Start)
-            .tooltip(|cx| Tooltip::text("Type / to insert via keyboard", cx)),
+            .tooltip(|cx| {
+                Tooltip::with_meta("Insert Context", None, "Type / to insert via keyboard", cx)
+            }),
    )
 }

@@ -4523,7 +4385,7 @@ impl Render for ContextEditorToolbarItem {
                                                .w_full()
                                                .justify_between()
                                                .gap_2()
-                                                .child(Label::new("Add Context"))
+                                                .child(Label::new("Insert Context"))
                                                .child(Label::new("/ command").color(Color::Muted))
                                                .into_any()
                                        },
@@ -4547,7 +4409,7 @@ impl Render for ContextEditorToolbarItem {
                                            }
                                        },
                                    )
-                                    .action("Add Selection", QuoteSelection.boxed_clone())
+                                    .action("Insert Selection", QuoteSelection.boxed_clone())
                            }))
                        }
                    }),
@@ -4807,7 +4669,7 @@ impl Render for ConfigurationView {

        let mut element = v_flex()
            .id("assistant-configuration-view")
-            .track_focus(&self.focus_handle(cx))
+            .track_focus(&self.focus_handle)
            .bg(cx.theme().colors().editor_background)
            .size_full()
            .overflow_y_scroll()
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
@@ -2,13 +2,12 @@
 mod context_tests;

 use crate::{
-    prompts::PromptBuilder,
-    slash_command::{file_command::FileCommandMetadata, SlashCommandLine},
-    AssistantEdit, AssistantPatch, AssistantPatchStatus, MessageId, MessageStatus,
+    prompts::PromptBuilder, slash_command::SlashCommandLine, AssistantEdit, AssistantPatch,
+    AssistantPatchStatus, MessageId, MessageStatus,
 };
 use anyhow::{anyhow, Context as _, Result};
 use assistant_slash_command::{
-    SlashCommandOutput, SlashCommandOutputSection, SlashCommandRegistry, SlashCommandResult,
+    SlashCommandOutput, SlashCommandOutputSection, SlashCommandRegistry,
 };
 use assistant_tool::ToolRegistry;
 use client::{self, proto, telemetry::Telemetry};
@@ -24,7 +23,6 @@ use gpui::{

 use language::{AnchorRangeExt, Bias, Buffer, LanguageRegistry, OffsetRangeExt, Point, ToOffset};
 use language_model::{
-    logging::report_assistant_event,
    provider::cloud::{MaxMonthlySpendReachedError, PaymentRequiredError},
    LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionEvent,
    LanguageModelImage, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage,
@@ -68,14 +66,6 @@ impl ContextId {
    }
 }

-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum RequestType {
-    /// Request a normal chat response from the model.
-    Chat,
-    /// Add a preamble to the message, which tells the model to return a structured response that suggests edits.
-    SuggestEdits,
-}
-
 #[derive(Clone, Debug)]
 pub enum ContextOperation {
    InsertMessage {
@@ -991,20 +981,6 @@ impl Context {
        &self.slash_command_output_sections
    }

-    pub fn contains_files(&self, cx: &AppContext) -> bool {
-        let buffer = self.buffer.read(cx);
-        self.slash_command_output_sections.iter().any(|section| {
-            section.is_valid(buffer)
-                && section
-                    .metadata
-                    .as_ref()
-                    .and_then(|metadata| {
-                        serde_json::from_value::<FileCommandMetadata>(metadata.clone()).ok()
-                    })
-                    .is_some()
-        })
-    }
-
    pub fn pending_tool_uses(&self) -> Vec<&PendingToolUse> {
        self.pending_tool_uses_by_id.values().collect()
    }
@@ -1052,7 +1028,7 @@ impl Context {
    }

    pub(crate) fn count_remaining_tokens(&mut self, cx: &mut ModelContext<Self>) {
-        let request = self.to_completion_request(RequestType::SuggestEdits, cx); // Conservatively assume SuggestEdits, since it takes more tokens.
+        let request = self.to_completion_request(cx);
        let Some(model) = LanguageModelRegistry::read_global(cx).active_model() else {
            return;
        };
@@ -1195,7 +1171,7 @@ impl Context {
        }

        let request = {
-            let mut req = self.to_completion_request(RequestType::Chat, cx);
+            let mut req = self.to_completion_request(cx);
            // Skip the last message because it's likely to change and
            // therefore would be a waste to cache.
            req.messages.pop();
@@ -1701,7 +1677,7 @@ impl Context {
    pub fn insert_command_output(
        &mut self,
        command_range: Range<language::Anchor>,
-        output: Task<SlashCommandResult>,
+        output: Task<Result<SlashCommandOutput>>,
        ensure_trailing_newline: bool,
        expand_result: bool,
        cx: &mut ModelContext<Self>,
@@ -1712,13 +1688,19 @@ impl Context {
            let command_range = command_range.clone();
            async move {
                let output = output.await;
-                let output = match output {
-                    Ok(output) => SlashCommandOutput::from_event_stream(output).await,
-                    Err(err) => Err(err),
-                };
                this.update(&mut cx, |this, cx| match output {
                    Ok(mut output) => {
-                        output.ensure_valid_section_ranges();
+                        // Ensure section ranges are valid.
+                        for section in &mut output.sections {
+                            section.range.start = section.range.start.min(output.text.len());
+                            section.range.end = section.range.end.min(output.text.len());
+                            while !output.text.is_char_boundary(section.range.start) {
+                                section.range.start -= 1;
+                            }
+                            while !output.text.is_char_boundary(section.range.end) {
+                                section.range.end += 1;
+                            }
+                        }

                        // Ensure there is a newline after the last section.
                        if ensure_trailing_newline {
@@ -1883,11 +1865,7 @@ impl Context {
        })
    }

-    pub fn assist(
-        &mut self,
-        request_type: RequestType,
-        cx: &mut ModelContext<Self>,
-    ) -> Option<MessageAnchor> {
+    pub fn assist(&mut self, cx: &mut ModelContext<Self>) -> Option<MessageAnchor> {
        let model_registry = LanguageModelRegistry::read_global(cx);
        let provider = model_registry.active_provider()?;
        let model = model_registry.active_model()?;
@@ -1900,7 +1878,7 @@ impl Context {
        // Compute which messages to cache, including the last one.
        self.mark_cache_anchors(&model.cache_configuration(), false, cx);

-        let mut request = self.to_completion_request(request_type, cx);
+        let mut request = self.to_completion_request(cx);

        if cx.has_flag::<ToolUseFeatureFlag>() {
            let tool_registry = ToolRegistry::global(cx);
@@ -1956,7 +1934,6 @@ impl Context {
                                    });

                                match event {
-                                    LanguageModelCompletionEvent::StartMessage { .. } => {}
                                    LanguageModelCompletionEvent::Stop(reason) => {
                                        stop_reason = reason;
                                    }
@@ -2062,28 +2039,23 @@ impl Context {
                        None
                    };

-                    let language_name = this
-                        .buffer
-                        .read(cx)
-                        .language()
-                        .map(|language| language.name());
-                    report_assistant_event(
-                        AssistantEvent {
+                    if let Some(telemetry) = this.telemetry.as_ref() {
+                        let language_name = this
+                            .buffer
+                            .read(cx)
+                            .language()
+                            .map(|language| language.name());
+                        telemetry.report_assistant_event(AssistantEvent {
                            conversation_id: Some(this.id.0.clone()),
                            kind: AssistantKind::Panel,
                            phase: AssistantPhase::Response,
-                            message_id: None,
                            model: model.telemetry_id(),
                            model_provider: model.provider_id().to_string(),
                            response_latency,
                            error_message,
                            language_name: language_name.map(|name| name.to_proto()),
-                        },
-                        this.telemetry.clone(),
-                        cx.http_client(),
-                        model.api_key(cx),
-                        cx.background_executor(),
-                    );
+                        });
+                    }

                    if let Ok(stop_reason) = result {
                        match stop_reason {
@@ -2108,11 +2080,7 @@ impl Context {
        Some(user_message)
    }

-    pub fn to_completion_request(
-        &self,
-        request_type: RequestType,
-        cx: &AppContext,
-    ) -> LanguageModelRequest {
+    pub fn to_completion_request(&self, cx: &AppContext) -> LanguageModelRequest {
        let buffer = self.buffer.read(cx);

        let mut contents = self.contents(cx).peekable();
@@ -2201,25 +2169,6 @@ impl Context {
            completion_request.messages.push(request_message);
        }

-        if let RequestType::SuggestEdits = request_type {
-            if let Ok(preamble) = self.prompt_builder.generate_workflow_prompt() {
-                let last_elem_index = completion_request.messages.len();
-
-                completion_request
-                    .messages
-                    .push(LanguageModelRequestMessage {
-                        role: Role::User,
-                        content: vec![MessageContent::Text(preamble)],
-                        cache: false,
-                    });
-
-                // The preamble message should be sent right before the last actual user message.
-                completion_request
-                    .messages
-                    .swap(last_elem_index, last_elem_index.saturating_sub(1));
-            }
-        }
-
        completion_request
    }

@@ -2534,7 +2483,7 @@ impl Context {
                return;
            }

-            let mut request = self.to_completion_request(RequestType::Chat, cx);
+            let mut request = self.to_completion_request(cx);
            request.messages.push(LanguageModelRequestMessage {
                role: Role::User,
                content: vec![
@@ -2550,7 +2499,7 @@ impl Context {
                    let mut messages = stream.await?;

                    let mut replaced = !replace_old;
-                    while let Some(message) = messages.stream.next().await {
+                    while let Some(message) = messages.next().await {
                        let text = message?;
                        let mut lines = text.lines();
                        this.update(&mut cx, |this, cx| {
--- a/crates/assistant/src/context/context_tests.rs
+++ b/crates/assistant/src/context/context_tests.rs
@@ -6,7 +6,7 @@ use crate::{
 use anyhow::Result;
 use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandRegistry, SlashCommandResult,
+    SlashCommandRegistry,
 };
 use collections::HashSet;
 use fs::FakeFs;
@@ -636,7 +636,7 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
            kind: AssistantEditKind::InsertAfter {
                old_text: "fn one".into(),
                new_text: "fn two() {}".into(),
-                description: Some("add a `two` function".into()),
+                description: "add a `two` function".into(),
            },
        }]],
        cx,
@@ -690,7 +690,7 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
            kind: AssistantEditKind::InsertAfter {
                old_text: "fn zero".into(),
                new_text: "fn two() {}".into(),
-                description: Some("add a `two` function".into()),
+                description: "add a `two` function".into(),
            },
        }]],
        cx,
@@ -754,7 +754,7 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
            kind: AssistantEditKind::InsertAfter {
                old_text: "fn zero".into(),
                new_text: "fn two() {}".into(),
-                description: Some("add a `two` function".into()),
+                description: "add a `two` function".into(),
            },
        }]],
        cx,
@@ -798,7 +798,7 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
            kind: AssistantEditKind::InsertAfter {
                old_text: "fn zero".into(),
                new_text: "fn two() {}".into(),
-                description: Some("add a `two` function".into()),
+                description: "add a `two` function".into(),
            },
        }]],
        cx,
@@ -1097,8 +1097,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                            text: output_text,
                            sections,
                            run_commands_in_text: false,
-                        }
-                        .to_event_stream())),
+                        })),
                        true,
                        false,
                        cx,
@@ -1417,12 +1416,11 @@ impl SlashCommand for FakeSlashCommand {
        _workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        _cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        Task::ready(Ok(SlashCommandOutput {
            text: format!("Executed fake command: {}", self.0),
            sections: vec![],
            run_commands_in_text: false,
-        }
-        .to_event_stream()))
+        }))
    }
 }
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -1,7 +1,7 @@
 use crate::{
    assistant_settings::AssistantSettings, humanize_token_count, prompts::PromptBuilder,
    AssistantPanel, AssistantPanelEvent, CharOperation, CycleNextInlineAssist,
-    CyclePreviousInlineAssist, LineDiff, LineOperation, ModelSelector, RequestType, StreamingDiff,
+    CyclePreviousInlineAssist, LineDiff, LineOperation, ModelSelector, StreamingDiff,
 };
 use anyhow::{anyhow, Context as _, Result};
 use client::{telemetry::Telemetry, ErrorExt};
@@ -21,7 +21,9 @@ use fs::Fs;
 use futures::{
    channel::mpsc,
    future::{BoxFuture, LocalBoxFuture},
-    join, SinkExt, Stream, StreamExt,
+    join,
+    stream::{self, BoxStream},
+    SinkExt, Stream, StreamExt,
 };
 use gpui::{
    anchored, deferred, point, AnyElement, AppContext, ClickEvent, EventEmitter, FocusHandle,
@@ -30,8 +32,7 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    logging::report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, LanguageModelTextStream, Role,
+    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -53,7 +54,7 @@ use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal_view::terminal_panel::TerminalPanel;
 use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
-use ui::{prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, Popover, Tooltip};
+use ui::{prelude::*, CheckboxWithLabel, IconButtonShape, Popover, Tooltip};
 use util::{RangeExt, ResultExt};
 use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace};

@@ -188,16 +189,11 @@ impl InlineAssistant {
        initial_prompt: Option<String>,
        cx: &mut WindowContext,
    ) {
-        let (snapshot, initial_selections) = editor.update(cx, |editor, cx| {
-            (
-                editor.buffer().read(cx).snapshot(cx),
-                editor.selections.all::<Point>(cx),
-            )
-        });
+        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);

        let mut selections = Vec::<Selection<Point>>::new();
        let mut newest_selection = None;
-        for mut selection in initial_selections {
+        for mut selection in editor.read(cx).selections.all::<Point>(cx) {
            if selection.end > selection.start {
                selection.start.column = 0;
                // If the selection ends at the start of the line, we don't want to include it.
@@ -240,13 +236,12 @@ impl InlineAssistant {
            };
            codegen_ranges.push(start..end);

-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                if let Some(telemetry) = self.telemetry.as_ref() {
+            if let Some(telemetry) = self.telemetry.as_ref() {
+                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
                    telemetry.report_assistant_event(AssistantEvent {
                        conversation_id: None,
                        kind: AssistantKind::Inline,
                        phase: AssistantPhase::Invoked,
-                        message_id: None,
                        model: model.telemetry_id(),
                        model_provider: model.provider_id().to_string(),
                        response_latency: None,
@@ -571,13 +566,10 @@ impl InlineAssistant {
            return;
        };

-        if editor.read(cx).selections.count() == 1 {
-            let (selection, buffer) = editor.update(cx, |editor, cx| {
-                (
-                    editor.selections.newest::<usize>(cx),
-                    editor.buffer().read(cx).snapshot(cx),
-                )
-            });
+        let editor = editor.read(cx);
+        if editor.selections.count() == 1 {
+            let selection = editor.selections.newest::<usize>(cx);
+            let buffer = editor.buffer().read(cx).snapshot(cx);
            for assist_id in &editor_assists.assist_ids {
                let assist = &self.assists[assist_id];
                let assist_range = assist.range.to_offset(&buffer);
@@ -602,13 +594,10 @@ impl InlineAssistant {
            return;
        };

-        if editor.read(cx).selections.count() == 1 {
-            let (selection, buffer) = editor.update(cx, |editor, cx| {
-                (
-                    editor.selections.newest::<usize>(cx),
-                    editor.buffer().read(cx).snapshot(cx),
-                )
-            });
+        let editor = editor.read(cx);
+        if editor.selections.count() == 1 {
+            let selection = editor.selections.newest::<usize>(cx);
+            let buffer = editor.buffer().read(cx).snapshot(cx);
            let mut closest_assist_fallback = None;
            for assist_id in &editor_assists.assist_ids {
                let assist = &self.assists[assist_id];
@@ -754,6 +743,33 @@ impl InlineAssistant {

    pub fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
        if let Some(assist) = self.assists.get(&assist_id) {
+            if let Some(telemetry) = self.telemetry.as_ref() {
+                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                    let language_name = assist.editor.upgrade().and_then(|editor| {
+                        let multibuffer = editor.read(cx).buffer().read(cx);
+                        let ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
+                        ranges
+                            .first()
+                            .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                            .map(|language| language.name())
+                    });
+                    telemetry.report_assistant_event(AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::Inline,
+                        phase: if undo {
+                            AssistantPhase::Rejected
+                        } else {
+                            AssistantPhase::Accepted
+                        },
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name: language_name.map(|name| name.to_proto()),
+                    });
+                }
+            }
+
            let assist_group_id = assist.group_id;
            if self.assist_groups[&assist_group_id].linked {
                for assist_id in self.unlink_assist_group(assist_group_id, cx) {
@@ -788,45 +804,12 @@ impl InlineAssistant {
                }
            }

-            let active_alternative = assist.codegen.read(cx).active_alternative().clone();
-            let message_id = active_alternative.read(cx).message_id.clone();
-
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                let language_name = assist.editor.upgrade().and_then(|editor| {
-                    let multibuffer = editor.read(cx).buffer().read(cx);
-                    let ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
-                    ranges
-                        .first()
-                        .and_then(|(buffer, _, _)| buffer.read(cx).language())
-                        .map(|language| language.name())
-                });
-                report_assistant_event(
-                    AssistantEvent {
-                        conversation_id: None,
-                        kind: AssistantKind::Inline,
-                        message_id,
-                        phase: if undo {
-                            AssistantPhase::Rejected
-                        } else {
-                            AssistantPhase::Accepted
-                        },
-                        model: model.telemetry_id(),
-                        model_provider: model.provider_id().to_string(),
-                        response_latency: None,
-                        error_message: None,
-                        language_name: language_name.map(|name| name.to_proto()),
-                    },
-                    self.telemetry.clone(),
-                    cx.http_client(),
-                    model.api_key(cx),
-                    cx.background_executor(),
-                );
-            }
-
            if undo {
                assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
            } else {
-                self.confirmed_assists.insert(assist_id, active_alternative);
+                let confirmed_alternative = assist.codegen.read(cx).active_alternative().clone();
+                self.confirmed_assists
+                    .insert(assist_id, confirmed_alternative);
            }
        }
    }
@@ -1613,7 +1596,7 @@ impl PromptEditor {
            // always show the cursor (even when it isn't focused) because
            // typing in one will make what you typed appear in all of them.
            editor.set_show_cursor_when_unfocused(true, cx);
-            editor.set_placeholder_text(Self::placeholder_text(codegen.read(cx), cx), cx);
+            editor.set_placeholder_text("Add a prompt…", cx);
            editor
        });

@@ -1670,7 +1653,6 @@ impl PromptEditor {
        self.editor = cx.new_view(|cx| {
            let mut editor = Editor::auto_height(Self::MAX_LINES as usize, cx);
            editor.set_soft_wrap_mode(language::language_settings::SoftWrap::EditorWidth, cx);
-            editor.set_placeholder_text(Self::placeholder_text(self.codegen.read(cx), cx), cx);
            editor.set_placeholder_text("Add a prompt…", cx);
            editor.set_text(prompt, cx);
            if focus {
@@ -1681,20 +1663,6 @@ impl PromptEditor {
        self.subscribe_to_editor(cx);
    }

-    fn placeholder_text(codegen: &Codegen, cx: &WindowContext) -> String {
-        let context_keybinding = text_for_action(&crate::ToggleFocus, cx)
-            .map(|keybinding| format!(" • {keybinding} for context"))
-            .unwrap_or_default();
-
-        let action = if codegen.is_insertion {
-            "Generate"
-        } else {
-            "Transform"
-        };
-
-        format!("{action}…{context_keybinding} • ↓↑ for history")
-    }
-
    fn prompt(&self, cx: &AppContext) -> String {
        self.editor.read(cx).text(cx)
    }
@@ -2251,7 +2219,7 @@ impl InlineAssist {
                    .read(cx)
                    .active_context(cx)?
                    .read(cx)
-                    .to_completion_request(RequestType::Chat, cx),
+                    .to_completion_request(cx),
            )
        } else {
            None
@@ -2292,7 +2260,6 @@ pub struct Codegen {
    initial_transaction_id: Option<TransactionId>,
    telemetry: Option<Arc<Telemetry>>,
    builder: Arc<PromptBuilder>,
-    is_insertion: bool,
 }

 impl Codegen {
@@ -2315,7 +2282,6 @@ impl Codegen {
            )
        });
        let mut this = Self {
-            is_insertion: range.to_offset(&buffer.read(cx).snapshot(cx)).is_empty(),
            alternatives: vec![codegen],
            active_alternative: 0,
            seen_alternatives: HashSet::default(),
@@ -2503,7 +2469,6 @@ pub struct CodegenAlternative {
    line_operations: Vec<LineOperation>,
    request: Option<LanguageModelRequest>,
    elapsed_time: Option<f64>,
-    message_id: Option<String>,
 }

 enum CodegenStatus {
@@ -2562,7 +2527,6 @@ impl CodegenAlternative {
            buffer: buffer.clone(),
            old_buffer,
            edit_position: None,
-            message_id: None,
            snapshot,
            last_equal_ranges: Default::default(),
            transformation_transaction_id: None,
@@ -2667,20 +2631,20 @@ impl CodegenAlternative {

        self.edit_position = Some(self.range.start.bias_right(&self.snapshot));

-        let api_key = model.api_key(cx);
        let telemetry_id = model.telemetry_id();
        let provider_id = model.provider_id();
-        let stream: LocalBoxFuture<Result<LanguageModelTextStream>> =
+        let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> =
            if user_prompt.trim().to_lowercase() == "delete" {
-                async { Ok(LanguageModelTextStream::default()) }.boxed_local()
+                async { Ok(stream::empty().boxed()) }.boxed_local()
            } else {
                let request = self.build_request(user_prompt, assistant_panel_context, cx)?;
                self.request = Some(request.clone());

-                cx.spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await })
-                    .boxed_local()
+                let chunks = cx
+                    .spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await });
+                async move { Ok(chunks.await?.boxed()) }.boxed_local()
            };
-        self.handle_stream(telemetry_id, provider_id.to_string(), api_key, stream, cx);
+        self.handle_stream(telemetry_id, provider_id.to_string(), chunks, cx);
        Ok(())
    }

@@ -2719,7 +2683,7 @@ impl CodegenAlternative {

        let prompt = self
            .builder
-            .generate_inline_transformation_prompt(user_prompt, language_name, buffer, range)
+            .generate_content_prompt(user_prompt, language_name, buffer, range)
            .map_err(|e| anyhow::anyhow!("Failed to generate content prompt: {}", e))?;

        let mut messages = Vec::new();
@@ -2745,8 +2709,7 @@ impl CodegenAlternative {
        &mut self,
        model_telemetry_id: String,
        model_provider_id: String,
-        model_api_key: Option<String>,
-        stream: impl 'static + Future<Output = Result<LanguageModelTextStream>>,
+        stream: impl 'static + Future<Output = Result<BoxStream<'static, Result<String>>>>,
        cx: &mut ModelContext<Self>,
    ) {
        let start_time = Instant::now();
@@ -2776,7 +2739,6 @@ impl CodegenAlternative {
            }
        }

-        let http_client = cx.http_client().clone();
        let telemetry = self.telemetry.clone();
        let language_name = {
            let multibuffer = self.buffer.read(cx);
@@ -2792,21 +2754,15 @@ impl CodegenAlternative {
        let mut edit_start = self.range.start.to_offset(&snapshot);
        self.generation = cx.spawn(|codegen, mut cx| {
            async move {
-                let stream = stream.await;
-                let message_id = stream
-                    .as_ref()
-                    .ok()
-                    .and_then(|stream| stream.message_id.clone());
+                let chunks = stream.await;
                let generate = async {
                    let (mut diff_tx, mut diff_rx) = mpsc::channel(1);
-                    let executor = cx.background_executor().clone();
-                    let message_id = message_id.clone();
                    let line_based_stream_diff: Task<anyhow::Result<()>> =
                        cx.background_executor().spawn(async move {
                            let mut response_latency = None;
                            let request_start = Instant::now();
                            let diff = async {
-                                let chunks = StripInvalidSpans::new(stream?.stream);
+                                let chunks = StripInvalidSpans::new(chunks?);
                                futures::pin_mut!(chunks);
                                let mut diff = StreamingDiff::new(selected_text.to_string());
                                let mut line_diff = LineDiff::default();
@@ -2902,10 +2858,9 @@ impl CodegenAlternative {

                            let error_message =
                                result.as_ref().err().map(|error| error.to_string());
-                            report_assistant_event(
-                                AssistantEvent {
+                            if let Some(telemetry) = telemetry {
+                                telemetry.report_assistant_event(AssistantEvent {
                                    conversation_id: None,
-                                    message_id,
                                    kind: AssistantKind::Inline,
                                    phase: AssistantPhase::Response,
                                    model: model_telemetry_id,
@@ -2913,12 +2868,8 @@ impl CodegenAlternative {
                                    response_latency,
                                    error_message,
                                    language_name: language_name.map(|name| name.to_proto()),
-                                },
-                                telemetry,
-                                http_client,
-                                model_api_key,
-                                &executor,
-                            );
+                                });
+                            }

                            result?;
                            Ok(())
@@ -2982,7 +2933,6 @@ impl CodegenAlternative {

                codegen
                    .update(&mut cx, |this, cx| {
-                        this.message_id = message_id;
                        this.last_equal_ranges.clear();
                        if let Err(error) = result {
                            this.status = CodegenStatus::Error(error);
@@ -3534,7 +3484,15 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });

        let mut new_text = concat!(
            "       let mut x = 0;\n",
@@ -3598,7 +3556,15 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });

        cx.background_executor.run_until_parked();

@@ -3665,7 +3631,15 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });

        cx.background_executor.run_until_parked();

@@ -3731,7 +3705,16 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });
+
        let new_text = concat!(
            "func main() {\n",
            "\tx := 0\n",
@@ -3786,7 +3769,16 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });
+
        chunks_tx
            .unbounded_send("let mut x = 0;\nx += 1;".to_string())
            .unwrap();
@@ -3860,26 +3852,6 @@ mod tests {
        }
    }

-    fn simulate_response_stream(
-        codegen: Model<CodegenAlternative>,
-        cx: &mut TestAppContext,
-    ) -> mpsc::UnboundedSender<String> {
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                None,
-                future::ready(Ok(LanguageModelTextStream {
-                    message_id: None,
-                    stream: chunks_rx.map(Ok).boxed(),
-                })),
-                cx,
-            );
-        });
-        chunks_tx
-    }
-
    fn rust_lang() -> Language {
        Language::new(
            LanguageConfig {
--- a/crates/assistant/src/model_selector.rs
+++ b/crates/assistant/src/model_selector.rs
@@ -158,34 +158,39 @@ impl PickerDelegate for ModelPickerDelegate {
                .spacing(ListItemSpacing::Sparse)
                .selected(selected)
                .start_slot(
-                    div().pr_0p5().child(
+                    div().pr_1().child(
                        Icon::new(model_info.icon)
                            .color(Color::Muted)
                            .size(IconSize::Medium),
                    ),
                )
                .child(
-                    h_flex().w_full().justify_between().min_w(px(200.)).child(
-                        h_flex()
-                            .gap_1p5()
-                            .child(Label::new(model_info.model.name().0.clone()))
-                            .child(
-                                Label::new(provider_name)
-                                    .size(LabelSize::XSmall)
-                                    .color(Color::Muted),
-                            )
-                            .children(match model_info.availability {
-                                LanguageModelAvailability::Public => None,
-                                LanguageModelAvailability::RequiresPlan(Plan::Free) => None,
-                                LanguageModelAvailability::RequiresPlan(Plan::ZedPro) => {
-                                    show_badges.then(|| {
-                                        Label::new("Pro")
-                                            .size(LabelSize::XSmall)
-                                            .color(Color::Muted)
-                                    })
-                                }
-                            }),
-                    ),
+                    h_flex()
+                        .w_full()
+                        .justify_between()
+                        .font_buffer(cx)
+                        .min_w(px(240.))
+                        .child(
+                            h_flex()
+                                .gap_2()
+                                .child(Label::new(model_info.model.name().0.clone()))
+                                .child(
+                                    Label::new(provider_name)
+                                        .size(LabelSize::XSmall)
+                                        .color(Color::Muted),
+                                )
+                                .children(match model_info.availability {
+                                    LanguageModelAvailability::Public => None,
+                                    LanguageModelAvailability::RequiresPlan(Plan::Free) => None,
+                                    LanguageModelAvailability::RequiresPlan(Plan::ZedPro) => {
+                                        show_badges.then(|| {
+                                            Label::new("Pro")
+                                                .size(LabelSize::XSmall)
+                                                .color(Color::Muted)
+                                        })
+                                    }
+                                }),
+                        ),
                )
                .end_slot(div().when(model_info.is_selected, |this| {
                    this.child(
@@ -207,7 +212,7 @@ impl PickerDelegate for ModelPickerDelegate {
            h_flex()
                .w_full()
                .border_t_1()
-                .border_color(cx.theme().colors().border_variant)
+                .border_color(cx.theme().colors().border)
                .p_1()
                .gap_4()
                .justify_between()
--- a/crates/assistant/src/patch.rs
+++ b/crates/assistant/src/patch.rs
@@ -33,21 +33,21 @@ pub enum AssistantEditKind {
    Update {
        old_text: String,
        new_text: String,
-        description: Option<String>,
+        description: String,
    },
    Create {
        new_text: String,
-        description: Option<String>,
+        description: String,
    },
    InsertBefore {
        old_text: String,
        new_text: String,
-        description: Option<String>,
+        description: String,
    },
    InsertAfter {
        old_text: String,
        new_text: String,
-        description: Option<String>,
+        description: String,
    },
    Delete {
        old_text: String,
@@ -86,37 +86,19 @@ enum SearchDirection {
    Diagonal,
 }

+// A measure of the currently quality of an in-progress fuzzy search.
+//
+// Uses 60 bits to store a numeric cost, and 4 bits to store the preceding
+// operation in the search.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 struct SearchState {
-    cost: u32,
+    score: u32,
    direction: SearchDirection,
 }

 impl SearchState {
-    fn new(cost: u32, direction: SearchDirection) -> Self {
-        Self { cost, direction }
-    }
-}
-
-struct SearchMatrix {
-    cols: usize,
-    data: Vec<SearchState>,
-}
-
-impl SearchMatrix {
-    fn new(rows: usize, cols: usize) -> Self {
-        SearchMatrix {
-            cols,
-            data: vec![SearchState::new(0, SearchDirection::Diagonal); rows * cols],
-        }
-    }
-
-    fn get(&self, row: usize, col: usize) -> SearchState {
-        self.data[row * self.cols + col]
-    }
-
-    fn set(&mut self, row: usize, col: usize, cost: SearchState) {
-        self.data[row * self.cols + col] = cost;
+    fn new(score: u32, direction: SearchDirection) -> Self {
+        Self { score, direction }
    }
 }

@@ -205,23 +187,23 @@ impl AssistantEdit {
            "update" => AssistantEditKind::Update {
                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-                description,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
            },
            "insert_before" => AssistantEditKind::InsertBefore {
                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-                description,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
            },
            "insert_after" => AssistantEditKind::InsertAfter {
                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
-                description,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
            },
            "delete" => AssistantEditKind::Delete {
                old_text: old_text.ok_or_else(|| anyhow!("missing old_text"))?,
            },
            "create" => AssistantEditKind::Create {
-                description,
+                description: description.ok_or_else(|| anyhow!("missing description"))?,
                new_text: new_text.ok_or_else(|| anyhow!("missing new_text"))?,
            },
            _ => Err(anyhow!("unknown operation {operation:?}"))?,
@@ -282,7 +264,7 @@ impl AssistantEditKind {
                ResolvedEdit {
                    range,
                    new_text,
-                    description,
+                    description: Some(description),
                }
            }
            Self::Create {
@@ -290,7 +272,7 @@ impl AssistantEditKind {
                description,
            } => ResolvedEdit {
                range: text::Anchor::MIN..text::Anchor::MAX,
-                description,
+                description: Some(description),
                new_text,
            },
            Self::InsertBefore {
@@ -303,7 +285,7 @@ impl AssistantEditKind {
                ResolvedEdit {
                    range: range.start..range.start,
                    new_text,
-                    description,
+                    description: Some(description),
                }
            }
            Self::InsertAfter {
@@ -316,7 +298,7 @@ impl AssistantEditKind {
                ResolvedEdit {
                    range: range.end..range.end,
                    new_text,
-                    description,
+                    description: Some(description),
                }
            }
            Self::Delete { old_text } => {
@@ -332,29 +314,44 @@ impl AssistantEditKind {

    fn resolve_location(buffer: &text::BufferSnapshot, search_query: &str) -> Range<text::Anchor> {
        const INSERTION_COST: u32 = 3;
-        const DELETION_COST: u32 = 10;
        const WHITESPACE_INSERTION_COST: u32 = 1;
+        const DELETION_COST: u32 = 3;
        const WHITESPACE_DELETION_COST: u32 = 1;
+        const EQUALITY_BONUS: u32 = 5;
+
+        struct Matrix {
+            cols: usize,
+            data: Vec<SearchState>,
+        }
+
+        impl Matrix {
+            fn new(rows: usize, cols: usize) -> Self {
+                Matrix {
+                    cols,
+                    data: vec![SearchState::new(0, SearchDirection::Diagonal); rows * cols],
+                }
+            }
+
+            fn get(&self, row: usize, col: usize) -> SearchState {
+                self.data[row * self.cols + col]
+            }
+
+            fn set(&mut self, row: usize, col: usize, cost: SearchState) {
+                self.data[row * self.cols + col] = cost;
+            }
+        }

        let buffer_len = buffer.len();
        let query_len = search_query.len();
-        let mut matrix = SearchMatrix::new(query_len + 1, buffer_len + 1);
-        let mut leading_deletion_cost = 0_u32;
+        let mut matrix = Matrix::new(query_len + 1, buffer_len + 1);
+
        for (row, query_byte) in search_query.bytes().enumerate() {
-            let deletion_cost = if query_byte.is_ascii_whitespace() {
-                WHITESPACE_DELETION_COST
-            } else {
-                DELETION_COST
-            };
-
-            leading_deletion_cost = leading_deletion_cost.saturating_add(deletion_cost);
-            matrix.set(
-                row + 1,
-                0,
-                SearchState::new(leading_deletion_cost, SearchDirection::Diagonal),
-            );
-
            for (col, buffer_byte) in buffer.bytes_in_range(0..buffer.len()).flatten().enumerate() {
+                let deletion_cost = if query_byte.is_ascii_whitespace() {
+                    WHITESPACE_DELETION_COST
+                } else {
+                    DELETION_COST
+                };
                let insertion_cost = if buffer_byte.is_ascii_whitespace() {
                    WHITESPACE_INSERTION_COST
                } else {
@@ -362,35 +359,38 @@ impl AssistantEditKind {
                };

                let up = SearchState::new(
-                    matrix.get(row, col + 1).cost.saturating_add(deletion_cost),
+                    matrix.get(row, col + 1).score.saturating_sub(deletion_cost),
                    SearchDirection::Up,
                );
                let left = SearchState::new(
-                    matrix.get(row + 1, col).cost.saturating_add(insertion_cost),
+                    matrix
+                        .get(row + 1, col)
+                        .score
+                        .saturating_sub(insertion_cost),
                    SearchDirection::Left,
                );
                let diagonal = SearchState::new(
                    if query_byte == *buffer_byte {
-                        matrix.get(row, col).cost
+                        matrix.get(row, col).score.saturating_add(EQUALITY_BONUS)
                    } else {
                        matrix
                            .get(row, col)
-                            .cost
-                            .saturating_add(deletion_cost + insertion_cost)
+                            .score
+                            .saturating_sub(deletion_cost + insertion_cost)
                    },
                    SearchDirection::Diagonal,
                );
-                matrix.set(row + 1, col + 1, up.min(left).min(diagonal));
+                matrix.set(row + 1, col + 1, up.max(left).max(diagonal));
            }
        }

        // Traceback to find the best match
        let mut best_buffer_end = buffer_len;
-        let mut best_cost = u32::MAX;
+        let mut best_score = 0;
        for col in 1..=buffer_len {
-            let cost = matrix.get(query_len, col).cost;
-            if cost < best_cost {
-                best_cost = cost;
+            let score = matrix.get(query_len, col).score;
+            if score > best_score {
+                best_score = score;
                best_buffer_end = col;
            }
        }
@@ -560,84 +560,89 @@ mod tests {
        language_settings::AllLanguageSettings, Language, LanguageConfig, LanguageMatcher,
    };
    use settings::SettingsStore;
+    use text::{OffsetRangeExt, Point};
    use ui::BorrowAppContext;
    use unindent::Unindent as _;
-    use util::test::{generate_marked_text, marked_text_ranges};

    #[gpui::test]
    fn test_resolve_location(cx: &mut AppContext) {
-        assert_location_resolution(
-            concat!(
-                "    Lorem\n",
-                "«    ipsum\n",
-                "    dolor sit amet»\n",
-                "    consecteur",
-            ),
-            "ipsum\ndolor",
-            cx,
-        );
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "    Lorem\n",
+                        "    ipsum\n",
+                        "    dolor sit amet\n",
+                        "    consecteur",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                AssistantEditKind::resolve_location(&snapshot, "ipsum\ndolor").to_point(&snapshot),
+                Point::new(1, 0)..Point::new(2, 18)
+            );
+        }

-        assert_location_resolution(
-            &"
-            «fn foo1(a: usize) -> usize {
-                40
-            }»
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "fn foo1(a: usize) -> usize {\n",
+                        "    40\n",
+                        "}\n",
+                        "\n",
+                        "fn foo2(b: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                AssistantEditKind::resolve_location(&snapshot, "fn foo1(b: usize) {\n40\n}")
+                    .to_point(&snapshot),
+                Point::new(0, 0)..Point::new(2, 1)
+            );
+        }

-            fn foo2(b: usize) -> usize {
-                42
-            }
-            "
-            .unindent(),
-            "fn foo1(b: usize) {\n40\n}",
-            cx,
-        );
-
-        assert_location_resolution(
-            &"
-            fn main() {
-            «    Foo
-                    .bar()
-                    .baz()
-                    .qux()»
-            }
-
-            fn foo2(b: usize) -> usize {
-                42
-            }
-            "
-            .unindent(),
-            "Foo.bar.baz.qux()",
-            cx,
-        );
-
-        assert_location_resolution(
-            &"
-            class Something {
-                one() { return 1; }
-            «    two() { return 2222; }
-                three() { return 333; }
-                four() { return 4444; }
-                five() { return 5555; }
-                six() { return 6666; }
-            »    seven() { return 7; }
-                eight() { return 8; }
-            }
-            "
-            .unindent(),
-            &"
-                two() { return 2222; }
-                four() { return 4444; }
-                five() { return 5555; }
-                six() { return 6666; }
-            "
-            .unindent(),
-            cx,
-        );
+        {
+            let buffer = cx.new_model(|cx| {
+                Buffer::local(
+                    concat!(
+                        "fn main() {\n",
+                        "    Foo\n",
+                        "        .bar()\n",
+                        "        .baz()\n",
+                        "        .qux()\n",
+                        "}\n",
+                        "\n",
+                        "fn foo2(b: usize) -> usize {\n",
+                        "    42\n",
+                        "}\n",
+                    ),
+                    cx,
+                )
+            });
+            let snapshot = buffer.read(cx).snapshot();
+            assert_eq!(
+                AssistantEditKind::resolve_location(&snapshot, "Foo.bar.baz.qux()")
+                    .to_point(&snapshot),
+                Point::new(1, 0)..Point::new(4, 14)
+            );
+        }
    }

    #[gpui::test]
    fn test_resolve_edits(cx: &mut AppContext) {
-        init_test(cx);
+        let settings_store = SettingsStore::test(cx);
+        cx.set_global(settings_store);
+        language::init(cx);
+        cx.update_global::<SettingsStore, _>(|settings, cx| {
+            settings.update_user_settings::<AllLanguageSettings>(cx, |_| {});
+        });

        assert_edits(
            "
@@ -670,7 +675,7 @@ mod tests {
                        last_name: String,
                    "
                    .unindent(),
-                    description: None,
+                    description: "".into(),
                },
                AssistantEditKind::Update {
                    old_text: "
@@ -685,7 +690,7 @@ mod tests {
                        }
                    "
                    .unindent(),
-                    description: None,
+                    description: "".into(),
                },
            ],
            "
@@ -729,7 +734,7 @@ mod tests {
                            qux();
                        }"
                    .unindent(),
-                    description: Some("implement bar".into()),
+                    description: "implement bar".into(),
                },
                AssistantEditKind::Update {
                    old_text: "
@@ -742,7 +747,7 @@ mod tests {
                            bar();
                        }"
                    .unindent(),
-                    description: Some("call bar in foo".into()),
+                    description: "call bar in foo".into(),
                },
                AssistantEditKind::InsertAfter {
                    old_text: "
@@ -757,7 +762,7 @@ mod tests {
                        }
                    "
                    .unindent(),
-                    description: Some("implement qux".into()),
+                    description: "implement qux".into(),
                },
            ],
            "
@@ -809,7 +814,7 @@ mod tests {
                        }
                    "
                    .unindent(),
-                    description: None,
+                    description: "pick better number".into(),
                },
                AssistantEditKind::Update {
                    old_text: "
@@ -824,7 +829,7 @@ mod tests {
                        }
                    "
                    .unindent(),
-                    description: None,
+                    description: "pick better number".into(),
                },
                AssistantEditKind::Update {
                    old_text: "
@@ -839,7 +844,7 @@ mod tests {
                        }
                    "
                    .unindent(),
-                    description: None,
+                    description: "pick better number".into(),
                },
            ],
            "
@@ -860,69 +865,6 @@ mod tests {
            .unindent(),
            cx,
        );
-
-        assert_edits(
-            "
-            impl Person {
-                fn set_name(&mut self, name: String) {
-                    self.name = name;
-                }
-
-                fn name(&self) -> String {
-                    return self.name;
-                }
-            }
-            "
-            .unindent(),
-            vec![
-                AssistantEditKind::Update {
-                    old_text: "self.name = name;".unindent(),
-                    new_text: "self._name = name;".unindent(),
-                    description: None,
-                },
-                AssistantEditKind::Update {
-                    old_text: "return self.name;\n".unindent(),
-                    new_text: "return self._name;\n".unindent(),
-                    description: None,
-                },
-            ],
-            "
-                impl Person {
-                    fn set_name(&mut self, name: String) {
-                        self._name = name;
-                    }
-
-                    fn name(&self) -> String {
-                        return self._name;
-                    }
-                }
-            "
-            .unindent(),
-            cx,
-        );
-    }
-
-    fn init_test(cx: &mut AppContext) {
-        let settings_store = SettingsStore::test(cx);
-        cx.set_global(settings_store);
-        language::init(cx);
-        cx.update_global::<SettingsStore, _>(|settings, cx| {
-            settings.update_user_settings::<AllLanguageSettings>(cx, |_| {});
-        });
-    }
-
-    #[track_caller]
-    fn assert_location_resolution(
-        text_with_expected_range: &str,
-        query: &str,
-        cx: &mut AppContext,
-    ) {
-        let (text, _) = marked_text_ranges(text_with_expected_range, false);
-        let buffer = cx.new_model(|cx| Buffer::local(text.clone(), cx));
-        let snapshot = buffer.read(cx).snapshot();
-        let range = AssistantEditKind::resolve_location(&snapshot, query).to_offset(&snapshot);
-        let text_with_actual_range = generate_marked_text(&text, &[range], false);
-        pretty_assertions::assert_eq!(text_with_actual_range, text_with_expected_range);
    }

    #[track_caller]
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -204,7 +204,7 @@ impl PromptBuilder {
        Ok(())
    }

-    pub fn generate_inline_transformation_prompt(
+    pub fn generate_content_prompt(
        &self,
        user_prompt: String,
        language_name: Option<&LanguageName>,
@@ -311,7 +311,7 @@ impl PromptBuilder {
    }

    pub fn generate_workflow_prompt(&self) -> Result<String, RenderError> {
-        self.handlebars.lock().render("suggest_edits", &())
+        self.handlebars.lock().render("edit_workflow", &())
    }

    pub fn generate_project_slash_command_prompt(
--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -31,10 +31,10 @@ pub mod now_command;
 pub mod project_command;
 pub mod prompt_command;
 pub mod search_command;
-pub mod streaming_example_command;
 pub mod symbols_command;
 pub mod tab_command;
 pub mod terminal_command;
+pub mod workflow_command;

 pub(crate) struct SlashCommandCompletionProvider {
    cancel_flag: Mutex<Arc<AtomicBool>>,
--- a/crates/assistant/src/slash_command/auto_command.rs
+++ b/crates/assistant/src/slash_command/auto_command.rs
@@ -1,8 +1,7 @@
+use super::create_label_for_command;
+use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use futures::StreamExt;
 use gpui::{AppContext, AsyncAppContext, Task, WeakView};
@@ -14,12 +13,10 @@ use language_model::{
 use semantic_index::{FileSummary, SemanticDb};
 use smol::channel;
 use std::sync::{atomic::AtomicBool, Arc};
-use ui::{prelude::*, BorrowAppContext, WindowContext};
+use ui::{BorrowAppContext, WindowContext};
 use util::ResultExt;
 use workspace::Workspace;

-use crate::slash_command::create_label_for_command;
-
 pub struct AutoSlashCommandFeatureFlag;

 impl FeatureFlag for AutoSlashCommandFeatureFlag {
@@ -37,10 +34,6 @@ impl SlashCommand for AutoCommand {
        "Automatically infer what context to add".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::Wand
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -99,7 +92,7 @@ impl SlashCommand for AutoCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let Some(workspace) = workspace.upgrade() else {
            return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
        };
@@ -151,8 +144,7 @@ impl SlashCommand for AutoCommand {
                text: prompt,
                sections: Vec::new(),
                run_commands_in_text: true,
-            }
-            .to_event_stream())
+            })
        })
    }
 }
--- a/crates/assistant/src/slash_command/cargo_workspace_command.rs
+++ b/crates/assistant/src/slash_command/cargo_workspace_command.rs
@@ -1,8 +1,6 @@
+use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use fs::Fs;
 use gpui::{AppContext, Model, Task, WeakView};
 use language::{BufferSnapshot, LspAdapterDelegate};
@@ -125,7 +123,7 @@ impl SlashCommand for CargoWorkspaceSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let output = workspace.update(cx, |workspace, cx| {
            let project = workspace.project().clone();
            let fs = workspace.project().read(cx).fs().clone();
@@ -147,8 +145,7 @@ impl SlashCommand for CargoWorkspaceSlashCommand {
                        metadata: None,
                    }],
                    run_commands_in_text: false,
-                }
-                .to_event_stream())
+                })
            })
        });
        output.unwrap_or_else(|error| Task::ready(Err(error)))
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -1,7 +1,8 @@
+use super::create_label_for_command;
 use anyhow::{anyhow, Result};
 use assistant_slash_command::{
    AfterCompletion, ArgumentCompletion, SlashCommand, SlashCommandOutput,
-    SlashCommandOutputSection, SlashCommandResult,
+    SlashCommandOutputSection,
 };
 use collections::HashMap;
 use context_servers::{
@@ -16,8 +17,6 @@ use text::LineEnding;
 use ui::{IconName, SharedString};
 use workspace::Workspace;

-use crate::slash_command::create_label_for_command;
-
 pub struct ContextServerSlashCommand {
    server_id: String,
    prompt: Prompt,
@@ -129,7 +128,7 @@ impl SlashCommand for ContextServerSlashCommand {
        _workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let server_id = self.server_id.clone();
        let prompt_name = self.prompt.name.clone();

@@ -185,8 +184,7 @@ impl SlashCommand for ContextServerSlashCommand {
                    }],
                    text: prompt,
                    run_commands_in_text: false,
-                }
-                .to_event_stream())
+                })
            })
        } else {
            Task::ready(Err(anyhow!("Context server not found")))
--- a/crates/assistant/src/slash_command/default_command.rs
+++ b/crates/assistant/src/slash_command/default_command.rs
@@ -1,9 +1,7 @@
+use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{Task, WeakView};
 use language::{BufferSnapshot, LspAdapterDelegate};
 use std::{
@@ -50,7 +48,7 @@ impl SlashCommand for DefaultSlashCommand {
        _workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let store = PromptStore::global(cx);
        cx.background_executor().spawn(async move {
            let store = store.await?;
@@ -78,8 +76,7 @@ impl SlashCommand for DefaultSlashCommand {
                }],
                text,
                run_commands_in_text: true,
-            }
-            .to_event_stream())
+            })
        })
    }
 }
--- a/crates/assistant/src/slash_command/delta_command.rs
+++ b/crates/assistant/src/slash_command/delta_command.rs
@@ -1,8 +1,7 @@
 use crate::slash_command::file_command::{FileCommandMetadata, FileSlashCommand};
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
 };
 use collections::HashSet;
 use futures::future;
@@ -10,7 +9,6 @@ use gpui::{Task, WeakView, WindowContext};
 use language::{BufferSnapshot, LspAdapterDelegate};
 use std::sync::{atomic::AtomicBool, Arc};
 use text::OffsetRangeExt;
-use ui::prelude::*;
 use workspace::Workspace;

 pub(crate) struct DeltaSlashCommand;
@@ -28,10 +26,6 @@ impl SlashCommand for DeltaSlashCommand {
        self.description()
    }

-    fn icon(&self) -> IconName {
-        IconName::Diff
-    }
-
    fn requires_argument(&self) -> bool {
        false
    }
@@ -43,7 +37,7 @@ impl SlashCommand for DeltaSlashCommand {
        _workspace: Option<WeakView<Workspace>>,
        _cx: &mut WindowContext,
    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Err(anyhow!("this command does not require argument")))
+        unimplemented!()
    }

    fn run(
@@ -54,7 +48,7 @@ impl SlashCommand for DeltaSlashCommand {
        workspace: WeakView<Workspace>,
        delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let mut paths = HashSet::default();
        let mut file_command_old_outputs = Vec::new();
        let mut file_command_new_outputs = Vec::new();
@@ -91,28 +85,25 @@ impl SlashCommand for DeltaSlashCommand {
                .zip(file_command_new_outputs)
            {
                if let Ok(new_output) = new_output {
-                    if let Ok(new_output) = SlashCommandOutput::from_event_stream(new_output).await
-                    {
-                        if let Some(file_command_range) = new_output.sections.first() {
-                            let new_text = &new_output.text[file_command_range.range.clone()];
-                            if old_text.chars().ne(new_text.chars()) {
-                                output.sections.extend(new_output.sections.into_iter().map(
-                                    |section| SlashCommandOutputSection {
-                                        range: output.text.len() + section.range.start
-                                            ..output.text.len() + section.range.end,
-                                        icon: section.icon,
-                                        label: section.label,
-                                        metadata: section.metadata,
-                                    },
-                                ));
-                                output.text.push_str(&new_output.text);
-                            }
+                    if let Some(file_command_range) = new_output.sections.first() {
+                        let new_text = &new_output.text[file_command_range.range.clone()];
+                        if old_text.chars().ne(new_text.chars()) {
+                            output.sections.extend(new_output.sections.into_iter().map(
+                                |section| SlashCommandOutputSection {
+                                    range: output.text.len() + section.range.start
+                                        ..output.text.len() + section.range.end,
+                                    icon: section.icon,
+                                    label: section.label,
+                                    metadata: section.metadata,
+                                },
+                            ));
+                            output.text.push_str(&new_output.text);
                        }
                    }
                }
            }

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

-use crate::slash_command::create_label_for_command;
-
 pub(crate) struct DiagnosticsSlashCommand;

 impl DiagnosticsSlashCommand {
@@ -98,10 +94,6 @@ impl SlashCommand for DiagnosticsSlashCommand {
        "Insert diagnostics".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::XCircle
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -175,7 +167,7 @@ impl SlashCommand for DiagnosticsSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let Some(workspace) = workspace.upgrade() else {
            return Task::ready(Err(anyhow!("workspace was dropped")));
        };
@@ -184,11 +176,7 @@ impl SlashCommand for DiagnosticsSlashCommand {

        let task = collect_diagnostics(workspace.read(cx).project().clone(), options, cx);

-        cx.spawn(move |_| async move {
-            task.await?
-                .map(|output| output.to_event_stream())
-                .ok_or_else(|| anyhow!("No diagnostics found"))
-        })
+        cx.spawn(move |_| async move { task.await?.ok_or_else(|| anyhow!("No diagnostics found")) })
    }
 }

--- a/crates/assistant/src/slash_command/docs_command.rs
+++ b/crates/assistant/src/slash_command/docs_command.rs
@@ -6,7 +6,6 @@ use std::time::Duration;
 use anyhow::{anyhow, bail, Result};
 use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
 };
 use gpui::{AppContext, BackgroundExecutor, Model, Task, WeakView};
 use indexed_docs::{
@@ -275,7 +274,7 @@ impl SlashCommand for DocsSlashCommand {
        _workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        if arguments.is_empty() {
            return Task::ready(Err(anyhow!("missing an argument")));
        };
@@ -356,8 +355,7 @@ impl SlashCommand for DocsSlashCommand {
                    })
                    .collect(),
                run_commands_in_text: false,
-            }
-            .to_event_stream())
+            })
        })
    }
 }
--- a/crates/assistant/src/slash_command/fetch_command.rs
+++ b/crates/assistant/src/slash_command/fetch_command.rs
@@ -6,7 +6,6 @@ use std::sync::Arc;
 use anyhow::{anyhow, bail, Context, Result};
 use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
 };
 use futures::AsyncReadExt;
 use gpui::{Task, WeakView};
@@ -134,7 +133,7 @@ impl SlashCommand for FetchSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let Some(argument) = arguments.first() else {
            return Task::ready(Err(anyhow!("missing URL")));
        };
@@ -167,8 +166,7 @@ impl SlashCommand for FetchSlashCommand {
                    metadata: None,
                }],
                run_commands_in_text: false,
-            }
-            .to_event_stream())
+            })
        })
    }
 }
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -1,16 +1,11 @@
+use super::{diagnostics_command::collect_buffer_diagnostics, SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context as _, Result};
-use assistant_slash_command::{
-    AfterCompletion, ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,
-    SlashCommandOutput, SlashCommandOutputSection, SlashCommandResult,
-};
-use futures::channel::mpsc;
-use futures::Stream;
+use assistant_slash_command::{AfterCompletion, ArgumentCompletion, SlashCommandOutputSection};
 use fuzzy::PathMatch;
 use gpui::{AppContext, Model, Task, View, WeakView};
 use language::{BufferSnapshot, CodeLabel, HighlightId, LineEnding, LspAdapterDelegate};
 use project::{PathMatchCandidateSet, Project};
 use serde::{Deserialize, Serialize};
-use smol::stream::StreamExt;
 use std::{
    fmt::Write,
    ops::{Range, RangeInclusive},
@@ -21,8 +16,6 @@ use ui::prelude::*;
 use util::ResultExt;
 use workspace::Workspace;

-use crate::slash_command::diagnostics_command::collect_buffer_diagnostics;
-
 pub(crate) struct FileSlashCommand;

 impl FileSlashCommand {
@@ -117,7 +110,7 @@ impl SlashCommand for FileSlashCommand {
    }

    fn description(&self) -> String {
-        "Insert file and/or directory".into()
+        "Insert file".into()
    }

    fn menu_text(&self) -> String {
@@ -128,10 +121,6 @@ impl SlashCommand for FileSlashCommand {
        true
    }

-    fn icon(&self) -> IconName {
-        IconName::File
-    }
-
    fn complete_argument(
        self: Arc<Self>,
        arguments: &[String],
@@ -192,7 +181,7 @@ impl SlashCommand for FileSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let Some(workspace) = workspace.upgrade() else {
            return Task::ready(Err(anyhow!("workspace was dropped")));
        };
@@ -201,12 +190,7 @@ impl SlashCommand for FileSlashCommand {
            return Task::ready(Err(anyhow!("missing path")));
        };

-        Task::ready(Ok(collect_files(
-            workspace.read(cx).project().clone(),
-            arguments,
-            cx,
-        )
-        .boxed()))
+        collect_files(workspace.read(cx).project().clone(), arguments, cx)
    }
 }

@@ -214,7 +198,7 @@ fn collect_files(
    project: Model<Project>,
    glob_inputs: &[String],
    cx: &mut AppContext,
-) -> impl Stream<Item = Result<SlashCommandEvent>> {
+) -> Task<Result<SlashCommandOutput>> {
    let Ok(matchers) = glob_inputs
        .into_iter()
        .map(|glob_input| {
@@ -223,7 +207,7 @@ fn collect_files(
        })
        .collect::<anyhow::Result<Vec<custom_path_matcher::PathMatcher>>>()
    else {
-        return futures::stream::once(async { Err(anyhow!("invalid path")) }).boxed();
+        return Task::ready(Err(anyhow!("invalid path")));
    };

    let project_handle = project.downgrade();
@@ -233,11 +217,11 @@ fn collect_files(
        .map(|worktree| worktree.read(cx).snapshot())
        .collect::<Vec<_>>();

-    let (events_tx, events_rx) = mpsc::unbounded();
    cx.spawn(|mut cx| async move {
+        let mut output = SlashCommandOutput::default();
        for snapshot in snapshots {
            let worktree_id = snapshot.id();
-            let mut directory_stack: Vec<Arc<Path>> = Vec::new();
+            let mut directory_stack: Vec<(Arc<Path>, String, usize)> = Vec::new();
            let mut folded_directory_names_stack = Vec::new();
            let mut is_top_level_directory = true;

@@ -253,19 +237,17 @@ fn collect_files(
                    continue;
                }

-                while let Some(dir) = directory_stack.last() {
+                while let Some((dir, _, _)) = directory_stack.last() {
                    if entry.path.starts_with(dir) {
                        break;
                    }
-                    directory_stack.pop().unwrap();
-                    events_tx
-                        .unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                        SlashCommandContent::Text {
-                            text: "\n".into(),
-                            run_commands_in_text: false,
-                        },
-                    )))?;
+                    let (_, entry_name, start) = directory_stack.pop().unwrap();
+                    output.sections.push(build_entry_output_section(
+                        start..output.text.len().saturating_sub(1),
+                        Some(&PathBuf::from(entry_name)),
+                        true,
+                        None,
+                    ));
                }

                let filename = entry
@@ -297,46 +279,23 @@ fn collect_files(
                        continue;
                    }
                    let prefix_paths = folded_directory_names_stack.drain(..).as_slice().join("/");
+                    let entry_start = output.text.len();
                    if prefix_paths.is_empty() {
-                        let label = if is_top_level_directory {
+                        if is_top_level_directory {
+                            output
+                                .text
+                                .push_str(&path_including_worktree_name.to_string_lossy());
                            is_top_level_directory = false;
-                            path_including_worktree_name.to_string_lossy().to_string()
                        } else {
-                            filename
-                        };
-                        events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                            icon: IconName::Folder,
-                            label: label.clone().into(),
-                            metadata: None,
-                        }))?;
-                        events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                            SlashCommandContent::Text {
-                                text: label,
-                                run_commands_in_text: false,
-                            },
-                        )))?;
-                        directory_stack.push(entry.path.clone());
+                            output.text.push_str(&filename);
+                        }
+                        directory_stack.push((entry.path.clone(), filename, entry_start));
                    } else {
                        let entry_name = format!("{}/{}", prefix_paths, &filename);
-                        events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                            icon: IconName::Folder,
-                            label: entry_name.clone().into(),
-                            metadata: None,
-                        }))?;
-                        events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                            SlashCommandContent::Text {
-                                text: entry_name,
-                                run_commands_in_text: false,
-                            },
-                        )))?;
-                        directory_stack.push(entry.path.clone());
+                        output.text.push_str(&entry_name);
+                        directory_stack.push((entry.path.clone(), entry_name, entry_start));
                    }
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                        SlashCommandContent::Text {
-                            text: "\n".into(),
-                            run_commands_in_text: false,
-                        },
-                    )))?;
+                    output.text.push('\n');
                } else if entry.is_file() {
                    let Some(open_buffer_task) = project_handle
                        .update(&mut cx, |project, cx| {
@@ -347,7 +306,6 @@ fn collect_files(
                        continue;
                    };
                    if let Some(buffer) = open_buffer_task.await.log_err() {
-                        let mut output = SlashCommandOutput::default();
                        let snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot())?;
                        append_buffer_to_output(
                            &snapshot,
@@ -355,24 +313,33 @@ fn collect_files(
                            &mut output,
                        )
                        .log_err();
-                        let mut buffer_events = output.to_event_stream();
-                        while let Some(event) = buffer_events.next().await {
-                            events_tx.unbounded_send(event)?;
-                        }
                    }
                }
            }

-            while let Some(_) = directory_stack.pop() {
-                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
+            while let Some((dir, entry, start)) = directory_stack.pop() {
+                if directory_stack.is_empty() {
+                    let mut root_path = PathBuf::new();
+                    root_path.push(snapshot.root_name());
+                    root_path.push(&dir);
+                    output.sections.push(build_entry_output_section(
+                        start..output.text.len(),
+                        Some(&root_path),
+                        true,
+                        None,
+                    ));
+                } else {
+                    output.sections.push(build_entry_output_section(
+                        start..output.text.len(),
+                        Some(&PathBuf::from(entry.as_str())),
+                        true,
+                        None,
+                    ));
+                }
            }
        }
-
-        anyhow::Ok(())
+        Ok(output)
    })
-    .detach_and_log_err(cx);
-
-    events_rx.boxed()
 }

 pub fn codeblock_fence_for_path(
@@ -557,14 +524,11 @@ pub fn append_buffer_to_output(

 #[cfg(test)]
 mod test {
-    use assistant_slash_command::SlashCommandOutput;
    use fs::FakeFs;
    use gpui::TestAppContext;
-    use pretty_assertions::assert_eq;
    use project::Project;
    use serde_json::json;
    use settings::SettingsStore;
-    use smol::stream::StreamExt;

    use crate::slash_command::file_command::collect_files;

@@ -605,9 +569,8 @@ mod test {

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

-        let result_1 =
-            cx.update(|cx| collect_files(project.clone(), &["root/dir".to_string()], cx));
-        let result_1 = SlashCommandOutput::from_event_stream(result_1.boxed())
+        let result_1 = cx
+            .update(|cx| collect_files(project.clone(), &["root/dir".to_string()], cx))
            .await
            .unwrap();

@@ -615,17 +578,17 @@ mod test {
        // 4 files + 2 directories
        assert_eq!(result_1.sections.len(), 6);

-        let result_2 =
-            cx.update(|cx| collect_files(project.clone(), &["root/dir/".to_string()], cx));
-        let result_2 = SlashCommandOutput::from_event_stream(result_2.boxed())
+        let result_2 = cx
+            .update(|cx| collect_files(project.clone(), &["root/dir/".to_string()], cx))
            .await
            .unwrap();

        assert_eq!(result_1, result_2);

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

        assert!(result.text.starts_with("root/dir"));
        // 5 files + 2 directories
@@ -668,9 +631,8 @@ mod test {

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

-        let result =
-            cx.update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx));
-        let result = SlashCommandOutput::from_event_stream(result.boxed())
+        let result = cx
+            .update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx))
            .await
            .unwrap();

@@ -730,9 +692,8 @@ mod test {

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

-        let result =
-            cx.update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx));
-        let result = SlashCommandOutput::from_event_stream(result.boxed())
+        let result = cx
+            .update(|cx| collect_files(project.clone(), &["zed/assets/themes".to_string()], cx))
            .await
            .unwrap();

@@ -755,8 +716,6 @@ mod test {
        assert_eq!(result.sections[6].label, "summercamp");
        assert_eq!(result.sections[7].label, "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");
-
        // Ensure that the project lasts until after the last await
        drop(project);
    }
--- a/crates/assistant/src/slash_command/now_command.rs
+++ b/crates/assistant/src/slash_command/now_command.rs
@@ -4,7 +4,6 @@ use std::sync::Arc;
 use anyhow::Result;
 use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
 };
 use chrono::Local;
 use gpui::{Task, WeakView};
@@ -49,7 +48,7 @@ impl SlashCommand for NowSlashCommand {
        _workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        _cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let now = Local::now();
        let text = format!("Today is {now}.", now = now.to_rfc2822());
        let range = 0..text.len();
@@ -63,7 +62,6 @@ impl SlashCommand for NowSlashCommand {
                metadata: None,
            }],
            run_commands_in_text: false,
-        }
-        .to_event_stream()))
+        }))
    }
 }
--- a/crates/assistant/src/slash_command/project_command.rs
+++ b/crates/assistant/src/slash_command/project_command.rs
@@ -4,7 +4,7 @@ use super::{
 };
 use crate::PromptBuilder;
 use anyhow::{anyhow, Result};
-use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection, SlashCommandResult};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use gpui::{AppContext, Task, WeakView, WindowContext};
 use language::{Anchor, CodeLabel, LspAdapterDelegate};
@@ -24,8 +24,7 @@ use std::{
    ops::DerefMut,
    sync::{atomic::AtomicBool, Arc},
 };
-
-use ui::prelude::*;
+use ui::{BorrowAppContext as _, IconName};
 use workspace::Workspace;

 pub struct ProjectSlashCommand {
@@ -51,10 +50,6 @@ impl SlashCommand for ProjectSlashCommand {
        "Generate a semantic search based on context".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::Folder
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -81,7 +76,7 @@ impl SlashCommand for ProjectSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let model_registry = LanguageModelRegistry::read_global(cx);
        let current_model = model_registry.active_model();
        let prompt_builder = self.prompt_builder.clone();
@@ -167,8 +162,7 @@ impl SlashCommand for ProjectSlashCommand {
                        text: output,
                        sections,
                        run_commands_in_text: true,
-                    }
-                    .to_event_stream())
+                    })
                })
                .await
        })
--- a/crates/assistant/src/slash_command/prompt_command.rs
+++ b/crates/assistant/src/slash_command/prompt_command.rs
@@ -1,9 +1,7 @@
+use super::{SlashCommand, SlashCommandOutput};
 use crate::prompt_library::PromptStore;
 use anyhow::{anyhow, Context, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use gpui::{Task, WeakView};
 use language::{BufferSnapshot, LspAdapterDelegate};
 use std::sync::{atomic::AtomicBool, Arc};
@@ -21,10 +19,6 @@ impl SlashCommand for PromptSlashCommand {
        "Insert prompt from library".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::Library
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -67,7 +61,7 @@ impl SlashCommand for PromptSlashCommand {
        _workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let title = arguments.to_owned().join(" ");
        if title.trim().is_empty() {
            return Task::ready(Err(anyhow!("missing prompt name")));
@@ -106,8 +100,7 @@ impl SlashCommand for PromptSlashCommand {
                    metadata: None,
                }],
                run_commands_in_text: true,
-            }
-            .to_event_stream())
+            })
        })
    }
 }
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -1,8 +1,10 @@
-use anyhow::Result;
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
+use super::{
+    create_label_for_command,
+    file_command::{build_entry_output_section, codeblock_fence_for_path},
+    SlashCommand, SlashCommandOutput,
 };
+use anyhow::Result;
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use feature_flags::FeatureFlag;
 use gpui::{AppContext, Task, WeakView};
 use language::{CodeLabel, LspAdapterDelegate};
@@ -14,9 +16,6 @@ use std::{
 use ui::{prelude::*, IconName};
 use workspace::Workspace;

-use crate::slash_command::create_label_for_command;
-use crate::slash_command::file_command::{build_entry_output_section, codeblock_fence_for_path};
-
 pub(crate) struct SearchSlashCommandFeatureFlag;

 impl FeatureFlag for SearchSlashCommandFeatureFlag {
@@ -38,10 +37,6 @@ impl SlashCommand for SearchSlashCommand {
        "Search your project semantically".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::SearchCode
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -68,7 +63,7 @@ impl SlashCommand for SearchSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let Some(workspace) = workspace.upgrade() else {
            return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
        };
@@ -134,7 +129,6 @@ impl SlashCommand for SearchSlashCommand {
                        sections,
                        run_commands_in_text: false,
                    }
-                    .to_event_stream()
                })
                .await;

--- a/crates/assistant/src/slash_command/streaming_example_command.rs
+++ b/crates/assistant/src/slash_command/streaming_example_command.rs
@@ -1,136 +0,0 @@
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-use std::time::Duration;
-
-use anyhow::Result;
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,
-    SlashCommandOutputSection, SlashCommandResult,
-};
-use feature_flags::FeatureFlag;
-use futures::channel::mpsc;
-use gpui::{Task, WeakView};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use smol::stream::StreamExt;
-use smol::Timer;
-use ui::prelude::*;
-use workspace::Workspace;
-
-pub struct StreamingExampleSlashCommandFeatureFlag;
-
-impl FeatureFlag for StreamingExampleSlashCommandFeatureFlag {
-    const NAME: &'static str = "streaming-example-slash-command";
-}
-
-pub(crate) struct StreamingExampleSlashCommand;
-
-impl SlashCommand for StreamingExampleSlashCommand {
-    fn name(&self) -> String {
-        "streaming-example".into()
-    }
-
-    fn description(&self) -> String {
-        "An example slash command that showcases streaming.".into()
-    }
-
-    fn menu_text(&self) -> String {
-        self.description()
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Ok(Vec::new()))
-    }
-
-    fn run(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
-        _workspace: WeakView<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
-        let (events_tx, events_rx) = mpsc::unbounded();
-        cx.background_executor()
-            .spawn(async move {
-                events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                    icon: IconName::FileRust,
-                    label: "Section 1".into(),
-                    metadata: None,
-                }))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                    SlashCommandContent::Text {
-                        text: "Hello".into(),
-                        run_commands_in_text: false,
-                    },
-                )))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                    SlashCommandContent::Text {
-                        text: "\n".into(),
-                        run_commands_in_text: false,
-                    },
-                )))?;
-
-                Timer::after(Duration::from_secs(1)).await;
-
-                events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                    icon: IconName::FileRust,
-                    label: "Section 2".into(),
-                    metadata: None,
-                }))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                    SlashCommandContent::Text {
-                        text: "World".into(),
-                        run_commands_in_text: false,
-                    },
-                )))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                    SlashCommandContent::Text {
-                        text: "\n".into(),
-                        run_commands_in_text: false,
-                    },
-                )))?;
-
-                for n in 1..=10 {
-                    Timer::after(Duration::from_secs(1)).await;
-
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                        icon: IconName::StarFilled,
-                        label: format!("Section {n}").into(),
-                        metadata: None,
-                    }))?;
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                        SlashCommandContent::Text {
-                            text: "lorem ipsum ".repeat(n).trim().into(),
-                            run_commands_in_text: false,
-                        },
-                    )))?;
-                    events_tx
-                        .unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                        SlashCommandContent::Text {
-                            text: "\n".into(),
-                            run_commands_in_text: false,
-                        },
-                    )))?;
-                }
-
-                anyhow::Ok(())
-            })
-            .detach_and_log_err(cx);
-
-        Task::ready(Ok(events_rx.boxed()))
-    }
-}
--- a/crates/assistant/src/slash_command/symbols_command.rs
+++ b/crates/assistant/src/slash_command/symbols_command.rs
@@ -1,8 +1,6 @@
+use super::{SlashCommand, SlashCommandOutput};
 use anyhow::{anyhow, Context as _, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use editor::Editor;
 use gpui::{Task, WeakView};
 use language::{BufferSnapshot, LspAdapterDelegate};
@@ -22,10 +20,6 @@ impl SlashCommand for OutlineSlashCommand {
        "Insert symbols for active tab".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::ListTree
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -52,7 +46,7 @@ impl SlashCommand for OutlineSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let output = workspace.update(cx, |workspace, cx| {
            let Some(active_item) = workspace.active_item(cx) else {
                return Task::ready(Err(anyhow!("no active tab")));
@@ -89,8 +83,7 @@ impl SlashCommand for OutlineSlashCommand {
                    }],
                    text: outline_text,
                    run_commands_in_text: false,
-                }
-                .to_event_stream())
+                })
            })
        });

--- a/crates/assistant/src/slash_command/tab_command.rs
+++ b/crates/assistant/src/slash_command/tab_command.rs
@@ -1,8 +1,6 @@
+use super::{file_command::append_buffer_to_output, SlashCommand, SlashCommandOutput};
 use anyhow::{Context, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
-};
+use assistant_slash_command::{ArgumentCompletion, SlashCommandOutputSection};
 use collections::{HashMap, HashSet};
 use editor::Editor;
 use futures::future::join_all;
@@ -12,12 +10,10 @@ use std::{
    path::PathBuf,
    sync::{atomic::AtomicBool, Arc},
 };
-use ui::{prelude::*, ActiveTheme, WindowContext};
+use ui::{ActiveTheme, WindowContext};
 use util::ResultExt;
 use workspace::Workspace;

-use crate::slash_command::file_command::append_buffer_to_output;
-
 pub(crate) struct TabSlashCommand;

 const ALL_TABS_COMPLETION_ITEM: &str = "all";
@@ -31,10 +27,6 @@ impl SlashCommand for TabSlashCommand {
        "Insert open tabs (active tab by default)".to_owned()
    }

-    fn icon(&self) -> IconName {
-        IconName::FileTree
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -140,7 +132,7 @@ impl SlashCommand for TabSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let tab_items_search = tab_items_for_queries(
            Some(workspace),
            arguments,
@@ -154,7 +146,7 @@ impl SlashCommand for TabSlashCommand {
            for (full_path, buffer, _) in tab_items_search.await? {
                append_buffer_to_output(&buffer, full_path.as_deref(), &mut output).log_err();
            }
-            Ok(output.to_event_stream())
+            Ok(output)
        })
    }
 }
--- a/crates/assistant/src/slash_command/terminal_command.rs
+++ b/crates/assistant/src/slash_command/terminal_command.rs
@@ -4,7 +4,6 @@ use std::sync::Arc;
 use anyhow::Result;
 use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
-    SlashCommandResult,
 };
 use gpui::{AppContext, Task, View, WeakView};
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
@@ -33,10 +32,6 @@ impl SlashCommand for TerminalSlashCommand {
        "Insert terminal output".into()
    }

-    fn icon(&self) -> IconName {
-        IconName::Terminal
-    }
-
    fn menu_text(&self) -> String {
        self.description()
    }
@@ -67,7 +62,7 @@ impl SlashCommand for TerminalSlashCommand {
        workspace: WeakView<Workspace>,
        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
+    ) -> Task<Result<SlashCommandOutput>> {
        let Some(workspace) = workspace.upgrade() else {
            return Task::ready(Err(anyhow::anyhow!("workspace was dropped")));
        };
@@ -101,8 +96,7 @@ impl SlashCommand for TerminalSlashCommand {
                metadata: None,
            }],
            run_commands_in_text: false,
-        }
-        .to_event_stream()))
+        }))
    }
 }

--- a/crates/assistant/src/slash_command/workflow_command.rs
+++ b/crates/assistant/src/slash_command/workflow_command.rs
@@ -0,0 +1,81 @@
+use crate::prompts::PromptBuilder;
+use std::sync::Arc;
+
+use std::sync::atomic::AtomicBool;
+
+use anyhow::Result;
+use assistant_slash_command::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+};
+use gpui::{Task, WeakView};
+use language::{BufferSnapshot, LspAdapterDelegate};
+use ui::prelude::*;
+
+use workspace::Workspace;
+
+pub(crate) struct WorkflowSlashCommand {
+    prompt_builder: Arc<PromptBuilder>,
+}
+
+impl WorkflowSlashCommand {
+    pub const NAME: &'static str = "workflow";
+
+    pub fn new(prompt_builder: Arc<PromptBuilder>) -> Self {
+        Self { prompt_builder }
+    }
+}
+
+impl SlashCommand for WorkflowSlashCommand {
+    fn name(&self) -> String {
+        Self::NAME.into()
+    }
+
+    fn description(&self) -> String {
+        "Insert prompt to opt into the edit workflow".into()
+    }
+
+    fn menu_text(&self) -> String {
+        self.description()
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        _cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        Task::ready(Ok(Vec::new()))
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
+        _workspace: WeakView<Workspace>,
+        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let prompt_builder = self.prompt_builder.clone();
+        cx.spawn(|_cx| async move {
+            let text = prompt_builder.generate_workflow_prompt()?;
+            let range = 0..text.len();
+
+            Ok(SlashCommandOutput {
+                text,
+                sections: vec![SlashCommandOutputSection {
+                    range,
+                    icon: IconName::Route,
+                    label: "Workflow".into(),
+                    metadata: None,
+                }],
+                run_commands_in_text: false,
+            })
+        })
+    }
+}
--- a/crates/assistant/src/slash_command_picker.rs
+++ b/crates/assistant/src/slash_command_picker.rs
@@ -1,13 +1,19 @@
 use std::sync::Arc;

 use assistant_slash_command::SlashCommandRegistry;
+use gpui::AnyElement;
+use gpui::DismissEvent;
+use gpui::WeakView;
+use picker::PickerEditorPosition;

-use gpui::{AnyElement, DismissEvent, SharedString, Task, WeakView};
-use picker::{Picker, PickerDelegate, PickerEditorPosition};
-use ui::{prelude::*, KeyBinding, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger};
+use ui::ListItemSpacing;
+
+use gpui::SharedString;
+use gpui::Task;
+use picker::{Picker, PickerDelegate};
+use ui::{prelude::*, ListItem, PopoverMenu, PopoverTrigger};

 use crate::assistant_panel::ContextEditor;
-use crate::QuoteSelection;

 #[derive(IntoElement)]
 pub(super) struct SlashCommandSelector<T: PopoverTrigger> {
@@ -21,7 +27,6 @@ struct SlashCommandInfo {
    name: SharedString,
    description: SharedString,
    args: Option<SharedString>,
-    icon: IconName,
 }

 #[derive(Clone)]
@@ -32,7 +37,6 @@ enum SlashCommandEntry {
        renderer: fn(&mut WindowContext<'_>) -> AnyElement,
        on_confirm: fn(&mut WindowContext<'_>),
    },
-    QuoteButton,
 }

 impl AsRef<str> for SlashCommandEntry {
@@ -40,7 +44,6 @@ impl AsRef<str> for SlashCommandEntry {
        match self {
            SlashCommandEntry::Info(SlashCommandInfo { name, .. })
            | SlashCommandEntry::Advert { name, .. } => name,
-            SlashCommandEntry::QuoteButton => "Quote Selection",
        }
    }
 }
@@ -142,23 +145,16 @@ impl PickerDelegate for SlashCommandDelegate {
        }
        ret
    }
-
    fn confirm(&mut self, _secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
        if let Some(command) = self.filtered_commands.get(self.selected_index) {
-            match command {
-                SlashCommandEntry::Info(info) => {
-                    self.active_context_editor
-                        .update(cx, |context_editor, cx| {
-                            context_editor.insert_command(&info.name, cx)
-                        })
-                        .ok();
-                }
-                SlashCommandEntry::QuoteButton => {
-                    cx.dispatch_action(Box::new(QuoteSelection));
-                }
-                SlashCommandEntry::Advert { on_confirm, .. } => {
-                    on_confirm(cx);
-                }
+            if let SlashCommandEntry::Info(info) = command {
+                self.active_context_editor
+                    .update(cx, |context_editor, cx| {
+                        context_editor.insert_command(&info.name, cx)
+                    })
+                    .ok();
+            } else if let SlashCommandEntry::Advert { on_confirm, .. } = command {
+                on_confirm(cx);
            }
            cx.emit(DismissEvent);
        }
@@ -182,85 +178,53 @@ impl PickerDelegate for SlashCommandDelegate {
            SlashCommandEntry::Info(info) => Some(
                ListItem::new(ix)
                    .inset(true)
-                    .spacing(ListItemSpacing::Dense)
+                    .spacing(ListItemSpacing::Sparse)
                    .selected(selected)
                    .child(
-                        v_flex()
+                        h_flex()
                            .group(format!("command-entry-label-{ix}"))
                            .w_full()
                            .min_w(px(250.))
                            .child(
-                                h_flex()
-                                    .gap_1p5()
-                                    .child(Icon::new(info.icon).size(IconSize::XSmall))
-                                    .child(div().font_buffer(cx).child({
-                                        let mut label = format!("{}", info.name);
-                                        if let Some(args) = info.args.as_ref().filter(|_| selected)
-                                        {
-                                            label.push_str(&args);
-                                        }
-                                        Label::new(label).size(LabelSize::Small)
-                                    }))
-                                    .children(info.args.clone().filter(|_| !selected).map(
-                                        |args| {
-                                            div()
-                                                .font_buffer(cx)
-                                                .child(
-                                                    Label::new(args)
-                                                        .size(LabelSize::Small)
-                                                        .color(Color::Muted),
-                                                )
-                                                .visible_on_hover(format!(
-                                                    "command-entry-label-{ix}"
-                                                ))
-                                        },
-                                    )),
-                            )
-                            .child(
-                                Label::new(info.description.clone())
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
+                                v_flex()
+                                    .child(
+                                        h_flex()
+                                            .child(div().font_buffer(cx).child({
+                                                let mut label = format!("/{}", info.name);
+                                                if let Some(args) =
+                                                    info.args.as_ref().filter(|_| selected)
+                                                {
+                                                    label.push_str(&args);
+                                                }
+                                                Label::new(label).size(LabelSize::Small)
+                                            }))
+                                            .children(info.args.clone().filter(|_| !selected).map(
+                                                |args| {
+                                                    div()
+                                                        .font_buffer(cx)
+                                                        .child(
+                                                            Label::new(args)
+                                                                .size(LabelSize::Small)
+                                                                .color(Color::Muted),
+                                                        )
+                                                        .visible_on_hover(format!(
+                                                            "command-entry-label-{ix}"
+                                                        ))
+                                                },
+                                            )),
+                                    )
+                                    .child(
+                                        Label::new(info.description.clone())
+                                            .size(LabelSize::Small)
+                                            .color(Color::Muted),
+                                    ),
                            ),
                    ),
            ),
-            SlashCommandEntry::QuoteButton => {
-                let focus = cx.focus_handle();
-                let key_binding = KeyBinding::for_action_in(&QuoteSelection, &focus, cx);
-
-                Some(
-                    ListItem::new(ix)
-                        .inset(true)
-                        .spacing(ListItemSpacing::Dense)
-                        .selected(selected)
-                        .child(
-                            v_flex()
-                                .child(
-                                    h_flex()
-                                        .gap_1p5()
-                                        .child(Icon::new(IconName::Quote).size(IconSize::XSmall))
-                                        .child(
-                                            div().font_buffer(cx).child(
-                                                Label::new("selection").size(LabelSize::Small),
-                                            ),
-                                        ),
-                                )
-                                .child(
-                                    h_flex()
-                                        .gap_1p5()
-                                        .child(
-                                            Label::new("Insert editor selection")
-                                                .color(Color::Muted)
-                                                .size(LabelSize::Small),
-                                        )
-                                        .children(key_binding.map(|kb| kb.render(cx))),
-                                ),
-                        ),
-                )
-            }
            SlashCommandEntry::Advert { renderer, .. } => Some(
                ListItem::new(ix)
                    .inset(true)
-                    .spacing(ListItemSpacing::Dense)
+                    .spacing(ListItemSpacing::Sparse)
                    .selected(selected)
                    .child(renderer(cx)),
            ),
@@ -287,50 +251,31 @@ impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
                    name: command_name.into(),
                    description: menu_text,
                    args,
-                    icon: command.icon(),
                }))
            })
-            .chain([
-                SlashCommandEntry::Advert {
-                    name: "create-your-command".into(),
-                    renderer: |cx| {
-                        v_flex()
-                            .w_full()
-                            .child(
-                                h_flex()
-                                    .w_full()
-                                    .font_buffer(cx)
-                                    .items_center()
-                                    .justify_between()
-                                    .child(
-                                        h_flex()
-                                            .items_center()
-                                            .gap_1p5()
-                                            .child(Icon::new(IconName::Plus).size(IconSize::XSmall))
-                                            .child(
-                                                div().font_buffer(cx).child(
-                                                    Label::new("create-your-command")
-                                                        .size(LabelSize::Small),
-                                                ),
-                                            ),
-                                    )
-                                    .child(
-                                        Icon::new(IconName::ArrowUpRight)
-                                            .size(IconSize::XSmall)
-                                            .color(Color::Muted),
-                                    ),
-                            )
-                            .child(
-                                Label::new("Create your custom command")
-                                    .size(LabelSize::Small)
-                                    .color(Color::Muted),
-                            )
-                            .into_any_element()
-                    },
-                    on_confirm: |cx| cx.open_url("https://zed.dev/docs/extensions/slash-commands"),
+            .chain([SlashCommandEntry::Advert {
+                name: "create-your-command".into(),
+                renderer: |cx| {
+                    v_flex()
+                        .child(
+                            h_flex()
+                                .font_buffer(cx)
+                                .items_center()
+                                .gap_1()
+                                .child(div().font_buffer(cx).child(
+                                    Label::new("create-your-command").size(LabelSize::Small),
+                                ))
+                                .child(Icon::new(IconName::ArrowUpRight).size(IconSize::XSmall)),
+                        )
+                        .child(
+                            Label::new("Learn how to create a custom command")
+                                .size(LabelSize::Small)
+                                .color(Color::Muted),
+                        )
+                        .into_any_element()
                },
-                SlashCommandEntry::QuoteButton,
-            ])
+                on_confirm: |cx| cx.open_url("https://zed.dev/docs/extensions/slash-commands"),
+            }])
            .collect::<Vec<_>>();

        let delegate = SlashCommandDelegate {
--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -1,6 +1,6 @@
 use crate::{
    humanize_token_count, prompts::PromptBuilder, AssistantPanel, AssistantPanelEvent,
-    ModelSelector, RequestType, DEFAULT_CONTEXT_LINES,
+    ModelSelector, DEFAULT_CONTEXT_LINES,
 };
 use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
@@ -17,8 +17,7 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    logging::report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, Role,
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
 use settings::Settings;
 use std::{
@@ -252,7 +251,7 @@ impl TerminalInlineAssistant {
                        .read(cx)
                        .active_context(cx)?
                        .read(cx)
-                        .to_completion_request(RequestType::Chat, cx),
+                        .to_completion_request(cx),
                )
            })
        } else {
@@ -307,33 +306,6 @@ impl TerminalInlineAssistant {
                    this.focus_handle(cx).focus(cx);
                })
                .log_err();
-
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                let codegen = assist.codegen.read(cx);
-                let executor = cx.background_executor().clone();
-                report_assistant_event(
-                    AssistantEvent {
-                        conversation_id: None,
-                        kind: AssistantKind::InlineTerminal,
-                        message_id: codegen.message_id.clone(),
-                        phase: if undo {
-                            AssistantPhase::Rejected
-                        } else {
-                            AssistantPhase::Accepted
-                        },
-                        model: model.telemetry_id(),
-                        model_provider: model.provider_id().to_string(),
-                        response_latency: None,
-                        error_message: None,
-                        language_name: None,
-                    },
-                    codegen.telemetry.clone(),
-                    cx.http_client(),
-                    model.api_key(cx),
-                    &executor,
-                );
-            }
-
            assist.codegen.update(cx, |codegen, cx| {
                if undo {
                    codegen.undo(cx);
@@ -1044,7 +1016,6 @@ pub struct Codegen {
    telemetry: Option<Arc<Telemetry>>,
    terminal: Model<Terminal>,
    generation: Task<()>,
-    message_id: Option<String>,
    transaction: Option<TerminalTransaction>,
 }

@@ -1055,7 +1026,6 @@ impl Codegen {
            telemetry,
            status: CodegenStatus::Idle,
            generation: Task::ready(()),
-            message_id: None,
            transaction: None,
        }
    }
@@ -1065,8 +1035,6 @@ impl Codegen {
            return;
        };

-        let model_api_key = model.api_key(cx);
-        let http_client = cx.http_client();
        let telemetry = self.telemetry.clone();
        self.status = CodegenStatus::Pending;
        self.transaction = Some(TerminalTransaction::start(self.terminal.clone()));
@@ -1075,61 +1043,43 @@ impl Codegen {
            let model_provider_id = model.provider_id();
            let response = model.stream_completion_text(prompt, &cx).await;
            let generate = async {
-                let message_id = response
-                    .as_ref()
-                    .ok()
-                    .and_then(|response| response.message_id.clone());
-
                let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);

-                let task = cx.background_executor().spawn({
-                    let message_id = message_id.clone();
-                    let executor = cx.background_executor().clone();
-                    async move {
-                        let mut response_latency = None;
-                        let request_start = Instant::now();
-                        let task = async {
-                            let mut chunks = response?.stream;
-                            while let Some(chunk) = chunks.next().await {
-                                if response_latency.is_none() {
-                                    response_latency = Some(request_start.elapsed());
-                                }
-                                let chunk = chunk?;
-                                hunks_tx.send(chunk).await?;
+                let task = cx.background_executor().spawn(async move {
+                    let mut response_latency = None;
+                    let request_start = Instant::now();
+                    let task = async {
+                        let mut chunks = response?;
+                        while let Some(chunk) = chunks.next().await {
+                            if response_latency.is_none() {
+                                response_latency = Some(request_start.elapsed());
                            }
+                            let chunk = chunk?;
+                            hunks_tx.send(chunk).await?;
+                        }

-                            anyhow::Ok(())
-                        };
-
-                        let result = task.await;
-
-                        let error_message = result.as_ref().err().map(|error| error.to_string());
-                        report_assistant_event(
-                            AssistantEvent {
-                                conversation_id: None,
-                                kind: AssistantKind::InlineTerminal,
-                                message_id,
-                                phase: AssistantPhase::Response,
-                                model: model_telemetry_id,
-                                model_provider: model_provider_id.to_string(),
-                                response_latency,
-                                error_message,
-                                language_name: None,
-                            },
-                            telemetry,
-                            http_client,
-                            model_api_key,
-                            &executor,
-                        );
-
-                        result?;
                        anyhow::Ok(())
-                    }
-                });
+                    };

-                this.update(&mut cx, |this, _| {
-                    this.message_id = message_id;
-                })?;
+                    let result = task.await;
+
+                    let error_message = result.as_ref().err().map(|error| error.to_string());
+                    if let Some(telemetry) = telemetry {
+                        telemetry.report_assistant_event(AssistantEvent {
+                            conversation_id: None,
+                            kind: AssistantKind::Inline,
+                            phase: AssistantPhase::Response,
+                            model: model_telemetry_id,
+                            model_provider: model_provider_id.to_string(),
+                            response_latency,
+                            error_message,
+                            language_name: None,
+                        });
+                    }
+
+                    result?;
+                    anyhow::Ok(())
+                });

                while let Some(hunk) = hunks_rx.next().await {
                    this.update(&mut cx, |this, cx| {
--- a/crates/assistant/src/tools.rs
+++ b/crates/assistant/src/tools.rs
@@ -1,2 +1 @@
-pub mod context_server_tool;
 pub mod now_tool;
--- a/crates/assistant/src/tools/context_server_tool.rs
+++ b/crates/assistant/src/tools/context_server_tool.rs
@@ -1,82 +0,0 @@
-use anyhow::{anyhow, bail};
-use assistant_tool::Tool;
-use context_servers::manager::ContextServerManager;
-use context_servers::types;
-use gpui::Task;
-
-pub struct ContextServerTool {
-    server_id: String,
-    tool: types::Tool,
-}
-
-impl ContextServerTool {
-    pub fn new(server_id: impl Into<String>, tool: types::Tool) -> Self {
-        Self {
-            server_id: server_id.into(),
-            tool,
-        }
-    }
-}
-
-impl Tool for ContextServerTool {
-    fn name(&self) -> String {
-        self.tool.name.clone()
-    }
-
-    fn description(&self) -> String {
-        self.tool.description.clone().unwrap_or_default()
-    }
-
-    fn input_schema(&self) -> serde_json::Value {
-        match &self.tool.input_schema {
-            serde_json::Value::Null => {
-                serde_json::json!({ "type": "object", "properties": [] })
-            }
-            serde_json::Value::Object(map) if map.is_empty() => {
-                serde_json::json!({ "type": "object", "properties": [] })
-            }
-            _ => self.tool.input_schema.clone(),
-        }
-    }
-
-    fn run(
-        self: std::sync::Arc<Self>,
-        input: serde_json::Value,
-        _workspace: gpui::WeakView<workspace::Workspace>,
-        cx: &mut ui::WindowContext,
-    ) -> gpui::Task<gpui::Result<String>> {
-        let manager = ContextServerManager::global(cx);
-        let manager = manager.read(cx);
-        if let Some(server) = manager.get_server(&self.server_id) {
-            cx.foreground_executor().spawn({
-                let tool_name = self.tool.name.clone();
-                async move {
-                    let Some(protocol) = server.client.read().clone() else {
-                        bail!("Context server not initialized");
-                    };
-
-                    let arguments = if let serde_json::Value::Object(map) = input {
-                        Some(map.into_iter().collect())
-                    } else {
-                        None
-                    };
-
-                    log::trace!(
-                        "Running tool: {} with arguments: {:?}",
-                        tool_name,
-                        arguments
-                    );
-                    let response = protocol.run_tool(tool_name, arguments).await?;
-
-                    let tool_result = match response.tool_result {
-                        serde_json::Value::String(s) => s,
-                        _ => serde_json::to_string(&response.tool_result)?,
-                    };
-                    Ok(tool_result)
-                }
-            })
-        } else {
-            Task::ready(Err(anyhow!("Context server not found")))
-        }
-    }
-}
--- a/crates/assistant_slash_command/Cargo.toml
+++ b/crates/assistant_slash_command/Cargo.toml
@@ -15,15 +15,9 @@ path = "src/assistant_slash_command.rs"
 anyhow.workspace = true
 collections.workspace = true
 derive_more.workspace = true
-futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 workspace.workspace = true
-
-[dev-dependencies]
-gpui = { workspace = true, features = ["test-support"] }
-pretty_assertions.workspace = true
-workspace = { workspace = true, features = ["test-support"] }
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -1,8 +1,6 @@
 mod slash_command_registry;

 use anyhow::Result;
-use futures::stream::{self, BoxStream};
-use futures::StreamExt;
 use gpui::{AnyElement, AppContext, ElementId, SharedString, Task, WeakView, WindowContext};
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate, OffsetRangeExt};
 use serde::{Deserialize, Serialize};
@@ -58,13 +56,8 @@ pub struct ArgumentCompletion {
    pub replace_previous_arguments: bool,
 }

-pub type SlashCommandResult = Result<BoxStream<'static, Result<SlashCommandEvent>>>;
-
 pub trait SlashCommand: 'static + Send + Sync {
    fn name(&self) -> String;
-    fn icon(&self) -> IconName {
-        IconName::Slash
-    }
    fn label(&self, _cx: &AppContext) -> CodeLabel {
        CodeLabel::plain(self.name(), None)
    }
@@ -94,7 +87,7 @@ pub trait SlashCommand: 'static + Send + Sync {
        // perhaps another kind of delegate is needed here.
        delegate: Option<Arc<dyn LspAdapterDelegate>>,
        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult>;
+    ) -> Task<Result<SlashCommandOutput>>;
 }

 pub type RenderFoldPlaceholder = Arc<
@@ -103,146 +96,13 @@ pub type RenderFoldPlaceholder = Arc<
        + Fn(ElementId, Arc<dyn Fn(&mut WindowContext)>, &mut WindowContext) -> AnyElement,
 >;

-#[derive(Debug, PartialEq, Eq)]
-pub enum SlashCommandContent {
-    Text {
-        text: String,
-        run_commands_in_text: bool,
-    },
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum SlashCommandEvent {
-    StartSection {
-        icon: IconName,
-        label: SharedString,
-        metadata: Option<serde_json::Value>,
-    },
-    Content(SlashCommandContent),
-    EndSection {
-        metadata: Option<serde_json::Value>,
-    },
-}
-
-#[derive(Debug, Default, PartialEq, Clone)]
+#[derive(Debug, Default, PartialEq)]
 pub struct SlashCommandOutput {
    pub text: String,
    pub sections: Vec<SlashCommandOutputSection<usize>>,
    pub run_commands_in_text: bool,
 }

-impl SlashCommandOutput {
-    pub fn ensure_valid_section_ranges(&mut self) {
-        for section in &mut self.sections {
-            section.range.start = section.range.start.min(self.text.len());
-            section.range.end = section.range.end.min(self.text.len());
-            while !self.text.is_char_boundary(section.range.start) {
-                section.range.start -= 1;
-            }
-            while !self.text.is_char_boundary(section.range.end) {
-                section.range.end += 1;
-            }
-        }
-    }
-
-    /// Returns this [`SlashCommandOutput`] as a stream of [`SlashCommandEvent`]s.
-    pub fn to_event_stream(mut self) -> BoxStream<'static, Result<SlashCommandEvent>> {
-        self.ensure_valid_section_ranges();
-
-        let mut events = Vec::new();
-        let mut last_section_end = 0;
-
-        for section in self.sections {
-            if last_section_end < section.range.start {
-                events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                    text: self
-                        .text
-                        .get(last_section_end..section.range.start)
-                        .unwrap_or_default()
-                        .to_string(),
-                    run_commands_in_text: self.run_commands_in_text,
-                })));
-            }
-
-            events.push(Ok(SlashCommandEvent::StartSection {
-                icon: section.icon,
-                label: section.label,
-                metadata: section.metadata.clone(),
-            }));
-            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                text: self
-                    .text
-                    .get(section.range.start..section.range.end)
-                    .unwrap_or_default()
-                    .to_string(),
-                run_commands_in_text: self.run_commands_in_text,
-            })));
-            events.push(Ok(SlashCommandEvent::EndSection {
-                metadata: section.metadata,
-            }));
-
-            last_section_end = section.range.end;
-        }
-
-        if last_section_end < self.text.len() {
-            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                text: self.text[last_section_end..].to_string(),
-                run_commands_in_text: self.run_commands_in_text,
-            })));
-        }
-
-        stream::iter(events).boxed()
-    }
-
-    pub async fn from_event_stream(
-        mut events: BoxStream<'static, Result<SlashCommandEvent>>,
-    ) -> Result<SlashCommandOutput> {
-        let mut output = SlashCommandOutput::default();
-        let mut section_stack = Vec::new();
-
-        while let Some(event) = events.next().await {
-            match event? {
-                SlashCommandEvent::StartSection {
-                    icon,
-                    label,
-                    metadata,
-                } => {
-                    let start = output.text.len();
-                    section_stack.push(SlashCommandOutputSection {
-                        range: start..start,
-                        icon,
-                        label,
-                        metadata,
-                    });
-                }
-                SlashCommandEvent::Content(SlashCommandContent::Text {
-                    text,
-                    run_commands_in_text,
-                }) => {
-                    output.text.push_str(&text);
-                    output.run_commands_in_text = run_commands_in_text;
-
-                    if let Some(section) = section_stack.last_mut() {
-                        section.range.end = output.text.len();
-                    }
-                }
-                SlashCommandEvent::EndSection { metadata } => {
-                    if let Some(mut section) = section_stack.pop() {
-                        section.metadata = metadata;
-                        output.sections.push(section);
-                    }
-                }
-            }
-        }
-
-        while let Some(section) = section_stack.pop() {
-            output.sections.push(section);
-        }
-
-        Ok(output)
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct SlashCommandOutputSection<T> {
    pub range: Range<T>,
@@ -256,243 +116,3 @@ impl SlashCommandOutputSection<language::Anchor> {
        self.range.start.is_valid(buffer) && !self.range.to_offset(buffer).is_empty()
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use pretty_assertions::assert_eq;
-    use serde_json::json;
-
-    use super::*;
-
-    #[gpui::test]
-    async fn test_slash_command_output_to_events_round_trip() {
-        // Test basic output consisting of a single section.
-        {
-            let text = "Hello, world!".to_string();
-            let range = 0..text.len();
-            let output = SlashCommandOutput {
-                text,
-                sections: vec![SlashCommandOutputSection {
-                    range,
-                    icon: IconName::Code,
-                    label: "Section 1".into(),
-                    metadata: None,
-                }],
-                run_commands_in_text: false,
-            };
-
-            let events = output.clone().to_event_stream().collect::<Vec<_>>().await;
-            let events = events
-                .into_iter()
-                .filter_map(|event| event.ok())
-                .collect::<Vec<_>>();
-
-            assert_eq!(
-                events,
-                vec![
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::Code,
-                        label: "Section 1".into(),
-                        metadata: None
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Hello, world!".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection { metadata: None }
-                ]
-            );
-
-            let new_output =
-                SlashCommandOutput::from_event_stream(output.clone().to_event_stream())
-                    .await
-                    .unwrap();
-
-            assert_eq!(new_output, output);
-        }
-
-        // Test output where the sections do not comprise all of the text.
-        {
-            let text = "Apple\nCucumber\nBanana\n".to_string();
-            let output = SlashCommandOutput {
-                text,
-                sections: vec![
-                    SlashCommandOutputSection {
-                        range: 0..6,
-                        icon: IconName::Check,
-                        label: "Fruit".into(),
-                        metadata: None,
-                    },
-                    SlashCommandOutputSection {
-                        range: 15..22,
-                        icon: IconName::Check,
-                        label: "Fruit".into(),
-                        metadata: None,
-                    },
-                ],
-                run_commands_in_text: false,
-            };
-
-            let events = output.clone().to_event_stream().collect::<Vec<_>>().await;
-            let events = events
-                .into_iter()
-                .filter_map(|event| event.ok())
-                .collect::<Vec<_>>();
-
-            assert_eq!(
-                events,
-                vec![
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::Check,
-                        label: "Fruit".into(),
-                        metadata: None
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Apple\n".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection { metadata: None },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Cucumber\n".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::Check,
-                        label: "Fruit".into(),
-                        metadata: None
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Banana\n".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection { metadata: None }
-                ]
-            );
-
-            let new_output =
-                SlashCommandOutput::from_event_stream(output.clone().to_event_stream())
-                    .await
-                    .unwrap();
-
-            assert_eq!(new_output, output);
-        }
-
-        // Test output consisting of multiple sections.
-        {
-            let text = "Line 1\nLine 2\nLine 3\nLine 4\n".to_string();
-            let output = SlashCommandOutput {
-                text,
-                sections: vec![
-                    SlashCommandOutputSection {
-                        range: 0..6,
-                        icon: IconName::FileCode,
-                        label: "Section 1".into(),
-                        metadata: Some(json!({ "a": true })),
-                    },
-                    SlashCommandOutputSection {
-                        range: 7..13,
-                        icon: IconName::FileDoc,
-                        label: "Section 2".into(),
-                        metadata: Some(json!({ "b": true })),
-                    },
-                    SlashCommandOutputSection {
-                        range: 14..20,
-                        icon: IconName::FileGit,
-                        label: "Section 3".into(),
-                        metadata: Some(json!({ "c": true })),
-                    },
-                    SlashCommandOutputSection {
-                        range: 21..27,
-                        icon: IconName::FileToml,
-                        label: "Section 4".into(),
-                        metadata: Some(json!({ "d": true })),
-                    },
-                ],
-                run_commands_in_text: false,
-            };
-
-            let events = output.clone().to_event_stream().collect::<Vec<_>>().await;
-            let events = events
-                .into_iter()
-                .filter_map(|event| event.ok())
-                .collect::<Vec<_>>();
-
-            assert_eq!(
-                events,
-                vec![
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::FileCode,
-                        label: "Section 1".into(),
-                        metadata: Some(json!({ "a": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Line 1".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection {
-                        metadata: Some(json!({ "a": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "\n".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::FileDoc,
-                        label: "Section 2".into(),
-                        metadata: Some(json!({ "b": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Line 2".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection {
-                        metadata: Some(json!({ "b": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "\n".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::FileGit,
-                        label: "Section 3".into(),
-                        metadata: Some(json!({ "c": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Line 3".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection {
-                        metadata: Some(json!({ "c": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "\n".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::StartSection {
-                        icon: IconName::FileToml,
-                        label: "Section 4".into(),
-                        metadata: Some(json!({ "d": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "Line 4".into(),
-                        run_commands_in_text: false
-                    }),
-                    SlashCommandEvent::EndSection {
-                        metadata: Some(json!({ "d": true }))
-                    },
-                    SlashCommandEvent::Content(SlashCommandContent::Text {
-                        text: "\n".into(),
-                        run_commands_in_text: false
-                    }),
-                ]
-            );
-
-            let new_output =
-                SlashCommandOutput::from_event_stream(output.clone().to_event_stream())
-                    .await
-                    .unwrap();
-
-            assert_eq!(new_output, output);
-        }
-    }
-}
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -11,7 +11,6 @@ use gpui::{
 };

 use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
-use paths::remote_servers_dir;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde_derive::Serialize;
@@ -84,9 +83,9 @@ pub struct AutoUpdater {
 }

 #[derive(Deserialize)]
-pub struct JsonRelease {
-    pub version: String,
-    pub url: String,
+struct JsonRelease {
+    version: String,
+    url: String,
 }

 struct MacOsUnmounter {
@@ -432,11 +431,10 @@ impl AutoUpdater {
        cx.notify();
    }

-    pub async fn download_remote_server_release(
+    pub async fn get_latest_remote_server_release(
        os: &str,
        arch: &str,
-        release_channel: ReleaseChannel,
-        version: Option<SemanticVersion>,
+        mut release_channel: ReleaseChannel,
        cx: &mut AsyncAppContext,
    ) -> Result<PathBuf> {
        let this = cx.update(|cx| {
@@ -446,12 +444,15 @@ impl AutoUpdater {
                .ok_or_else(|| anyhow!("auto-update not initialized"))
        })??;

-        let release = Self::get_release(
+        if release_channel == ReleaseChannel::Dev {
+            release_channel = ReleaseChannel::Nightly;
+        }
+
+        let release = Self::get_latest_release(
            &this,
            "zed-remote-server",
            os,
            arch,
-            version,
            Some(release_channel),
            cx,
        )
@@ -466,97 +467,13 @@ impl AutoUpdater {
        let client = this.read_with(cx, |this, _| this.http_client.clone())?;

        if smol::fs::metadata(&version_path).await.is_err() {
-            log::info!(
-                "downloading zed-remote-server {os} {arch} version {}",
-                release.version
-            );
+            log::info!("downloading zed-remote-server {os} {arch}");
            download_remote_server_binary(&version_path, release, client, cx).await?;
        }

        Ok(version_path)
    }

-    pub async fn get_remote_server_release_url(
-        os: &str,
-        arch: &str,
-        release_channel: ReleaseChannel,
-        version: Option<SemanticVersion>,
-        cx: &mut AsyncAppContext,
-    ) -> Result<(JsonRelease, String)> {
-        let this = cx.update(|cx| {
-            cx.default_global::<GlobalAutoUpdate>()
-                .0
-                .clone()
-                .ok_or_else(|| anyhow!("auto-update not initialized"))
-        })??;
-
-        let release = Self::get_release(
-            &this,
-            "zed-remote-server",
-            os,
-            arch,
-            version,
-            Some(release_channel),
-            cx,
-        )
-        .await?;
-
-        let update_request_body = build_remote_server_update_request_body(cx)?;
-        let body = serde_json::to_string(&update_request_body)?;
-
-        Ok((release, body))
-    }
-
-    async fn get_release(
-        this: &Model<Self>,
-        asset: &str,
-        os: &str,
-        arch: &str,
-        version: Option<SemanticVersion>,
-        release_channel: Option<ReleaseChannel>,
-        cx: &mut AsyncAppContext,
-    ) -> Result<JsonRelease> {
-        let client = this.read_with(cx, |this, _| this.http_client.clone())?;
-
-        if let Some(version) = version {
-            let channel = release_channel.map(|c| c.dev_name()).unwrap_or("stable");
-
-            let url = format!("/api/releases/{channel}/{version}/{asset}-{os}-{arch}.gz?update=1",);
-
-            Ok(JsonRelease {
-                version: version.to_string(),
-                url: client.build_url(&url),
-            })
-        } else {
-            let mut url_string = client.build_url(&format!(
-                "/api/releases/latest?asset={}&os={}&arch={}",
-                asset, os, arch
-            ));
-            if let Some(param) = release_channel.and_then(|c| c.release_query_param()) {
-                url_string += "&";
-                url_string += param;
-            }
-
-            let mut response = client.get(&url_string, Default::default(), true).await?;
-            let mut body = Vec::new();
-            response.body_mut().read_to_end(&mut body).await?;
-
-            if !response.status().is_success() {
-                return Err(anyhow!(
-                    "failed to fetch release: {:?}",
-                    String::from_utf8_lossy(&body),
-                ));
-            }
-
-            serde_json::from_slice(body.as_slice()).with_context(|| {
-                format!(
-                    "error deserializing release {:?}",
-                    String::from_utf8_lossy(&body),
-                )
-            })
-        }
-    }
-
    async fn get_latest_release(
        this: &Model<Self>,
        asset: &str,
@@ -565,7 +482,38 @@ impl AutoUpdater {
        release_channel: Option<ReleaseChannel>,
        cx: &mut AsyncAppContext,
    ) -> Result<JsonRelease> {
-        Self::get_release(this, asset, os, arch, None, release_channel, cx).await
+        let client = this.read_with(cx, |this, _| this.http_client.clone())?;
+        let mut url_string = client.build_url(&format!(
+            "/api/releases/latest?asset={}&os={}&arch={}",
+            asset, os, arch
+        ));
+        if let Some(param) = release_channel.and_then(|c| c.release_query_param()) {
+            url_string += "&";
+            url_string += param;
+        }
+
+        let mut response = client.get(&url_string, Default::default(), true).await?;
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .context("error reading release")?;
+
+        if !response.status().is_success() {
+            Err(anyhow!(
+                "failed to fetch release: {:?}",
+                String::from_utf8_lossy(&body),
+            ))?;
+        }
+
+        serde_json::from_slice(body.as_slice()).with_context(|| {
+            format!(
+                "error deserializing release {:?}",
+                String::from_utf8_lossy(&body),
+            )
+        })
    }

    async fn update(this: Model<Self>, mut cx: AsyncAppContext) -> Result<()> {
@@ -680,25 +628,7 @@ async fn download_remote_server_binary(
    client: Arc<HttpClientWithUrl>,
    cx: &AsyncAppContext,
 ) -> Result<()> {
-    let temp = tempfile::Builder::new().tempfile_in(remote_servers_dir())?;
-    let mut temp_file = File::create(&temp).await?;
-    let update_request_body = build_remote_server_update_request_body(cx)?;
-    let request_body = AsyncBody::from(serde_json::to_string(&update_request_body)?);
-
-    let mut response = client.get(&release.url, request_body, true).await?;
-    if !response.status().is_success() {
-        return Err(anyhow!(
-            "failed to download remote server release: {:?}",
-            response.status()
-        ));
-    }
-    smol::io::copy(response.body_mut(), &mut temp_file).await?;
-    smol::fs::rename(&temp, &target_path).await?;
-
-    Ok(())
-}
-
-fn build_remote_server_update_request_body(cx: &AsyncAppContext) -> Result<UpdateRequestBody> {
+    let mut target_file = File::create(&target_path).await?;
    let (installation_id, release_channel, telemetry_enabled, is_staff) = cx.update(|cx| {
        let telemetry = Client::global(cx).telemetry().clone();
        let is_staff = telemetry.is_staff();
@@ -714,14 +644,17 @@ fn build_remote_server_update_request_body(cx: &AsyncAppContext) -> Result<Updat
            is_staff,
        )
    })?;
-
-    Ok(UpdateRequestBody {
+    let request_body = AsyncBody::from(serde_json::to_string(&UpdateRequestBody {
        installation_id,
        release_channel,
        telemetry: telemetry_enabled,
        is_staff,
        destination: "remote",
-    })
+    })?);
+
+    let mut response = client.get(&release.url, request_body, true).await?;
+    smol::io::copy(response.body_mut(), &mut target_file).await?;
+    Ok(())
 }

 async fn download_release(
--- a/crates/call/Cargo.toml
+++ b/crates/call/Cargo.toml
@@ -13,6 +13,7 @@ path = "src/call.rs"
 doctest = false

 [features]
+no-webrtc = ["live_kit_client/no-webrtc"]
 test-support = [
    "client/test-support",
    "collections/test-support",
--- a/crates/call/src/room.rs
+++ b/crates/call/src/room.rs
@@ -1194,15 +1194,26 @@ impl Room {
        project: Model<Project>,
        cx: &mut ModelContext<Self>,
    ) -> Task<Result<u64>> {
-        if let Some(project_id) = project.read(cx).remote_id() {
-            return Task::ready(Ok(project_id));
-        }
+        let request = if let Some(dev_server_project_id) = project.read(cx).dev_server_project_id()
+        {
+            self.client.request(proto::ShareProject {
+                room_id: self.id(),
+                worktrees: vec![],
+                dev_server_project_id: Some(dev_server_project_id.0),
+                is_ssh_project: false,
+            })
+        } else {
+            if let Some(project_id) = project.read(cx).remote_id() {
+                return Task::ready(Ok(project_id));
+            }

-        let request = self.client.request(proto::ShareProject {
-            room_id: self.id(),
-            worktrees: project.read(cx).worktree_metadata_protos(cx),
-            is_ssh_project: project.read(cx).is_via_ssh(),
-        });
+            self.client.request(proto::ShareProject {
+                room_id: self.id(),
+                worktrees: project.read(cx).worktree_metadata_protos(cx),
+                dev_server_project_id: None,
+                is_ssh_project: project.read(cx).is_via_ssh(),
+            })
+        };

        cx.spawn(|this, mut cx| async move {
            let response = request.await?;
--- a/crates/channel/src/channel_store.rs
+++ b/crates/channel/src/channel_store.rs
@@ -3,7 +3,7 @@ mod channel_index;
 use crate::{channel_buffer::ChannelBuffer, channel_chat::ChannelChat, ChannelMessage};
 use anyhow::{anyhow, Result};
 use channel_index::ChannelIndex;
-use client::{ChannelId, Client, ClientSettings, Subscription, User, UserId, UserStore};
+use client::{ChannelId, Client, ClientSettings, ProjectId, Subscription, User, UserId, UserStore};
 use collections::{hash_map, HashMap, HashSet};
 use futures::{channel::mpsc, future::Shared, Future, FutureExt, StreamExt};
 use gpui::{
@@ -33,11 +33,30 @@ struct NotesVersion {
    version: clock::Global,
 }

+#[derive(Debug, Clone)]
+pub struct HostedProject {
+    project_id: ProjectId,
+    channel_id: ChannelId,
+    name: SharedString,
+    _visibility: proto::ChannelVisibility,
+}
+impl From<proto::HostedProject> for HostedProject {
+    fn from(project: proto::HostedProject) -> Self {
+        Self {
+            project_id: ProjectId(project.project_id),
+            channel_id: ChannelId(project.channel_id),
+            _visibility: project.visibility(),
+            name: project.name.into(),
+        }
+    }
+}
 pub struct ChannelStore {
    pub channel_index: ChannelIndex,
    channel_invitations: Vec<Arc<Channel>>,
    channel_participants: HashMap<ChannelId, Vec<Arc<User>>>,
    channel_states: HashMap<ChannelId, ChannelState>,
+    hosted_projects: HashMap<ProjectId, HostedProject>,
+
    outgoing_invites: HashSet<(ChannelId, UserId)>,
    update_channels_tx: mpsc::UnboundedSender<proto::UpdateChannels>,
    opened_buffers: HashMap<ChannelId, OpenedModelHandle<ChannelBuffer>>,
@@ -66,6 +85,7 @@ pub struct ChannelState {
    observed_notes_version: NotesVersion,
    observed_chat_message: Option<u64>,
    role: Option<ChannelRole>,
+    projects: HashSet<ProjectId>,
 }

 impl Channel {
@@ -196,6 +216,7 @@ impl ChannelStore {
            channel_invitations: Vec::default(),
            channel_index: ChannelIndex::default(),
            channel_participants: Default::default(),
+            hosted_projects: Default::default(),
            outgoing_invites: Default::default(),
            opened_buffers: Default::default(),
            opened_chats: Default::default(),
@@ -295,6 +316,19 @@ impl ChannelStore {
        self.channel_index.by_id().get(&channel_id)
    }

+    pub fn projects_for_id(&self, channel_id: ChannelId) -> Vec<(SharedString, ProjectId)> {
+        let mut projects: Vec<(SharedString, ProjectId)> = self
+            .channel_states
+            .get(&channel_id)
+            .map(|state| state.projects.clone())
+            .unwrap_or_default()
+            .into_iter()
+            .flat_map(|id| Some((self.hosted_projects.get(&id)?.name.clone(), id)))
+            .collect();
+        projects.sort();
+        projects
+    }
+
    pub fn has_open_channel_buffer(&self, channel_id: ChannelId, _cx: &AppContext) -> bool {
        if let Some(buffer) = self.opened_buffers.get(&channel_id) {
            if let OpenedModelHandle::Open(buffer) = buffer {
@@ -1068,7 +1102,9 @@ impl ChannelStore {
        let channels_changed = !payload.channels.is_empty()
            || !payload.delete_channels.is_empty()
            || !payload.latest_channel_message_ids.is_empty()
-            || !payload.latest_channel_buffer_versions.is_empty();
+            || !payload.latest_channel_buffer_versions.is_empty()
+            || !payload.hosted_projects.is_empty()
+            || !payload.deleted_hosted_projects.is_empty();

        if channels_changed {
            if !payload.delete_channels.is_empty() {
@@ -1125,6 +1161,34 @@ impl ChannelStore {
                    .or_default()
                    .update_latest_message_id(latest_channel_message.message_id);
            }
+
+            for hosted_project in payload.hosted_projects {
+                let hosted_project: HostedProject = hosted_project.into();
+                if let Some(old_project) = self
+                    .hosted_projects
+                    .insert(hosted_project.project_id, hosted_project.clone())
+                {
+                    self.channel_states
+                        .entry(old_project.channel_id)
+                        .or_default()
+                        .remove_hosted_project(old_project.project_id);
+                }
+                self.channel_states
+                    .entry(hosted_project.channel_id)
+                    .or_default()
+                    .add_hosted_project(hosted_project.project_id);
+            }
+
+            for hosted_project_id in payload.deleted_hosted_projects {
+                let hosted_project_id = ProjectId(hosted_project_id);
+
+                if let Some(old_project) = self.hosted_projects.remove(&hosted_project_id) {
+                    self.channel_states
+                        .entry(old_project.channel_id)
+                        .or_default()
+                        .remove_hosted_project(old_project.project_id);
+                }
+            }
        }

        cx.notify();
@@ -1231,4 +1295,12 @@ impl ChannelState {
            };
        }
    }
+
+    fn add_hosted_project(&mut self, project_id: ProjectId) {
+        self.projects.insert(project_id);
+    }
+
+    fn remove_hosted_project(&mut self, project_id: ProjectId) {
+        self.projects.remove(&project_id);
+    }
 }
--- a/crates/cli/src/cli.rs
+++ b/crates/cli/src/cli.rs
@@ -15,6 +15,7 @@ pub enum CliRequest {
        urls: Vec<String>,
        wait: bool,
        open_new_workspace: Option<bool>,
+        dev_server_token: Option<String>,
        env: Option<HashMap<String, String>>,
    },
 }
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -151,12 +151,6 @@ fn main() -> Result<()> {
        }
    }

-    if let Some(_) = args.dev_server_token {
-        return Err(anyhow::anyhow!(
-            "Dev servers were removed in v0.157.x please upgrade to SSH remoting: https://zed.dev/docs/remote-development"
-        ))?;
-    }
-
    let sender: JoinHandle<anyhow::Result<()>> = thread::spawn({
        let exit_status = exit_status.clone();
        move || {
@@ -168,6 +162,7 @@ fn main() -> Result<()> {
                urls,
                wait: args.wait,
                open_new_workspace,
+                dev_server_token: args.dev_server_token,
                env,
            })?;

--- a/crates/client/src/client.rs
+++ b/crates/client/src/client.rs
@@ -30,6 +30,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsSources};
 use socks::connect_socks_proxy_stream;
+use std::fmt;
 use std::pin::Pin;
 use std::{
    any::TypeId,
@@ -53,6 +54,15 @@ pub use rpc::*;
 pub use telemetry_events::Event;
 pub use user::*;

+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct DevServerToken(pub String);
+
+impl fmt::Display for DevServerToken {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 static ZED_SERVER_URL: LazyLock<Option<String>> =
    LazyLock::new(|| std::env::var("ZED_SERVER_URL").ok());
 static ZED_RPC_URL: LazyLock<Option<String>> = LazyLock::new(|| std::env::var("ZED_RPC_URL").ok());
@@ -294,14 +304,20 @@ struct ClientState {
 }

 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Credentials {
-    pub user_id: u64,
-    pub access_token: String,
+pub enum Credentials {
+    DevServer { token: DevServerToken },
+    User { user_id: u64, access_token: String },
 }

 impl Credentials {
    pub fn authorization_header(&self) -> String {
-        format!("{} {}", self.user_id, self.access_token)
+        match self {
+            Credentials::DevServer { token } => format!("dev-server-token {}", token),
+            Credentials::User {
+                user_id,
+                access_token,
+            } => format!("{} {}", user_id, access_token),
+        }
    }
 }

@@ -584,11 +600,11 @@ impl Client {
    }

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

    pub fn peer_id(&self) -> Option<PeerId> {
@@ -777,6 +793,11 @@ impl Client {
            .is_some()
    }

+    pub fn set_dev_server_token(&self, token: DevServerToken) -> &Self {
+        self.state.write().credentials = Some(Credentials::DevServer { token });
+        self
+    }
+
    #[async_recursion(?Send)]
    pub async fn authenticate_and_connect(
        self: &Arc<Self>,
@@ -827,7 +848,9 @@ impl Client {
            }
        }
        let credentials = credentials.unwrap();
-        self.set_id(credentials.user_id);
+        if let Credentials::User { user_id, .. } = &credentials {
+            self.set_id(*user_id);
+        }

        if was_disconnected {
            self.set_status(Status::Connecting, cx);
@@ -843,8 +866,9 @@ impl Client {
                    Ok(conn) => {
                        self.state.write().credentials = Some(credentials.clone());
                        if !read_from_provider && IMPERSONATE_LOGIN.is_none() {
-                                self.credentials_provider.write_credentials(credentials.user_id, credentials.access_token, cx).await.log_err();
-
+                            if let Credentials::User{user_id, access_token} = credentials {
+                                self.credentials_provider.write_credentials(user_id, access_token, cx).await.log_err();
+                            }
                        }

                        futures::select_biased! {
@@ -1277,7 +1301,7 @@ impl Client {
                        .decrypt_string(&access_token)
                        .context("failed to decrypt access token")?;

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

        // Use the admin API token to authenticate as the impersonated user.
        api_token.insert_str(0, "ADMIN_TOKEN:");
-        Ok(Credentials {
+        Ok(Credentials::User {
            user_id: response.user.id,
            access_token: api_token,
        })
@@ -1643,7 +1667,7 @@ impl CredentialsProvider for DevelopmentCredentialsProvider {

            let credentials: DevelopmentCredentials = serde_json::from_slice(&json).log_err()?;

-            Some(Credentials {
+            Some(Credentials::User {
                user_id: credentials.user_id,
                access_token: credentials.access_token,
            })
@@ -1697,7 +1721,7 @@ impl CredentialsProvider for KeychainCredentialsProvider {
                .await
                .log_err()??;

-            Some(Credentials {
+            Some(Credentials::User {
                user_id: user_id.parse().ok()?,
                access_token: String::from_utf8(access_token).ok()?,
            })
@@ -1831,7 +1855,7 @@ mod tests {
        // Time out when client tries to connect.
        client.override_authenticate(move |cx| {
            cx.background_executor().spawn(async move {
-                Ok(Credentials {
+                Ok(Credentials::User {
                    user_id,
                    access_token: "token".into(),
                })
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -341,13 +341,6 @@ impl Telemetry {
            .detach();
    }

-    pub fn metrics_enabled(self: &Arc<Self>) -> bool {
-        let state = self.state.lock();
-        let enabled = state.settings.metrics;
-        drop(state);
-        return enabled;
-    }
-
    pub fn set_authenticated_user_info(
        self: &Arc<Self>,
        metrics_id: Option<String>,
--- a/crates/client/src/test.rs
+++ b/crates/client/src/test.rs
@@ -49,7 +49,7 @@ impl FakeServer {
                        let mut state = state.lock();
                        state.auth_count += 1;
                        let access_token = state.access_token.to_string();
-                        Ok(Credentials {
+                        Ok(Credentials::User {
                            user_id: client_user_id,
                            access_token,
                        })
@@ -73,7 +73,7 @@ impl FakeServer {
                        }

                        if credentials
-                            != (Credentials {
+                            != (Credentials::User {
                                user_id: client_user_id,
                                access_token: state.lock().access_token.to_string(),
                            })
--- a/crates/client/src/user.rs
+++ b/crates/client/src/user.rs
@@ -28,6 +28,9 @@ impl std::fmt::Display for ChannelId {
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
 pub struct ProjectId(pub u64);

+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
+pub struct DevServerId(pub u64);
+
 #[derive(
    Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, serde::Serialize, serde::Deserialize,
 )]
@@ -48,7 +51,6 @@ pub struct Collaborator {
    pub peer_id: proto::PeerId,
    pub replica_id: ReplicaId,
    pub user_id: UserId,
-    pub is_host: bool,
 }

 impl PartialOrd for User {
@@ -825,7 +827,6 @@ impl Collaborator {
            peer_id: message.peer_id.ok_or_else(|| anyhow!("invalid peer id"))?,
            replica_id: message.replica_id as ReplicaId,
            user_id: message.user_id as UserId,
-            is_host: message.is_host,
        })
    }
 }
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -86,6 +86,7 @@ client = { workspace = true, features = ["test-support"] }
 collab_ui = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
 ctor.workspace = true
+dev_server_projects.workspace = true
 editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 file_finder.workspace = true
@@ -93,6 +94,7 @@ fs = { workspace = true, features = ["test-support"] }
 git = { workspace = true, features = ["test-support"] }
 git_hosting_providers.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
+headless.workspace = true
 hyper.workspace = true
 indoc.workspace = true
 language = { workspace = true, features = ["test-support"] }
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -52,7 +52,9 @@ CREATE TABLE "projects" (
    "host_user_id" INTEGER REFERENCES users (id),
    "host_connection_id" INTEGER,
    "host_connection_server_id" INTEGER REFERENCES servers (id) ON DELETE CASCADE,
-    "unregistered" BOOLEAN NOT NULL DEFAULT FALSE
+    "unregistered" BOOLEAN NOT NULL DEFAULT FALSE,
+    "hosted_project_id" INTEGER REFERENCES hosted_projects (id),
+    "dev_server_project_id" INTEGER REFERENCES dev_server_projects(id)
 );
 CREATE INDEX "index_projects_on_host_connection_server_id" ON "projects" ("host_connection_server_id");
 CREATE INDEX "index_projects_on_host_connection_id_and_host_connection_server_id" ON "projects" ("host_connection_id", "host_connection_server_id");
@@ -397,6 +399,30 @@ CREATE TABLE rate_buckets (
 );
 CREATE INDEX idx_user_id_rate_limit ON rate_buckets (user_id, rate_limit_name);

+CREATE TABLE hosted_projects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    channel_id INTEGER NOT NULL REFERENCES channels(id),
+    name TEXT NOT NULL,
+    visibility TEXT NOT NULL,
+    deleted_at TIMESTAMP NULL
+);
+CREATE INDEX idx_hosted_projects_on_channel_id ON hosted_projects (channel_id);
+CREATE UNIQUE INDEX uix_hosted_projects_on_channel_id_and_name ON hosted_projects (channel_id, name) WHERE (deleted_at IS NULL);
+
+CREATE TABLE dev_servers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL REFERENCES users(id),
+    name TEXT NOT NULL,
+    ssh_connection_string TEXT,
+    hashed_token TEXT NOT NULL
+);
+
+CREATE TABLE dev_server_projects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    dev_server_id INTEGER NOT NULL REFERENCES dev_servers(id),
+    paths TEXT NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS billing_preferences (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
--- a/crates/collab/migrations/20241023201725_remove_dev_servers.sql
+++ b/crates/collab/migrations/20241023201725_remove_dev_servers.sql
@@ -1,6 +0,0 @@
-ALTER TABLE projects DROP COLUMN dev_server_project_id;
-ALTER TABLE projects DROP COLUMN hosted_project_id;
-
-DROP TABLE hosted_projects;
-DROP TABLE dev_server_projects;
-DROP TABLE dev_servers;
--- a/crates/collab/src/api/billing.rs
+++ b/crates/collab/src/api/billing.rs
@@ -252,10 +252,7 @@ async fn create_billing_subscription(

    let default_model = llm_db.model(rpc::LanguageModelProvider::Anthropic, "claude-3-5-sonnet")?;
    let stripe_model = stripe_billing.register_model(default_model).await?;
-    let success_url = format!(
-        "{}/account?checkout_complete=1",
-        app.config.zed_dot_dev_url()
-    );
+    let success_url = format!("{}/account", app.config.zed_dot_dev_url());
    let checkout_session_url = stripe_billing
        .checkout(customer_id, &user.github_login, &stripe_model, &success_url)
        .await?;
--- a/crates/collab/src/auth.rs
+++ b/crates/collab/src/auth.rs
@@ -1,5 +1,5 @@
 use crate::{
-    db::{self, AccessTokenId, Database, UserId},
+    db::{self, dev_server, AccessTokenId, Database, DevServerId, UserId},
    rpc::Principal,
    AppState, Error, Result,
 };
@@ -44,10 +44,19 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into

    let first = auth_header.next().unwrap_or("");
    if first == "dev-server-token" {
-        Err(Error::http(
-            StatusCode::UNAUTHORIZED,
-            "Dev servers were removed in Zed 0.157 please upgrade to SSH remoting".to_string(),
-        ))?;
+        let dev_server_token = auth_header.next().ok_or_else(|| {
+            Error::http(
+                StatusCode::BAD_REQUEST,
+                "missing dev-server-token token in authorization header".to_string(),
+            )
+        })?;
+        let dev_server = verify_dev_server_token(dev_server_token, &state.db)
+            .await
+            .map_err(|e| Error::http(StatusCode::UNAUTHORIZED, format!("{}", e)))?;
+
+        req.extensions_mut()
+            .insert(Principal::DevServer(dev_server));
+        return Ok::<_, Error>(next.run(req).await);
    }

    let user_id = UserId(first.parse().map_err(|_| {
@@ -231,6 +240,41 @@ pub async fn verify_access_token(
    })
 }

+pub fn generate_dev_server_token(id: usize, access_token: String) -> String {
+    format!("{}.{}", id, access_token)
+}
+
+pub async fn verify_dev_server_token(
+    dev_server_token: &str,
+    db: &Arc<Database>,
+) -> anyhow::Result<dev_server::Model> {
+    let (id, token) = split_dev_server_token(dev_server_token)?;
+    let token_hash = hash_access_token(token);
+    let server = db.get_dev_server(id).await?;
+
+    if server
+        .hashed_token
+        .as_bytes()
+        .ct_eq(token_hash.as_ref())
+        .into()
+    {
+        Ok(server)
+    } else {
+        Err(anyhow!("wrong token for dev server"))
+    }
+}
+
+// a dev_server_token has the format <id>.<base64>. This is to make them
+// relatively easy to copy/paste around.
+pub fn split_dev_server_token(dev_server_token: &str) -> anyhow::Result<(DevServerId, &str)> {
+    let mut parts = dev_server_token.splitn(2, '.');
+    let id = DevServerId(parts.next().unwrap_or_default().parse()?);
+    let token = parts
+        .next()
+        .ok_or_else(|| anyhow!("invalid dev server token format"))?;
+    Ok((id, token))
+}
+
 #[cfg(test)]
 mod test {
    use rand::thread_rng;
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -617,6 +617,7 @@ pub struct ChannelsForUser {
    pub channels: Vec<Channel>,
    pub channel_memberships: Vec<channel_member::Model>,
    pub channel_participants: HashMap<ChannelId, Vec<UserId>>,
+    pub hosted_projects: Vec<proto::HostedProject>,
    pub invited_channels: Vec<Channel>,

    pub observed_buffer_versions: Vec<proto::ChannelBufferVersion>,
@@ -725,6 +726,7 @@ pub struct Project {
    pub collaborators: Vec<ProjectCollaborator>,
    pub worktrees: BTreeMap<u64, Worktree>,
    pub language_servers: Vec<proto::LanguageServer>,
+    pub dev_server_project_id: Option<DevServerProjectId>,
 }

 pub struct ProjectCollaborator {
@@ -740,7 +742,6 @@ impl ProjectCollaborator {
            peer_id: Some(self.connection_id.into()),
            replica_id: self.replica_id.0 as u32,
            user_id: self.user_id.to_proto(),
-            is_host: self.is_host,
        }
    }
 }
--- a/crates/collab/src/db/ids.rs
+++ b/crates/collab/src/db/ids.rs
@@ -79,6 +79,7 @@ id_type!(ChannelChatParticipantId);
 id_type!(ChannelId);
 id_type!(ChannelMemberId);
 id_type!(ContactId);
+id_type!(DevServerId);
 id_type!(ExtensionId);
 id_type!(FlagId);
 id_type!(FollowerId);
@@ -88,6 +89,7 @@ id_type!(NotificationId);
 id_type!(NotificationKindId);
 id_type!(ProjectCollaboratorId);
 id_type!(ProjectId);
+id_type!(DevServerProjectId);
 id_type!(ReplicaId);
 id_type!(RoomId);
 id_type!(RoomParticipantId);
@@ -275,6 +277,12 @@ impl From<ChannelVisibility> for i32 {
    }
 }

+#[derive(Copy, Clone, Debug, Serialize, PartialEq)]
+pub enum PrincipalId {
+    UserId(UserId),
+    DevServerId(DevServerId),
+}
+
 /// Indicate whether a [Buffer] has permissions to edit.
 #[derive(PartialEq, Clone, Copy, Debug)]
 pub enum Capability {
--- a/crates/collab/src/db/queries.rs
+++ b/crates/collab/src/db/queries.rs
@@ -8,8 +8,11 @@ pub mod buffers;
 pub mod channels;
 pub mod contacts;
 pub mod contributors;
+pub mod dev_server_projects;
+pub mod dev_servers;
 pub mod embeddings;
 pub mod extensions;
+pub mod hosted_projects;
 pub mod messages;
 pub mod notifications;
 pub mod processed_stripe_events;
--- a/crates/collab/src/db/queries/buffers.rs
+++ b/crates/collab/src/db/queries/buffers.rs
@@ -116,7 +116,6 @@ impl Database {
                        peer_id: Some(collaborator.connection().into()),
                        user_id: collaborator.user_id.to_proto(),
                        replica_id: collaborator.replica_id.0 as u32,
-                        is_host: false,
                    })
                    .collect(),
            })
@@ -223,7 +222,6 @@ impl Database {
                                peer_id: Some(collaborator.connection().into()),
                                user_id: collaborator.user_id.to_proto(),
                                replica_id: collaborator.replica_id.0 as u32,
-                                is_host: false,
                            })
                            .collect(),
                    },
@@ -259,7 +257,6 @@ impl Database {
                        peer_id: Some(db_collaborator.connection().into()),
                        replica_id: db_collaborator.replica_id.0 as u32,
                        user_id: db_collaborator.user_id.to_proto(),
-                        is_host: false,
                    })
                } else {
                    collaborator_ids_to_remove.push(db_collaborator.id);
@@ -388,7 +385,6 @@ impl Database {
                peer_id: Some(connection.into()),
                replica_id: row.replica_id.0 as u32,
                user_id: row.user_id.to_proto(),
-                is_host: false,
            });
        }

--- a/crates/collab/src/db/queries/channels.rs
+++ b/crates/collab/src/db/queries/channels.rs
@@ -615,10 +615,15 @@ impl Database {
            .observed_channel_messages(&channel_ids, user_id, tx)
            .await?;

+        let hosted_projects = self
+            .get_hosted_projects(&channel_ids, &roles_by_channel_id, tx)
+            .await?;
+
        Ok(ChannelsForUser {
            channel_memberships,
            channels,
            invited_channels,
+            hosted_projects,
            channel_participants,
            latest_buffer_versions,
            latest_channel_messages,
--- a/crates/collab/src/db/queries/dev_server_projects.rs
+++ b/crates/collab/src/db/queries/dev_server_projects.rs
@@ -1 +1,365 @@
+use anyhow::anyhow;
+use rpc::{
+    proto::{self},
+    ConnectionId,
+};
+use sea_orm::{
+    ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait,
+    IntoActiveModel, ModelTrait, QueryFilter,
+};

+use crate::db::ProjectId;
+
+use super::{
+    dev_server, dev_server_project, project, project_collaborator, worktree, Database, DevServerId,
+    DevServerProjectId, RejoinedProject, ResharedProject, ServerId, UserId,
+};
+
+impl Database {
+    pub async fn get_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+    ) -> crate::Result<dev_server_project::Model> {
+        self.transaction(|tx| async move {
+            Ok(
+                dev_server_project::Entity::find_by_id(dev_server_project_id)
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| {
+                        anyhow!("no dev server project with id {}", dev_server_project_id)
+                    })?,
+            )
+        })
+        .await
+    }
+
+    pub async fn get_projects_for_dev_server(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> crate::Result<Vec<proto::DevServerProject>> {
+        self.transaction(|tx| async move {
+            self.get_projects_for_dev_server_internal(dev_server_id, &tx)
+                .await
+        })
+        .await
+    }
+
+    pub async fn get_projects_for_dev_server_internal(
+        &self,
+        dev_server_id: DevServerId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<Vec<proto::DevServerProject>> {
+        let servers = dev_server_project::Entity::find()
+            .filter(dev_server_project::Column::DevServerId.eq(dev_server_id))
+            .find_also_related(project::Entity)
+            .all(tx)
+            .await?;
+        Ok(servers
+            .into_iter()
+            .map(|(dev_server_project, project)| dev_server_project.to_proto(project))
+            .collect())
+    }
+
+    pub async fn dev_server_project_ids_for_user(
+        &self,
+        user_id: UserId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<Vec<DevServerProjectId>> {
+        let dev_servers = dev_server::Entity::find()
+            .filter(dev_server::Column::UserId.eq(user_id))
+            .find_with_related(dev_server_project::Entity)
+            .all(tx)
+            .await?;
+
+        Ok(dev_servers
+            .into_iter()
+            .flat_map(|(_, projects)| projects.into_iter().map(|p| p.id))
+            .collect())
+    }
+
+    pub async fn owner_for_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<UserId> {
+        let dev_server = dev_server_project::Entity::find_by_id(dev_server_project_id)
+            .find_also_related(dev_server::Entity)
+            .one(tx)
+            .await?
+            .and_then(|(_, dev_server)| dev_server)
+            .ok_or_else(|| anyhow!("no dev server project"))?;
+
+        Ok(dev_server.user_id)
+    }
+
+    pub async fn get_stale_dev_server_projects(
+        &self,
+        connection: ConnectionId,
+    ) -> crate::Result<Vec<ProjectId>> {
+        self.transaction(|tx| async move {
+            let projects = project::Entity::find()
+                .filter(
+                    Condition::all()
+                        .add(project::Column::HostConnectionId.eq(connection.id))
+                        .add(project::Column::HostConnectionServerId.eq(connection.owner_id)),
+                )
+                .all(&*tx)
+                .await?;
+
+            Ok(projects.into_iter().map(|p| p.id).collect())
+        })
+        .await
+    }
+
+    pub async fn create_dev_server_project(
+        &self,
+        dev_server_id: DevServerId,
+        path: &str,
+        user_id: UserId,
+    ) -> crate::Result<(dev_server_project::Model, proto::DevServerProjectsUpdate)> {
+        self.transaction(|tx| async move {
+            let dev_server = dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no dev server with id {}", dev_server_id))?;
+            if dev_server.user_id != user_id {
+                return Err(anyhow!("not your dev server"))?;
+            }
+
+            let project = dev_server_project::Entity::insert(dev_server_project::ActiveModel {
+                id: ActiveValue::NotSet,
+                dev_server_id: ActiveValue::Set(dev_server_id),
+                paths: ActiveValue::Set(dev_server_project::JSONPaths(vec![path.to_string()])),
+            })
+            .exec_with_returning(&*tx)
+            .await?;
+
+            let status = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok((project, status))
+        })
+        .await
+    }
+
+    pub async fn update_dev_server_project(
+        &self,
+        id: DevServerProjectId,
+        paths: &[String],
+        user_id: UserId,
+    ) -> crate::Result<(dev_server_project::Model, proto::DevServerProjectsUpdate)> {
+        self.transaction(move |tx| async move {
+            let paths = paths.to_owned();
+            let Some((project, Some(dev_server))) = dev_server_project::Entity::find_by_id(id)
+                .find_also_related(dev_server::Entity)
+                .one(&*tx)
+                .await?
+            else {
+                return Err(anyhow!("no such dev server project"))?;
+            };
+
+            if dev_server.user_id != user_id {
+                return Err(anyhow!("not your dev server"))?;
+            }
+            let mut project = project.into_active_model();
+            project.paths = ActiveValue::Set(dev_server_project::JSONPaths(paths));
+            let project = project.update(&*tx).await?;
+
+            let status = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok((project, status))
+        })
+        .await
+    }
+
+    pub async fn delete_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+        dev_server_id: DevServerId,
+        user_id: UserId,
+    ) -> crate::Result<(Vec<proto::DevServerProject>, proto::DevServerProjectsUpdate)> {
+        self.transaction(|tx| async move {
+            project::Entity::delete_many()
+                .filter(project::Column::DevServerProjectId.eq(dev_server_project_id))
+                .exec(&*tx)
+                .await?;
+            let result = dev_server_project::Entity::delete_by_id(dev_server_project_id)
+                .exec(&*tx)
+                .await?;
+            if result.rows_affected != 1 {
+                return Err(anyhow!(
+                    "no dev server project with id {}",
+                    dev_server_project_id
+                ))?;
+            }
+
+            let status = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            let projects = self
+                .get_projects_for_dev_server_internal(dev_server_id, &tx)
+                .await?;
+            Ok((projects, status))
+        })
+        .await
+    }
+
+    pub async fn share_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+        dev_server_id: DevServerId,
+        connection: ConnectionId,
+        worktrees: &[proto::WorktreeMetadata],
+    ) -> crate::Result<(
+        proto::DevServerProject,
+        UserId,
+        proto::DevServerProjectsUpdate,
+    )> {
+        self.transaction(|tx| async move {
+            let dev_server = dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no dev server with id {}", dev_server_id))?;
+
+            let dev_server_project = dev_server_project::Entity::find_by_id(dev_server_project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| {
+                    anyhow!("no dev server project with id {}", dev_server_project_id)
+                })?;
+
+            if dev_server_project.dev_server_id != dev_server_id {
+                return Err(anyhow!("dev server project shared from wrong server"))?;
+            }
+
+            let project = project::ActiveModel {
+                room_id: ActiveValue::Set(None),
+                host_user_id: ActiveValue::Set(None),
+                host_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                host_connection_server_id: ActiveValue::set(Some(ServerId(
+                    connection.owner_id as i32,
+                ))),
+                id: ActiveValue::NotSet,
+                hosted_project_id: ActiveValue::Set(None),
+                dev_server_project_id: ActiveValue::Set(Some(dev_server_project_id)),
+            }
+            .insert(&*tx)
+            .await?;
+
+            if !worktrees.is_empty() {
+                worktree::Entity::insert_many(worktrees.iter().map(|worktree| {
+                    worktree::ActiveModel {
+                        id: ActiveValue::set(worktree.id as i64),
+                        project_id: ActiveValue::set(project.id),
+                        abs_path: ActiveValue::set(worktree.abs_path.clone()),
+                        root_name: ActiveValue::set(worktree.root_name.clone()),
+                        visible: ActiveValue::set(worktree.visible),
+                        scan_id: ActiveValue::set(0),
+                        completed_scan_id: ActiveValue::set(0),
+                    }
+                }))
+                .exec(&*tx)
+                .await?;
+            }
+
+            let status = self
+                .dev_server_projects_update_internal(dev_server.user_id, &tx)
+                .await?;
+
+            Ok((
+                dev_server_project.to_proto(Some(project)),
+                dev_server.user_id,
+                status,
+            ))
+        })
+        .await
+    }
+
+    pub async fn reshare_dev_server_projects(
+        &self,
+        reshared_projects: &Vec<proto::UpdateProject>,
+        dev_server_id: DevServerId,
+        connection: ConnectionId,
+    ) -> crate::Result<Vec<ResharedProject>> {
+        self.transaction(|tx| async move {
+            let mut ret = Vec::new();
+            for reshared_project in reshared_projects {
+                let project_id = ProjectId::from_proto(reshared_project.project_id);
+                let (project, dev_server_project) = project::Entity::find_by_id(project_id)
+                    .find_also_related(dev_server_project::Entity)
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| anyhow!("project does not exist"))?;
+
+                if dev_server_project.map(|rp| rp.dev_server_id) != Some(dev_server_id) {
+                    return Err(anyhow!("dev server project reshared from wrong server"))?;
+                }
+
+                let Ok(old_connection_id) = project.host_connection() else {
+                    return Err(anyhow!("dev server project was not shared"))?;
+                };
+
+                project::Entity::update(project::ActiveModel {
+                    id: ActiveValue::set(project_id),
+                    host_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                    host_connection_server_id: ActiveValue::set(Some(ServerId(
+                        connection.owner_id as i32,
+                    ))),
+                    ..Default::default()
+                })
+                .exec(&*tx)
+                .await?;
+
+                let collaborators = project
+                    .find_related(project_collaborator::Entity)
+                    .all(&*tx)
+                    .await?;
+
+                self.update_project_worktrees(project_id, &reshared_project.worktrees, &tx)
+                    .await?;
+
+                ret.push(super::ResharedProject {
+                    id: project_id,
+                    old_connection_id,
+                    collaborators: collaborators
+                        .iter()
+                        .map(|collaborator| super::ProjectCollaborator {
+                            connection_id: collaborator.connection(),
+                            user_id: collaborator.user_id,
+                            replica_id: collaborator.replica_id,
+                            is_host: collaborator.is_host,
+                        })
+                        .collect(),
+                    worktrees: reshared_project.worktrees.clone(),
+                });
+            }
+            Ok(ret)
+        })
+        .await
+    }
+
+    pub async fn rejoin_dev_server_projects(
+        &self,
+        rejoined_projects: &Vec<proto::RejoinProject>,
+        user_id: UserId,
+        connection_id: ConnectionId,
+    ) -> crate::Result<Vec<RejoinedProject>> {
+        self.transaction(|tx| async move {
+            let mut ret = Vec::new();
+            for rejoined_project in rejoined_projects {
+                if let Some(project) = self
+                    .rejoin_project_internal(&tx, rejoined_project, user_id, connection_id)
+                    .await?
+                {
+                    ret.push(project);
+                }
+            }
+            Ok(ret)
+        })
+        .await
+    }
+}
--- a/crates/collab/src/db/queries/dev_servers.rs
+++ b/crates/collab/src/db/queries/dev_servers.rs
@@ -1 +1,222 @@
+use rpc::proto;
+use sea_orm::{
+    ActiveValue, ColumnTrait, DatabaseTransaction, EntityTrait, IntoActiveModel, QueryFilter,
+};

+use super::{dev_server, dev_server_project, Database, DevServerId, UserId};
+
+impl Database {
+    pub async fn get_dev_server(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> crate::Result<dev_server::Model> {
+        self.transaction(|tx| async move {
+            Ok(dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("no dev server with id {}", dev_server_id))?)
+        })
+        .await
+    }
+
+    pub async fn get_dev_server_for_user(
+        &self,
+        dev_server_id: DevServerId,
+        user_id: UserId,
+    ) -> crate::Result<dev_server::Model> {
+        self.transaction(|tx| async move {
+            let server = dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("no dev server with id {}", dev_server_id))?;
+            if server.user_id != user_id {
+                return Err(anyhow::anyhow!(
+                    "dev server {} is not owned by user {}",
+                    dev_server_id,
+                    user_id
+                ))?;
+            }
+            Ok(server)
+        })
+        .await
+    }
+
+    pub async fn get_dev_servers(&self, user_id: UserId) -> crate::Result<Vec<dev_server::Model>> {
+        self.transaction(|tx| async move {
+            Ok(dev_server::Entity::find()
+                .filter(dev_server::Column::UserId.eq(user_id))
+                .all(&*tx)
+                .await?)
+        })
+        .await
+    }
+
+    pub async fn dev_server_projects_update(
+        &self,
+        user_id: UserId,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            self.dev_server_projects_update_internal(user_id, &tx).await
+        })
+        .await
+    }
+
+    pub async fn dev_server_projects_update_internal(
+        &self,
+        user_id: UserId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        let dev_servers = dev_server::Entity::find()
+            .filter(dev_server::Column::UserId.eq(user_id))
+            .all(tx)
+            .await?;
+
+        let dev_server_projects = dev_server_project::Entity::find()
+            .filter(
+                dev_server_project::Column::DevServerId
+                    .is_in(dev_servers.iter().map(|d| d.id).collect::<Vec<_>>()),
+            )
+            .find_also_related(super::project::Entity)
+            .all(tx)
+            .await?;
+
+        Ok(proto::DevServerProjectsUpdate {
+            dev_servers: dev_servers
+                .into_iter()
+                .map(|d| d.to_proto(proto::DevServerStatus::Offline))
+                .collect(),
+            dev_server_projects: dev_server_projects
+                .into_iter()
+                .map(|(dev_server_project, project)| dev_server_project.to_proto(project))
+                .collect(),
+        })
+    }
+
+    pub async fn create_dev_server(
+        &self,
+        name: &str,
+        ssh_connection_string: Option<&str>,
+        hashed_access_token: &str,
+        user_id: UserId,
+    ) -> crate::Result<(dev_server::Model, proto::DevServerProjectsUpdate)> {
+        self.transaction(|tx| async move {
+            if name.trim().is_empty() {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            let dev_server = dev_server::Entity::insert(dev_server::ActiveModel {
+                id: ActiveValue::NotSet,
+                hashed_token: ActiveValue::Set(hashed_access_token.to_string()),
+                name: ActiveValue::Set(name.trim().to_string()),
+                user_id: ActiveValue::Set(user_id),
+                ssh_connection_string: ActiveValue::Set(
+                    ssh_connection_string.map(ToOwned::to_owned),
+                ),
+            })
+            .exec_with_returning(&*tx)
+            .await?;
+
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok((dev_server, dev_server_projects))
+        })
+        .await
+    }
+
+    pub async fn update_dev_server_token(
+        &self,
+        id: DevServerId,
+        hashed_token: &str,
+        user_id: UserId,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            let Some(dev_server) = dev_server::Entity::find_by_id(id).one(&*tx).await? else {
+                return Err(anyhow::anyhow!("no dev server with id {}", id))?;
+            };
+            if dev_server.user_id != user_id {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            dev_server::Entity::update(dev_server::ActiveModel {
+                hashed_token: ActiveValue::Set(hashed_token.to_string()),
+                ..dev_server.clone().into_active_model()
+            })
+            .exec(&*tx)
+            .await?;
+
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok(dev_server_projects)
+        })
+        .await
+    }
+
+    pub async fn rename_dev_server(
+        &self,
+        id: DevServerId,
+        name: &str,
+        ssh_connection_string: Option<&str>,
+        user_id: UserId,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            let Some(dev_server) = dev_server::Entity::find_by_id(id).one(&*tx).await? else {
+                return Err(anyhow::anyhow!("no dev server with id {}", id))?;
+            };
+            if dev_server.user_id != user_id || name.trim().is_empty() {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            dev_server::Entity::update(dev_server::ActiveModel {
+                name: ActiveValue::Set(name.trim().to_string()),
+                ssh_connection_string: ActiveValue::Set(
+                    ssh_connection_string.map(ToOwned::to_owned),
+                ),
+                ..dev_server.clone().into_active_model()
+            })
+            .exec(&*tx)
+            .await?;
+
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok(dev_server_projects)
+        })
+        .await
+    }
+
+    pub async fn delete_dev_server(
+        &self,
+        id: DevServerId,
+        user_id: UserId,
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            let Some(dev_server) = dev_server::Entity::find_by_id(id).one(&*tx).await? else {
+                return Err(anyhow::anyhow!("no dev server with id {}", id))?;
+            };
+            if dev_server.user_id != user_id {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            dev_server_project::Entity::delete_many()
+                .filter(dev_server_project::Column::DevServerId.eq(id))
+                .exec(&*tx)
+                .await?;
+
+            dev_server::Entity::delete(dev_server.into_active_model())
+                .exec(&*tx)
+                .await?;
+
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok(dev_server_projects)
+        })
+        .await
+    }
+}
--- a/crates/collab/src/db/queries/hosted_projects.rs
+++ b/crates/collab/src/db/queries/hosted_projects.rs
@@ -0,0 +1,85 @@
+use rpc::{proto, ErrorCode};
+
+use super::*;
+
+impl Database {
+    pub async fn get_hosted_projects(
+        &self,
+        channel_ids: &[ChannelId],
+        roles: &HashMap<ChannelId, ChannelRole>,
+        tx: &DatabaseTransaction,
+    ) -> Result<Vec<proto::HostedProject>> {
+        let projects = hosted_project::Entity::find()
+            .find_also_related(project::Entity)
+            .filter(hosted_project::Column::ChannelId.is_in(channel_ids.iter().map(|id| id.0)))
+            .all(tx)
+            .await?
+            .into_iter()
+            .flat_map(|(hosted_project, project)| {
+                if hosted_project.deleted_at.is_some() {
+                    return None;
+                }
+                match hosted_project.visibility {
+                    ChannelVisibility::Public => {}
+                    ChannelVisibility::Members => {
+                        let is_visible = roles
+                            .get(&hosted_project.channel_id)
+                            .map(|role| role.can_see_all_descendants())
+                            .unwrap_or(false);
+                        if !is_visible {
+                            return None;
+                        }
+                    }
+                };
+                Some(proto::HostedProject {
+                    project_id: project?.id.to_proto(),
+                    channel_id: hosted_project.channel_id.to_proto(),
+                    name: hosted_project.name.clone(),
+                    visibility: hosted_project.visibility.into(),
+                })
+            })
+            .collect();
+
+        Ok(projects)
+    }
+
+    pub async fn get_hosted_project(
+        &self,
+        hosted_project_id: HostedProjectId,
+        user_id: UserId,
+        tx: &DatabaseTransaction,
+    ) -> Result<(hosted_project::Model, ChannelRole)> {
+        let project = hosted_project::Entity::find_by_id(hosted_project_id)
+            .one(tx)
+            .await?
+            .ok_or_else(|| anyhow!(ErrorCode::NoSuchProject))?;
+        let channel = channel::Entity::find_by_id(project.channel_id)
+            .one(tx)
+            .await?
+            .ok_or_else(|| anyhow!(ErrorCode::NoSuchChannel))?;
+
+        let role = match project.visibility {
+            ChannelVisibility::Public => {
+                self.check_user_is_channel_participant(&channel, user_id, tx)
+                    .await?
+            }
+            ChannelVisibility::Members => {
+                self.check_user_is_channel_member(&channel, user_id, tx)
+                    .await?
+            }
+        };
+
+        Ok((project, role))
+    }
+
+    pub async fn is_hosted_project(&self, project_id: ProjectId) -> Result<bool> {
+        self.transaction(|tx| async move {
+            Ok(project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .map(|project| project.hosted_project_id.is_some())
+                .ok_or_else(|| anyhow!(ErrorCode::NoSuchProject))?)
+        })
+        .await
+    }
+}
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -32,6 +32,7 @@ impl Database {
        connection: ConnectionId,
        worktrees: &[proto::WorktreeMetadata],
        is_ssh_project: bool,
+        dev_server_project_id: Option<DevServerProjectId>,
    ) -> Result<TransactionGuard<(ProjectId, proto::Room)>> {
        self.room_transaction(room_id, |tx| async move {
            let participant = room_participant::Entity::find()
@@ -60,6 +61,38 @@ impl Database {
                return Err(anyhow!("guests cannot share projects"))?;
            }

+            if let Some(dev_server_project_id) = dev_server_project_id {
+                let project = project::Entity::find()
+                    .filter(project::Column::DevServerProjectId.eq(Some(dev_server_project_id)))
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| anyhow!("no remote project"))?;
+
+                let (_, dev_server) = dev_server_project::Entity::find_by_id(dev_server_project_id)
+                    .find_also_related(dev_server::Entity)
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| anyhow!("no dev_server_project"))?;
+
+                if !dev_server.is_some_and(|dev_server| dev_server.user_id == participant.user_id) {
+                    return Err(anyhow!("not your dev server"))?;
+                }
+
+                if project.room_id.is_some() {
+                    return Err(anyhow!("project already shared"))?;
+                };
+
+                let project = project::Entity::update(project::ActiveModel {
+                    room_id: ActiveValue::Set(Some(room_id)),
+                    ..project.into_active_model()
+                })
+                .exec(&*tx)
+                .await?;
+
+                let room = self.get_room(room_id, &tx).await?;
+                return Ok((project.id, room));
+            }
+
            let project = project::ActiveModel {
                room_id: ActiveValue::set(Some(participant.room_id)),
                host_user_id: ActiveValue::set(Some(participant.user_id)),
@@ -68,6 +101,8 @@ impl Database {
                    connection.owner_id as i32,
                ))),
                id: ActiveValue::NotSet,
+                hosted_project_id: ActiveValue::Set(None),
+                dev_server_project_id: ActiveValue::Set(None),
            }
            .insert(&*tx)
            .await?;
@@ -121,6 +156,7 @@ impl Database {
        &self,
        project_id: ProjectId,
        connection: ConnectionId,
+        user_id: Option<UserId>,
    ) -> Result<TransactionGuard<(bool, Option<proto::Room>, Vec<ConnectionId>)>> {
        self.project_transaction(project_id, |tx| async move {
            let guest_connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
@@ -136,6 +172,25 @@ impl Database {
            if project.host_connection()? == connection {
                return Ok((true, room, guest_connection_ids));
            }
+            if let Some(dev_server_project_id) = project.dev_server_project_id {
+                if let Some(user_id) = user_id {
+                    if user_id
+                        != self
+                            .owner_for_dev_server_project(dev_server_project_id, &tx)
+                            .await?
+                    {
+                        Err(anyhow!("cannot unshare a project hosted by another user"))?
+                    }
+                    project::Entity::update(project::ActiveModel {
+                        room_id: ActiveValue::Set(None),
+                        ..project.into_active_model()
+                    })
+                    .exec(&*tx)
+                    .await?;
+                    return Ok((false, room, guest_connection_ids));
+                }
+            }
+
            Err(anyhow!("cannot unshare a project hosted by another user"))?
        })
        .await
@@ -217,16 +272,6 @@ impl Database {
        update: &proto::UpdateWorktree,
        connection: ConnectionId,
    ) -> Result<TransactionGuard<Vec<ConnectionId>>> {
-        if update.removed_entries.len() > proto::MAX_WORKTREE_UPDATE_MAX_CHUNK_SIZE
-            || update.updated_entries.len() > proto::MAX_WORKTREE_UPDATE_MAX_CHUNK_SIZE
-        {
-            return Err(anyhow!(
-                "invalid worktree update. removed entries: {}, updated entries: {}",
-                update.removed_entries.len(),
-                update.updated_entries.len()
-            ))?;
-        }
-
        let project_id = ProjectId::from_proto(update.project_id);
        let worktree_id = update.worktree_id as i64;
        self.project_transaction(project_id, |tx| async move {
@@ -535,6 +580,39 @@ impl Database {
        .await
    }

+    /// Adds the given connection to the specified hosted project
+    pub async fn join_hosted_project(
+        &self,
+        id: ProjectId,
+        user_id: UserId,
+        connection: ConnectionId,
+    ) -> Result<(Project, ReplicaId)> {
+        self.transaction(|tx| async move {
+            let (project, hosted_project) = project::Entity::find_by_id(id)
+                .find_also_related(hosted_project::Entity)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("hosted project is no longer shared"))?;
+
+            let Some(hosted_project) = hosted_project else {
+                return Err(anyhow!("project is not hosted"))?;
+            };
+
+            let channel = channel::Entity::find_by_id(hosted_project.channel_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such channel"))?;
+
+            let role = self
+                .check_user_is_channel_participant(&channel, user_id, &tx)
+                .await?;
+
+            self.join_project_internal(project, user_id, connection, role, &tx)
+                .await
+        })
+        .await
+    }
+
    pub async fn get_project(&self, id: ProjectId) -> Result<project::Model> {
        self.transaction(|tx| async move {
            Ok(project::Entity::find_by_id(id)
@@ -545,6 +623,17 @@ impl Database {
        .await
    }

+    pub async fn find_dev_server_project(&self, id: DevServerProjectId) -> Result<project::Model> {
+        self.transaction(|tx| async move {
+            Ok(project::Entity::find()
+                .filter(project::Column::DevServerProjectId.eq(id))
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?)
+        })
+        .await
+    }
+
    /// Adds the given connection to the specified project
    /// in the current room.
    pub async fn join_project(
@@ -555,7 +644,13 @@ impl Database {
    ) -> Result<TransactionGuard<(Project, ReplicaId)>> {
        self.project_transaction(project_id, |tx| async move {
            let (project, role) = self
-                .access_project(project_id, connection, Capability::ReadOnly, &tx)
+                .access_project(
+                    project_id,
+                    connection,
+                    PrincipalId::UserId(user_id),
+                    Capability::ReadOnly,
+                    &tx,
+                )
                .await?;
            self.join_project_internal(project, user_id, connection, role, &tx)
                .await
@@ -746,10 +841,54 @@ impl Database {
                    worktree_id: None,
                })
                .collect(),
+            dev_server_project_id: project.dev_server_project_id,
        };
        Ok((project, replica_id as ReplicaId))
    }

+    pub async fn leave_hosted_project(
+        &self,
+        project_id: ProjectId,
+        connection: ConnectionId,
+    ) -> Result<LeftProject> {
+        self.transaction(|tx| async move {
+            let result = project_collaborator::Entity::delete_many()
+                .filter(
+                    Condition::all()
+                        .add(project_collaborator::Column::ProjectId.eq(project_id))
+                        .add(project_collaborator::Column::ConnectionId.eq(connection.id as i32))
+                        .add(
+                            project_collaborator::Column::ConnectionServerId
+                                .eq(connection.owner_id as i32),
+                        ),
+                )
+                .exec(&*tx)
+                .await?;
+            if result.rows_affected == 0 {
+                return Err(anyhow!("not in the project"))?;
+            }
+
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
+            let collaborators = project
+                .find_related(project_collaborator::Entity)
+                .all(&*tx)
+                .await?;
+            let connection_ids = collaborators
+                .into_iter()
+                .map(|collaborator| collaborator.connection())
+                .collect();
+            Ok(LeftProject {
+                id: project.id,
+                connection_ids,
+                should_unshare: false,
+            })
+        })
+        .await
+    }
+
    /// Removes the given connection from the specified project.
    pub async fn leave_project(
        &self,
@@ -858,14 +997,29 @@ impl Database {
        &self,
        project_id: ProjectId,
        connection_id: ConnectionId,
+        principal_id: PrincipalId,
        capability: Capability,
        tx: &DatabaseTransaction,
    ) -> Result<(project::Model, ChannelRole)> {
-        let project = project::Entity::find_by_id(project_id)
+        let (mut project, dev_server_project) = project::Entity::find_by_id(project_id)
+            .find_also_related(dev_server_project::Entity)
            .one(tx)
            .await?
            .ok_or_else(|| anyhow!("no such project"))?;

+        let user_id = match principal_id {
+            PrincipalId::DevServerId(_) => {
+                if project
+                    .host_connection()
+                    .is_ok_and(|connection| connection == connection_id)
+                {
+                    return Ok((project, ChannelRole::Admin));
+                }
+                return Err(anyhow!("not the project host"))?;
+            }
+            PrincipalId::UserId(user_id) => user_id,
+        };
+
        let role_from_room = if let Some(room_id) = project.room_id {
            room_participant::Entity::find()
                .filter(room_participant::Column::RoomId.eq(room_id))
@@ -876,8 +1030,34 @@ impl Database {
        } else {
            None
        };
+        let role_from_dev_server = if let Some(dev_server_project) = dev_server_project {
+            let dev_server = dev_server::Entity::find_by_id(dev_server_project.dev_server_id)
+                .one(tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such channel"))?;
+            if user_id == dev_server.user_id {
+                // If the user left the room "uncleanly" they may rejoin the
+                // remote project before leave_room runs. IN that case kick
+                // the project out of the room pre-emptively.
+                if role_from_room.is_none() {
+                    project = project::Entity::update(project::ActiveModel {
+                        room_id: ActiveValue::Set(None),
+                        ..project.into_active_model()
+                    })
+                    .exec(tx)
+                    .await?;
+                }
+                Some(ChannelRole::Admin)
+            } else {
+                None
+            }
+        } else {
+            None
+        };

-        let role = role_from_room.unwrap_or(ChannelRole::Banned);
+        let role = role_from_dev_server
+            .or(role_from_room)
+            .unwrap_or(ChannelRole::Banned);

        match capability {
            Capability::ReadWrite => {
@@ -900,10 +1080,17 @@ impl Database {
        &self,
        project_id: ProjectId,
        connection_id: ConnectionId,
+        user_id: UserId,
    ) -> Result<ConnectionId> {
        self.project_transaction(project_id, |tx| async move {
            let (project, _) = self
-                .access_project(project_id, connection_id, Capability::ReadOnly, &tx)
+                .access_project(
+                    project_id,
+                    connection_id,
+                    PrincipalId::UserId(user_id),
+                    Capability::ReadOnly,
+                    &tx,
+                )
                .await?;
            project.host_connection()
        })
@@ -916,10 +1103,17 @@ impl Database {
        &self,
        project_id: ProjectId,
        connection_id: ConnectionId,
+        user_id: UserId,
    ) -> Result<ConnectionId> {
        self.project_transaction(project_id, |tx| async move {
            let (project, _) = self
-                .access_project(project_id, connection_id, Capability::ReadWrite, &tx)
+                .access_project(
+                    project_id,
+                    connection_id,
+                    PrincipalId::UserId(user_id),
+                    Capability::ReadWrite,
+                    &tx,
+                )
                .await?;
            project.host_connection()
        })
@@ -927,16 +1121,47 @@ impl Database {
        .map(|guard| guard.into_inner())
    }

+    /// Returns the host connection for a request to join a shared project.
+    pub async fn host_for_owner_project_request(
+        &self,
+        project_id: ProjectId,
+        _connection_id: ConnectionId,
+        user_id: UserId,
+    ) -> Result<ConnectionId> {
+        self.project_transaction(project_id, |tx| async move {
+            let (project, dev_server_project) = project::Entity::find_by_id(project_id)
+                .find_also_related(dev_server_project::Entity)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
+
+            let Some(dev_server_project) = dev_server_project else {
+                return Err(anyhow!("not a dev server project"))?;
+            };
+            let dev_server = dev_server::Entity::find_by_id(dev_server_project.dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such dev server"))?;
+            if dev_server.user_id != user_id {
+                return Err(anyhow!("not your project"))?;
+            }
+            project.host_connection()
+        })
+        .await
+        .map(|guard| guard.into_inner())
+    }
+
    pub async fn connections_for_buffer_update(
        &self,
        project_id: ProjectId,
+        principal_id: PrincipalId,
        connection_id: ConnectionId,
        capability: Capability,
    ) -> Result<TransactionGuard<(ConnectionId, Vec<ConnectionId>)>> {
        self.project_transaction(project_id, |tx| async move {
            // Authorize
            let (project, _) = self
-                .access_project(project_id, connection_id, capability, &tx)
+                .access_project(project_id, connection_id, principal_id, capability, &tx)
                .await?;

            let host_connection_id = project.host_connection()?;
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -858,6 +858,25 @@ impl Database {
                    .all(&*tx)
                    .await?;

+                // if any project in the room has a remote-project-id that belongs to a dev server that this user owns.
+                let dev_server_projects_for_user = self
+                    .dev_server_project_ids_for_user(leaving_participant.user_id, &tx)
+                    .await?;
+
+                let dev_server_projects_to_unshare = project::Entity::find()
+                    .filter(
+                        Condition::all()
+                            .add(project::Column::RoomId.eq(room_id))
+                            .add(
+                                project::Column::DevServerProjectId
+                                    .is_in(dev_server_projects_for_user.clone()),
+                            ),
+                    )
+                    .all(&*tx)
+                    .await?
+                    .into_iter()
+                    .map(|project| project.id)
+                    .collect::<HashSet<_>>();
                let mut left_projects = HashMap::default();
                let mut collaborators = project_collaborator::Entity::find()
                    .filter(project_collaborator::Column::ProjectId.is_in(project_ids))
@@ -880,7 +899,9 @@ impl Database {
                        left_project.connection_ids.push(collaborator_connection_id);
                    }

-                    if collaborator.is_host && collaborator.connection() == connection {
+                    if (collaborator.is_host && collaborator.connection() == connection)
+                        || dev_server_projects_to_unshare.contains(&collaborator.project_id)
+                    {
                        left_project.should_unshare = true;
                    }
                }
@@ -923,6 +944,17 @@ impl Database {
                    .exec(&*tx)
                    .await?;

+                if !dev_server_projects_to_unshare.is_empty() {
+                    project::Entity::update_many()
+                        .filter(project::Column::Id.is_in(dev_server_projects_to_unshare))
+                        .set(project::ActiveModel {
+                            room_id: ActiveValue::Set(None),
+                            ..Default::default()
+                        })
+                        .exec(&*tx)
+                        .await?;
+                }
+
                let (channel, room) = self.get_channel_room(room_id, &tx).await?;
                let deleted = if room.participants.is_empty() {
                    let result = room::Entity::delete_by_id(room_id).exec(&*tx).await?;
@@ -1291,6 +1323,26 @@ impl Database {
                        project.worktree_root_names.push(db_worktree.root_name);
                    }
                }
+            } else if let Some(dev_server_project_id) = db_project.dev_server_project_id {
+                let host = self
+                    .owner_for_dev_server_project(dev_server_project_id, tx)
+                    .await?;
+                if let Some((_, participant)) = participants
+                    .iter_mut()
+                    .find(|(_, v)| v.user_id == host.to_proto())
+                {
+                    participant.projects.push(proto::ParticipantProject {
+                        id: db_project.id.to_proto(),
+                        worktree_root_names: Default::default(),
+                    });
+                    let project = participant.projects.last_mut().unwrap();
+
+                    for db_worktree in db_worktrees {
+                        if db_worktree.visible {
+                            project.worktree_root_names.push(db_worktree.root_name);
+                        }
+                    }
+                }
            }
        }

--- a/crates/collab/src/db/tables.rs
+++ b/crates/collab/src/db/tables.rs
@@ -13,11 +13,14 @@ pub mod channel_message;
 pub mod channel_message_mention;
 pub mod contact;
 pub mod contributor;
+pub mod dev_server;
+pub mod dev_server_project;
 pub mod embedding;
 pub mod extension;
 pub mod extension_version;
 pub mod feature_flag;
 pub mod follower;
+pub mod hosted_project;
 pub mod language_server;
 pub mod notification;
 pub mod notification_kind;
--- a/crates/collab/src/db/tables/dev_server.rs
+++ b/crates/collab/src/db/tables/dev_server.rs
@@ -0,0 +1,39 @@
+use crate::db::{DevServerId, UserId};
+use rpc::proto;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "dev_servers")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: DevServerId,
+    pub name: String,
+    pub user_id: UserId,
+    pub hashed_token: String,
+    pub ssh_connection_string: Option<String>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::dev_server_project::Entity")]
+    RemoteProject,
+}
+
+impl Related<super::dev_server_project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::RemoteProject.def()
+    }
+}
+
+impl Model {
+    pub fn to_proto(&self, status: proto::DevServerStatus) -> proto::DevServer {
+        proto::DevServer {
+            dev_server_id: self.id.to_proto(),
+            name: self.name.clone(),
+            status: status as i32,
+            ssh_connection_string: self.ssh_connection_string.clone(),
+        }
+    }
+}
--- a/crates/collab/src/db/tables/dev_server_project.rs
+++ b/crates/collab/src/db/tables/dev_server_project.rs
@@ -0,0 +1,59 @@
+use super::project;
+use crate::db::{DevServerId, DevServerProjectId};
+use rpc::proto;
+use sea_orm::{entity::prelude::*, FromJsonQueryResult};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "dev_server_projects")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: DevServerProjectId,
+    pub dev_server_id: DevServerId,
+    pub paths: JSONPaths,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct JSONPaths(pub Vec<String>);
+
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_one = "super::project::Entity")]
+    Project,
+    #[sea_orm(
+        belongs_to = "super::dev_server::Entity",
+        from = "Column::DevServerId",
+        to = "super::dev_server::Column::Id"
+    )]
+    DevServer,
+}
+
+impl Related<super::project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Project.def()
+    }
+}
+
+impl Related<super::dev_server::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::DevServer.def()
+    }
+}
+
+impl Model {
+    pub fn to_proto(&self, project: Option<project::Model>) -> proto::DevServerProject {
+        proto::DevServerProject {
+            id: self.id.to_proto(),
+            project_id: project.map(|p| p.id.to_proto()),
+            dev_server_id: self.dev_server_id.to_proto(),
+            path: self.paths().first().cloned().unwrap_or_default(),
+            paths: self.paths().clone(),
+        }
+    }
+
+    pub fn paths(&self) -> &Vec<String> {
+        &self.paths.0
+    }
+}
--- a/crates/collab/src/db/tables/hosted_project.rs
+++ b/crates/collab/src/db/tables/hosted_project.rs
@@ -0,0 +1,27 @@
+use crate::db::{ChannelId, ChannelVisibility, HostedProjectId};
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "hosted_projects")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: HostedProjectId,
+    pub channel_id: ChannelId,
+    pub name: String,
+    pub visibility: ChannelVisibility,
+    pub deleted_at: Option<DateTime>,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_one = "super::project::Entity")]
+    Project,
+}
+
+impl Related<super::project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Project.def()
+    }
+}
--- a/crates/collab/src/db/tables/project.rs
+++ b/crates/collab/src/db/tables/project.rs
@@ -1,4 +1,4 @@
-use crate::db::{ProjectId, Result, RoomId, ServerId, UserId};
+use crate::db::{DevServerProjectId, HostedProjectId, ProjectId, Result, RoomId, ServerId, UserId};
 use anyhow::anyhow;
 use rpc::ConnectionId;
 use sea_orm::entity::prelude::*;
@@ -12,6 +12,8 @@ pub struct Model {
    pub host_user_id: Option<UserId>,
    pub host_connection_id: Option<i32>,
    pub host_connection_server_id: Option<ServerId>,
+    pub hosted_project_id: Option<HostedProjectId>,
+    pub dev_server_project_id: Option<DevServerProjectId>,
 }

 impl Model {
@@ -49,6 +51,18 @@ pub enum Relation {
    Collaborators,
    #[sea_orm(has_many = "super::language_server::Entity")]
    LanguageServers,
+    #[sea_orm(
+        belongs_to = "super::hosted_project::Entity",
+        from = "Column::HostedProjectId",
+        to = "super::hosted_project::Column::Id"
+    )]
+    HostedProject,
+    #[sea_orm(
+        belongs_to = "super::dev_server_project::Entity",
+        from = "Column::DevServerProjectId",
+        to = "super::dev_server_project::Column::Id"
+    )]
+    RemoteProject,
 }

 impl Related<super::user::Entity> for Entity {
@@ -81,4 +95,16 @@ impl Related<super::language_server::Entity> for Entity {
    }
 }

+impl Related<super::hosted_project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::HostedProject.def()
+    }
+}
+
+impl Related<super::dev_server_project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::RemoteProject.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}
--- a/crates/collab/src/db/tests/buffer_tests.rs
+++ b/crates/collab/src/db/tests/buffer_tests.rs
@@ -121,13 +121,11 @@ async fn test_channel_buffers(db: &Arc<Database>) {
                user_id: a_id.to_proto(),
                peer_id: Some(rpc::proto::PeerId { id: 1, owner_id }),
                replica_id: 0,
-                is_host: false,
            },
            rpc::proto::Collaborator {
                user_id: b_id.to_proto(),
                peer_id: Some(rpc::proto::PeerId { id: 2, owner_id }),
                replica_id: 1,
-                is_host: false,
            }
        ]
    );
--- a/crates/collab/src/db/tests/db_tests.rs
+++ b/crates/collab/src/db/tests/db_tests.rs
@@ -540,18 +540,18 @@ async fn test_project_count(db: &Arc<Database>) {
        .unwrap();
    assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);

-    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], false)
+    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], false, None)
        .await
        .unwrap();
    assert_eq!(db.project_count_excluding_admins().await.unwrap(), 1);

-    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], false)
+    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], false, None)
        .await
        .unwrap();
    assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);

    // Projects shared by admins aren't counted.
-    db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[], false)
+    db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[], false, None)
        .await
        .unwrap();
    assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
--- a/crates/collab/src/llm.rs
+++ b/crates/collab/src/llm.rs
@@ -449,10 +449,6 @@ async fn check_usage_limit(
    model_name: &str,
    claims: &LlmTokenClaims,
 ) -> Result<()> {
-    if claims.is_staff {
-        return Ok(());
-    }
-
    let model = state.db.model(provider, model_name)?;
    let usage = state
        .db
@@ -517,6 +513,11 @@ async fn check_usage_limit(
    ];

    for (used, limit, usage_measure) in checks {
+        // Temporarily bypass rate-limiting for staff members.
+        if claims.is_staff {
+            continue;
+        }
+
        if used > limit {
            let resource = match usage_measure {
                UsageMeasure::RequestsPerMinute => "requests_per_minute",
--- a/crates/collab/src/main.rs
+++ b/crates/collab/src/main.rs
@@ -84,8 +84,6 @@ async fn main() -> Result<()> {

            let config = envy::from_env::<Config>().expect("error loading config");
            init_tracing(&config);
-            init_panic_hook();
-
            let mut app = Router::new()
                .route("/", get(handle_root))
                .route("/healthz", get(handle_liveness_probe))
@@ -380,20 +378,3 @@ pub fn init_tracing(config: &Config) -> Option<()> {

    None
 }
-
-fn init_panic_hook() {
-    std::panic::set_hook(Box::new(move |panic_info| {
-        let panic_message = match panic_info.payload().downcast_ref::<&'static str>() {
-            Some(message) => *message,
-            None => match panic_info.payload().downcast_ref::<String>() {
-                Some(message) => message.as_str(),
-                None => "Box<Any>",
-            },
-        };
-        let backtrace = std::backtrace::Backtrace::force_capture();
-        let location = panic_info
-            .location()
-            .map(|loc| format!("{}:{}", loc.file(), loc.line()));
-        tracing::error!(panic = true, ?location, %panic_message, %backtrace, "Server Panic");
-    }));
-}
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
--- a/crates/collab/src/rpc/connection_pool.rs
+++ b/crates/collab/src/rpc/connection_pool.rs
@@ -1,7 +1,7 @@
-use crate::db::{ChannelId, ChannelRole, UserId};
+use crate::db::{ChannelId, ChannelRole, DevServerId, PrincipalId, UserId};
 use anyhow::{anyhow, Result};
 use collections::{BTreeMap, HashMap, HashSet};
-use rpc::ConnectionId;
+use rpc::{proto, ConnectionId};
 use semantic_version::SemanticVersion;
 use serde::Serialize;
 use std::fmt;
@@ -11,7 +11,9 @@ use tracing::instrument;
 pub struct ConnectionPool {
    connections: BTreeMap<ConnectionId, Connection>,
    connected_users: BTreeMap<UserId, ConnectedPrincipal>,
+    connected_dev_servers: BTreeMap<DevServerId, ConnectionId>,
    channels: ChannelPool,
+    offline_dev_servers: HashSet<DevServerId>,
 }

 #[derive(Default, Serialize)]
@@ -30,13 +32,13 @@ impl fmt::Display for ZedVersion {

 impl ZedVersion {
    pub fn can_collaborate(&self) -> bool {
-        self.0 >= SemanticVersion::new(0, 157, 0)
+        self.0 >= SemanticVersion::new(0, 151, 0)
    }
 }

 #[derive(Serialize)]
 pub struct Connection {
-    pub user_id: UserId,
+    pub principal_id: PrincipalId,
    pub admin: bool,
    pub zed_version: ZedVersion,
 }
@@ -45,6 +47,7 @@ impl ConnectionPool {
    pub fn reset(&mut self) {
        self.connections.clear();
        self.connected_users.clear();
+        self.connected_dev_servers.clear();
        self.channels.clear();
    }

@@ -63,7 +66,7 @@ impl ConnectionPool {
        self.connections.insert(
            connection_id,
            Connection {
-                user_id,
+                principal_id: PrincipalId::UserId(user_id),
                admin,
                zed_version,
            },
@@ -72,6 +75,25 @@ impl ConnectionPool {
        connected_user.connection_ids.insert(connection_id);
    }

+    pub fn add_dev_server(
+        &mut self,
+        connection_id: ConnectionId,
+        dev_server_id: DevServerId,
+        zed_version: ZedVersion,
+    ) {
+        self.connections.insert(
+            connection_id,
+            Connection {
+                principal_id: PrincipalId::DevServerId(dev_server_id),
+                admin: false,
+                zed_version,
+            },
+        );
+
+        self.connected_dev_servers
+            .insert(dev_server_id, connection_id);
+    }
+
    #[instrument(skip(self))]
    pub fn remove_connection(&mut self, connection_id: ConnectionId) -> Result<()> {
        let connection = self
@@ -79,18 +101,28 @@ impl ConnectionPool {
            .get_mut(&connection_id)
            .ok_or_else(|| anyhow!("no such connection"))?;

-        let user_id = connection.user_id;
-
-        let connected_user = self.connected_users.get_mut(&user_id).unwrap();
-        connected_user.connection_ids.remove(&connection_id);
-        if connected_user.connection_ids.is_empty() {
-            self.connected_users.remove(&user_id);
-            self.channels.remove_user(&user_id);
-        };
+        match connection.principal_id {
+            PrincipalId::UserId(user_id) => {
+                let connected_user = self.connected_users.get_mut(&user_id).unwrap();
+                connected_user.connection_ids.remove(&connection_id);
+                if connected_user.connection_ids.is_empty() {
+                    self.connected_users.remove(&user_id);
+                    self.channels.remove_user(&user_id);
+                }
+            }
+            PrincipalId::DevServerId(dev_server_id) => {
+                self.connected_dev_servers.remove(&dev_server_id);
+                self.offline_dev_servers.remove(&dev_server_id);
+            }
+        }
        self.connections.remove(&connection_id).unwrap();
        Ok(())
    }

+    pub fn set_dev_server_offline(&mut self, dev_server_id: DevServerId) {
+        self.offline_dev_servers.insert(dev_server_id);
+    }
+
    pub fn connections(&self) -> impl Iterator<Item = &Connection> {
        self.connections.values()
    }
@@ -115,6 +147,42 @@ impl ConnectionPool {
            .copied()
    }

+    pub fn dev_server_status(&self, dev_server_id: DevServerId) -> proto::DevServerStatus {
+        if self.dev_server_connection_id(dev_server_id).is_some()
+            && !self.offline_dev_servers.contains(&dev_server_id)
+        {
+            proto::DevServerStatus::Online
+        } else {
+            proto::DevServerStatus::Offline
+        }
+    }
+
+    pub fn dev_server_connection_id(&self, dev_server_id: DevServerId) -> Option<ConnectionId> {
+        self.connected_dev_servers.get(&dev_server_id).copied()
+    }
+
+    pub fn online_dev_server_connection_id(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> Result<ConnectionId> {
+        match self.connected_dev_servers.get(&dev_server_id) {
+            Some(cid) => Ok(*cid),
+            None => Err(anyhow!(proto::ErrorCode::DevServerOffline)),
+        }
+    }
+
+    pub fn dev_server_connection_id_supporting(
+        &self,
+        dev_server_id: DevServerId,
+        required: ZedVersion,
+    ) -> Result<ConnectionId> {
+        match self.connected_dev_servers.get(&dev_server_id) {
+            Some(cid) if self.connections[cid].zed_version >= required => Ok(*cid),
+            Some(_) => Err(anyhow!(proto::ErrorCode::RemoteUpgradeRequired)),
+            None => Err(anyhow!(proto::ErrorCode::DevServerOffline)),
+        }
+    }
+
    pub fn channel_user_ids(
        &self,
        channel_id: ChannelId,
@@ -159,22 +227,39 @@ impl ConnectionPool {
    #[cfg(test)]
    pub fn check_invariants(&self) {
        for (connection_id, connection) in &self.connections {
-            assert!(self
-                .connected_users
-                .get(&connection.user_id)
-                .unwrap()
-                .connection_ids
-                .contains(connection_id));
+            match &connection.principal_id {
+                PrincipalId::UserId(user_id) => {
+                    assert!(self
+                        .connected_users
+                        .get(user_id)
+                        .unwrap()
+                        .connection_ids
+                        .contains(connection_id));
+                }
+                PrincipalId::DevServerId(dev_server_id) => {
+                    assert_eq!(
+                        self.connected_dev_servers.get(dev_server_id).unwrap(),
+                        connection_id
+                    );
+                }
+            }
        }

        for (user_id, state) in &self.connected_users {
            for connection_id in &state.connection_ids {
                assert_eq!(
-                    self.connections.get(connection_id).unwrap().user_id,
-                    *user_id
+                    self.connections.get(connection_id).unwrap().principal_id,
+                    PrincipalId::UserId(*user_id)
                );
            }
        }
+
+        for (dev_server_id, connection_id) in &self.connected_dev_servers {
+            assert_eq!(
+                self.connections.get(connection_id).unwrap().principal_id,
+                PrincipalId::DevServerId(*dev_server_id)
+            );
+        }
    }
 }

--- a/crates/collab/src/tests.rs
+++ b/crates/collab/src/tests.rs
@@ -8,6 +8,7 @@ mod channel_buffer_tests;
 mod channel_guest_tests;
 mod channel_message_tests;
 mod channel_tests;
+mod dev_server_tests;
 mod editor_tests;
 mod following_tests;
 mod integration_tests;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Antonio Scandurra	967dd02414	WIP: start using replace blocks for patches	2024-10-24 16:33:15 +02:00
Antonio Scandurra	a32dd07e27	Fix BlockMap::buffer_rows now that we have replacement blocks	2024-10-24 12:41:26 +02:00
Antonio Scandurra	57333fdcf0	Ensure clipping `BlockPoint`s right works correctly	2024-10-24 12:17:35 +02:00
Antonio Scandurra	dd5b4f23e6	Ensure replace blocks are at least one line tall Otherwise it becomes impossible to address certain ranges in the buffer.	2024-10-24 11:46:14 +02:00
Antonio Scandurra	397c19c103	WIP: start on fixing point translation in BlockMap SEED=437554 SIMPLE_TEXT=1 OPERATIONS=1 cargo test --package=editor random_blocks Co-Authored-By: Richard <richard@zed.dev>	2024-10-23 17:08:18 +02:00
Antonio Scandurra	5f515089ad	Fix `BlockMap::longest_row`	2024-10-23 14:48:09 +02:00
Antonio Scandurra	f8fe881631	Include zero-height blocks in expected blocks	2024-10-23 13:44:27 +02:00
Antonio Scandurra	10eed50765	Include replacements in expected blocks	2024-10-23 13:37:32 +02:00
Antonio Scandurra	6b44b11fc4	Fix randomized tests (passing with 20 operations, 1m iterations) Now we need to uncomment other parts of the randomized test (e.g., buffer rows)	2024-10-23 12:47:57 +02:00
Max Brunsfeld	2bb7567cbb	Re-enable non-singleton multibuffers in random blocks test failure:RUST_LOG=info SIMPLE_TEXT=1 OPERATIONS=2 ITERATIONS=1 SEED=26086 ct -p editor random_blocks -- --nocapture	2024-10-22 17:06:32 -07:00
Max Brunsfeld	0d8b8492f0	Merge branch 'main' into block-placement-2	2024-10-22 16:34:56 -07:00
Richard Feldman	4bf61f892f	Get text chunks assertions in BlockMap randomized tests passing Co-authored-by: Richard <richard@zed.dev> Co-authored-by: Antonio <antonio@zed.dev>	2024-10-22 16:20:15 -07:00
Antonio Scandurra	fc524ad02a	WIP: failing test, see below RUST_LOG=info SEED=22484 SIMPLE_TEXT=1 ITERATIONS=1 OPERATIONS=5 cargo test -p editor test_random_blocks -- --nocapture	2024-10-22 18:13:39 +02:00
Antonio Scandurra	607fb34124	Clarify how the expected text is constructed in randomized test Co-Authored-By: Nathan <nathan@zed.dev>	2024-10-22 17:01:01 +02:00
Antonio Scandurra	a931c7ac06	Make BlockMap::chunks randomized tests pass again with OPERATIONS=1	2024-10-22 14:00:45 +02:00
Antonio Scandurra	9322069dce	Fix some randomized test failures with OPERATIONS=1 I disabled all assertions but the ones that exercise `chunks`, as I'd like to make sure that things work at a basic level. We should re-enable the remaining assertions once basic features work correctly.	2024-10-22 13:42:30 +02:00
Antonio Scandurra	52732e75a0	Sort and deduplicate blocks correctly	2024-10-22 10:58:35 +02:00
Nathan Sobo	192aa78f94	Start on including replace blocks in randomized test Simple failure with OPERATIONS=1 Co-Authored-By: Max <max@zed.dev>	2024-10-21 18:41:34 -06:00
Max Brunsfeld	c50b572faf	Avoid subtraction overflow in BlockChunks::next When the end of a block is after the max row, don't overflow. Co-authored-by: Nathan <nathan@zed.dev>	2024-10-21 16:47:20 -07:00
Max Brunsfeld	2e54737a23	Get existing BlockMap randomized test passing Co-authored-by: Nathan <nathan@zed.dev> Co-authored-by: Richard <richard@zed.dev>	2024-10-21 16:15:22 -07:00
Antonio Scandurra	2e0ae8f1e1	Checkpoint Co-Authored-By: Max <max@zed.dev> Co-Authored-By: Richard <richard@zed.dev> Co-Authored-By: Marshall <marshall@zed.dev> Co-Authored-By: Nathan <nathan@zed.dev>	2024-10-21 20:11:12 +02:00
Antonio Scandurra	f92c892b49	WIP	2024-10-21 17:51:04 +02:00
Antonio Scandurra	1504f9d661	Seek input chunks when advancing to the next isomorphic transform Notably, this makes our basic unit test for replacing lines pass! Co-Authored-By: Richard <richard@zed.dev>	2024-10-21 17:35:19 +02:00
Antonio Scandurra	a5e6b222dd	WIP: Introduce a new `BlockPlacement::Replace` variant Co-Authored-By: Richard <richard@zed.dev>	2024-10-21 15:54:37 +02:00
Antonio Scandurra	23e3539f54	Checkpoint: compiles and tests pass	2024-10-21 14:24:01 +02:00
Antonio Scandurra	3303be678e	WIP: Replace `BlockDisposition` with `BlockPlacement` We still need to update users of this API and run tests.	2024-10-21 14:04:06 +02:00
				`@@ -1 +0,0 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-wand"><path d="M15 4V2"/><path d="M15 16v-2"/><path d="M8 9h2"/><path d="M20 9h2"/><path d="M17.8 11.8 19 13"/><path d="M15 9h.01"/><path d="M17.8 6.2 19 5"/><path d="m3 21 9-9"/><path d="M12.2 6.2 11 5"/></svg>`