diff --git a/crates/collab/src/db.rs b/crates/collab/src/db.rs
index 71faf16b4518a523f5929fcc771138ed3eb3fa0f..461fe06085b63a3b6b4dc6bc94b2ea0fe3fd0969 100644
--- a/crates/collab/src/db.rs
+++ b/crates/collab/src/db.rs
@@ -125,11 +125,13 @@ impl Database {
 
     pub async fn delete_stale_projects(
         &self,
-        new_epoch: ServerId,
         environment: &str,
+        new_server_id: ServerId,
     ) -> Result<()> {
         self.transaction(|tx| async move {
-            let stale_server_epochs = self.stale_server_ids(environment, new_epoch, &tx).await?;
+            let stale_server_epochs = self
+                .stale_server_ids(environment, new_server_id, &tx)
+                .await?;
             project_collaborator::Entity::delete_many()
                 .filter(
                     project_collaborator::Column::ConnectionServerId
@@ -151,8 +153,8 @@ impl Database {
 
     pub async fn stale_room_ids(
         &self,
-        new_epoch: ServerId,
         environment: &str,
+        new_server_id: ServerId,
     ) -> Result<Vec<RoomId>> {
         self.transaction(|tx| async move {
             #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
@@ -160,7 +162,9 @@ impl Database {
                 RoomId,
             }
 
-            let stale_server_epochs = self.stale_server_ids(environment, new_epoch, &tx).await?;
+            let stale_server_epochs = self
+                .stale_server_ids(environment, new_server_id, &tx)
+                .await?;
             Ok(room_participant::Entity::find()
                 .select_only()
                 .column(room_participant::Column::RoomId)
@@ -179,13 +183,13 @@ impl Database {
     pub async fn refresh_room(
         &self,
         room_id: RoomId,
-        new_epoch: ServerId,
+        new_server_id: ServerId,
     ) -> Result<RoomGuard<RefreshedRoom>> {
         self.room_transaction(|tx| async move {
             let stale_participant_filter = Condition::all()
                 .add(room_participant::Column::RoomId.eq(room_id))
                 .add(room_participant::Column::AnsweringConnectionId.is_not_null())
-                .add(room_participant::Column::AnsweringConnectionServerId.ne(new_epoch));
+                .add(room_participant::Column::AnsweringConnectionServerId.ne(new_server_id));
 
             let stale_participant_user_ids = room_participant::Entity::find()
                 .filter(stale_participant_filter.clone())
@@ -229,13 +233,17 @@ impl Database {
         .await
     }
 
-    pub async fn delete_stale_servers(&self, new_epoch: ServerId, environment: &str) -> Result<()> {
+    pub async fn delete_stale_servers(
+        &self,
+        new_server_id: ServerId,
+        environment: &str,
+    ) -> Result<()> {
         self.transaction(|tx| async move {
             server::Entity::delete_many()
                 .filter(
                     Condition::all()
                         .add(server::Column::Environment.eq(environment))
-                        .add(server::Column::Id.ne(new_epoch)),
+                        .add(server::Column::Id.ne(new_server_id)),
                 )
                 .exec(&*tx)
                 .await?;
@@ -247,14 +255,14 @@ impl Database {
     async fn stale_server_ids(
         &self,
         environment: &str,
-        new_epoch: ServerId,
+        new_server_id: ServerId,
         tx: &DatabaseTransaction,
     ) -> Result<Vec<ServerId>> {
         let stale_servers = server::Entity::find()
             .filter(
                 Condition::all()
                     .add(server::Column::Environment.eq(environment))
-                    .add(server::Column::Id.ne(new_epoch)),
+                    .add(server::Column::Id.ne(new_server_id)),
             )
             .all(&*tx)
             .await?;
@@ -1155,13 +1163,13 @@ impl Database {
                 user_id: ActiveValue::set(user_id),
                 answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
                 answering_connection_server_id: ActiveValue::set(Some(ServerId(
-                    connection.epoch as i32,
+                    connection.owner_id as i32,
                 ))),
                 answering_connection_lost: ActiveValue::set(false),
                 calling_user_id: ActiveValue::set(user_id),
                 calling_connection_id: ActiveValue::set(connection.id as i32),
                 calling_connection_server_id: ActiveValue::set(Some(ServerId(
-                    connection.epoch as i32,
+                    connection.owner_id as i32,
                 ))),
                 ..Default::default()
             }
@@ -1190,7 +1198,7 @@ impl Database {
                 calling_user_id: ActiveValue::set(calling_user_id),
                 calling_connection_id: ActiveValue::set(calling_connection.id as i32),
                 calling_connection_server_id: ActiveValue::set(Some(ServerId(
-                    calling_connection.epoch as i32,
+                    calling_connection.owner_id as i32,
                 ))),
                 initial_project_id: ActiveValue::set(initial_project_id),
                 ..Default::default()
@@ -1274,7 +1282,7 @@ impl Database {
                         )
                         .add(
                             room_participant::Column::CallingConnectionServerId
-                                .eq(calling_connection.epoch as i32),
+                                .eq(calling_connection.owner_id as i32),
                         )
                         .add(room_participant::Column::AnsweringConnectionId.is_null()),
                 )
@@ -1314,14 +1322,14 @@ impl Database {
                                 .add(room_participant::Column::AnsweringConnectionLost.eq(true))
                                 .add(
                                     room_participant::Column::AnsweringConnectionServerId
-                                        .ne(connection.epoch as i32),
+                                        .ne(connection.owner_id as i32),
                                 ),
                         ),
                 )
                 .set(room_participant::ActiveModel {
                     answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
                     answering_connection_server_id: ActiveValue::set(Some(ServerId(
-                        connection.epoch as i32,
+                        connection.owner_id as i32,
                     ))),
                     answering_connection_lost: ActiveValue::set(false),
                     ..Default::default()
@@ -1349,7 +1357,7 @@ impl Database {
                         )
                         .add(
                             room_participant::Column::AnsweringConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .one(&*tx)
@@ -1372,7 +1380,7 @@ impl Database {
                             )
                             .add(
                                 room_participant::Column::CallingConnectionServerId
-                                    .eq(connection.epoch as i32),
+                                    .eq(connection.owner_id as i32),
                             )
                             .add(room_participant::Column::AnsweringConnectionId.is_null()),
                     )
@@ -1408,7 +1416,7 @@ impl Database {
                             )
                             .add(
                                 project_collaborator::Column::ConnectionServerId
-                                    .eq(connection.epoch as i32),
+                                    .eq(connection.owner_id as i32),
                             ),
                     )
                     .into_values::<_, QueryProjectIds>()
@@ -1432,7 +1440,7 @@ impl Database {
                             });
 
                     let collaborator_connection_id = ConnectionId {
-                        epoch: collaborator.connection_server_id.0 as u32,
+                        owner_id: collaborator.connection_server_id.0 as u32,
                         id: collaborator.connection_id as u32,
                     };
                     if collaborator_connection_id != connection {
@@ -1455,7 +1463,7 @@ impl Database {
                             )
                             .add(
                                 project_collaborator::Column::ConnectionServerId
-                                    .eq(connection.epoch as i32),
+                                    .eq(connection.owner_id as i32),
                             ),
                     )
                     .exec(&*tx)
@@ -1468,7 +1476,8 @@ impl Database {
                             .add(project::Column::RoomId.eq(room_id))
                             .add(project::Column::HostConnectionId.eq(connection.id as i32))
                             .add(
-                                project::Column::HostConnectionServerId.eq(connection.epoch as i32),
+                                project::Column::HostConnectionServerId
+                                    .eq(connection.owner_id as i32),
                             ),
                     )
                     .exec(&*tx)
@@ -1536,7 +1545,7 @@ impl Database {
                         )
                         .add(
                             room_participant::Column::AnsweringConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .set(room_participant::ActiveModel {
@@ -1571,7 +1580,7 @@ impl Database {
                         )
                         .add(
                             room_participant::Column::AnsweringConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .one(&*tx)
@@ -1593,7 +1602,7 @@ impl Database {
                         .add(project_collaborator::Column::ConnectionId.eq(connection.id as i32))
                         .add(
                             project_collaborator::Column::ConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .all(&*tx)
@@ -1604,7 +1613,7 @@ impl Database {
                         .add(project_collaborator::Column::ConnectionId.eq(connection.id as i32))
                         .add(
                             project_collaborator::Column::ConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .exec(&*tx)
@@ -1621,7 +1630,7 @@ impl Database {
                         .into_iter()
                         .map(|collaborator| ConnectionId {
                             id: collaborator.connection_id as u32,
-                            epoch: collaborator.connection_server_id.0 as u32,
+                            owner_id: collaborator.connection_server_id.0 as u32,
                         })
                         .collect();
 
@@ -1630,7 +1639,7 @@ impl Database {
                         host_user_id: project.host_user_id,
                         host_connection_id: ConnectionId {
                             id: project.host_connection_id as u32,
-                            epoch: project.host_connection_server_id.0 as u32,
+                            owner_id: project.host_connection_server_id.0 as u32,
                         },
                         connection_ids,
                     });
@@ -1641,7 +1650,9 @@ impl Database {
                 .filter(
                     Condition::all()
                         .add(project::Column::HostConnectionId.eq(connection.id as i32))
-                        .add(project::Column::HostConnectionServerId.eq(connection.epoch as i32)),
+                        .add(
+                            project::Column::HostConnectionServerId.eq(connection.owner_id as i32),
+                        ),
                 )
                 .exec(&*tx)
                 .await?;
@@ -1717,7 +1728,7 @@ impl Database {
                 };
 
                 let answering_connection = ConnectionId {
-                    epoch: answering_connection_server_id.0 as u32,
+                    owner_id: answering_connection_server_id.0 as u32,
                     id: answering_connection_id as u32,
                 };
                 participants.insert(
@@ -1748,7 +1759,7 @@ impl Database {
         while let Some(row) = db_projects.next().await {
             let (db_project, db_worktree) = row?;
             let host_connection = ConnectionId {
-                epoch: db_project.host_connection_server_id.0 as u32,
+                owner_id: db_project.host_connection_server_id.0 as u32,
                 id: db_project.host_connection_id as u32,
             };
             if let Some(participant) = participants.get_mut(&host_connection) {
@@ -1818,7 +1829,7 @@ impl Database {
                         )
                         .add(
                             room_participant::Column::AnsweringConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .one(&*tx)
@@ -1832,7 +1843,7 @@ impl Database {
                 room_id: ActiveValue::set(participant.room_id),
                 host_user_id: ActiveValue::set(participant.user_id),
                 host_connection_id: ActiveValue::set(connection.id as i32),
-                host_connection_server_id: ActiveValue::set(ServerId(connection.epoch as i32)),
+                host_connection_server_id: ActiveValue::set(ServerId(connection.owner_id as i32)),
                 ..Default::default()
             }
             .insert(&*tx)
@@ -1857,7 +1868,7 @@ impl Database {
             project_collaborator::ActiveModel {
                 project_id: ActiveValue::set(project.id),
                 connection_id: ActiveValue::set(connection.id as i32),
-                connection_server_id: ActiveValue::set(ServerId(connection.epoch as i32)),
+                connection_server_id: ActiveValue::set(ServerId(connection.owner_id as i32)),
                 user_id: ActiveValue::set(participant.user_id),
                 replica_id: ActiveValue::set(ReplicaId(0)),
                 is_host: ActiveValue::set(true),
@@ -1885,7 +1896,7 @@ impl Database {
                 .await?
                 .ok_or_else(|| anyhow!("project not found"))?;
             let host_connection = ConnectionId {
-                epoch: project.host_connection_server_id.0 as u32,
+                owner_id: project.host_connection_server_id.0 as u32,
                 id: project.host_connection_id as u32,
             };
             if host_connection == connection {
@@ -1913,7 +1924,9 @@ impl Database {
                 .filter(
                     Condition::all()
                         .add(project::Column::HostConnectionId.eq(connection.id as i32))
-                        .add(project::Column::HostConnectionServerId.eq(connection.epoch as i32)),
+                        .add(
+                            project::Column::HostConnectionServerId.eq(connection.owner_id as i32),
+                        ),
                 )
                 .one(&*tx)
                 .await?
@@ -1971,7 +1984,9 @@ impl Database {
                 .filter(
                     Condition::all()
                         .add(project::Column::HostConnectionId.eq(connection.id as i32))
-                        .add(project::Column::HostConnectionServerId.eq(connection.epoch as i32)),
+                        .add(
+                            project::Column::HostConnectionServerId.eq(connection.owner_id as i32),
+                        ),
                 )
                 .one(&*tx)
                 .await?
@@ -2068,7 +2083,7 @@ impl Database {
                 .await?
                 .ok_or_else(|| anyhow!("no such project"))?;
             let host_connection = ConnectionId {
-                epoch: project.host_connection_server_id.0 as u32,
+                owner_id: project.host_connection_server_id.0 as u32,
                 id: project.host_connection_id as u32,
             };
             if host_connection != connection {
@@ -2125,7 +2140,7 @@ impl Database {
                 .await?
                 .ok_or_else(|| anyhow!("no such project"))?;
             let host_connection = ConnectionId {
-                epoch: project.host_connection_server_id.0 as u32,
+                owner_id: project.host_connection_server_id.0 as u32,
                 id: project.host_connection_id as u32,
             };
             if host_connection != connection {
@@ -2171,7 +2186,7 @@ impl Database {
                         )
                         .add(
                             room_participant::Column::AnsweringConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .one(&*tx)
@@ -2201,7 +2216,7 @@ impl Database {
             let new_collaborator = project_collaborator::ActiveModel {
                 project_id: ActiveValue::set(project_id),
                 connection_id: ActiveValue::set(connection.id as i32),
-                connection_server_id: ActiveValue::set(ServerId(connection.epoch as i32)),
+                connection_server_id: ActiveValue::set(ServerId(connection.owner_id as i32)),
                 user_id: ActiveValue::set(participant.user_id),
                 replica_id: ActiveValue::set(replica_id),
                 is_host: ActiveValue::set(false),
@@ -2313,7 +2328,7 @@ impl Database {
                         .add(project_collaborator::Column::ConnectionId.eq(connection.id as i32))
                         .add(
                             project_collaborator::Column::ConnectionServerId
-                                .eq(connection.epoch as i32),
+                                .eq(connection.owner_id as i32),
                         ),
                 )
                 .exec(&*tx)
@@ -2333,7 +2348,7 @@ impl Database {
             let connection_ids = collaborators
                 .into_iter()
                 .map(|collaborator| ConnectionId {
-                    epoch: collaborator.connection_server_id.0 as u32,
+                    owner_id: collaborator.connection_server_id.0 as u32,
                     id: collaborator.connection_id as u32,
                 })
                 .collect();
@@ -2342,7 +2357,7 @@ impl Database {
                 id: project_id,
                 host_user_id: project.host_user_id,
                 host_connection_id: ConnectionId {
-                    epoch: project.host_connection_server_id.0 as u32,
+                    owner_id: project.host_connection_server_id.0 as u32,
                     id: project.host_connection_id as u32,
                 },
                 connection_ids,
@@ -2369,7 +2384,7 @@ impl Database {
 
             if collaborators.iter().any(|collaborator| {
                 let collaborator_connection = ConnectionId {
-                    epoch: collaborator.connection_server_id.0 as u32,
+                    owner_id: collaborator.connection_server_id.0 as u32,
                     id: collaborator.connection_id as u32,
                 };
                 collaborator_connection == connection
@@ -2401,7 +2416,7 @@ impl Database {
             while let Some(participant) = participants.next().await {
                 let participant = participant?;
                 connection_ids.insert(ConnectionId {
-                    epoch: participant.connection_server_id.0 as u32,
+                    owner_id: participant.connection_server_id.0 as u32,
                     id: participant.connection_id as u32,
                 });
             }
@@ -2433,7 +2448,7 @@ impl Database {
         while let Some(participant) = participants.next().await {
             let participant = participant?;
             guest_connection_ids.push(ConnectionId {
-                epoch: participant.connection_server_id.0 as u32,
+                owner_id: participant.connection_server_id.0 as u32,
                 id: participant.connection_id as u32,
             });
         }
diff --git a/crates/collab/src/db/tests.rs b/crates/collab/src/db/tests.rs
index c229f0a6172b68c361e31c47080b1503db40a519..9d42c11f8bba88bd164eaab443857d910b97230d 100644
--- a/crates/collab/src/db/tests.rs
+++ b/crates/collab/src/db/tests.rs
@@ -410,7 +410,7 @@ test_both_dbs!(
     test_project_count_sqlite,
     db,
     {
-        let epoch = db.create_server("test").await.unwrap().0 as u32;
+        let owner_id = db.create_server("test").await.unwrap().0 as u32;
 
         let user1 = db
             .create_user(
@@ -438,7 +438,7 @@ test_both_dbs!(
             .unwrap();
 
         let room_id = RoomId::from_proto(
-            db.create_room(user1.user_id, ConnectionId { epoch, id: 0 }, "")
+            db.create_room(user1.user_id, ConnectionId { owner_id, id: 0 }, "")
                 .await
                 .unwrap()
                 .id,
@@ -446,34 +446,36 @@ test_both_dbs!(
         db.call(
             room_id,
             user1.user_id,
-            ConnectionId { epoch, id: 0 },
+            ConnectionId { owner_id, id: 0 },
             user2.user_id,
             None,
         )
         .await
         .unwrap();
-        db.join_room(room_id, user2.user_id, ConnectionId { epoch, id: 1 })
+        db.join_room(room_id, user2.user_id, ConnectionId { owner_id, id: 1 })
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);
 
-        db.share_project(room_id, ConnectionId { epoch, id: 1 }, &[])
+        db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 1);
 
-        db.share_project(room_id, ConnectionId { epoch, id: 1 }, &[])
+        db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
             .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 { epoch, id: 0 }, &[])
+        db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[])
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
 
-        db.leave_room(ConnectionId { epoch, id: 1 }).await.unwrap();
+        db.leave_room(ConnectionId { owner_id, id: 1 })
+            .await
+            .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);
     }
 );
diff --git a/crates/collab/src/integration_tests.rs b/crates/collab/src/integration_tests.rs
index dd18d5aef20f82bd070b6165c2cabf892c477d57..e52b7f6a1de78a1024e4c0d61216353fb81904cb 100644
--- a/crates/collab/src/integration_tests.rs
+++ b/crates/collab/src/integration_tests.rs
@@ -6123,9 +6123,17 @@ async fn test_random_collaboration(
             30..=34 => {
                 log::info!("Simulating server restart");
                 server.reset().await;
-                deterministic.advance_clock(RECEIVE_TIMEOUT + RECONNECT_TIMEOUT);
+                deterministic.advance_clock(RECEIVE_TIMEOUT);
                 server.start().await.unwrap();
                 deterministic.advance_clock(CLEANUP_TIMEOUT);
+                let environment = &server.app_state.config.zed_environment;
+                let stale_room_ids = server
+                    .app_state
+                    .db
+                    .stale_room_ids(environment, server.id())
+                    .await
+                    .unwrap();
+                assert_eq!(stale_room_ids, vec![]);
             }
             _ if !op_start_signals.is_empty() => {
                 while operations < max_operations && rng.lock().gen_bool(0.7) {
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 9ed50e802c4ebe5388be5c05ad86afaf136c17c9..d83aa65a6b76a2de1e5b5e0f4592214e6452f3f2 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -138,7 +138,7 @@ impl Deref for DbHandle {
 }
 
 pub struct Server {
-    epoch: parking_lot::Mutex<ServerId>,
+    id: parking_lot::Mutex<ServerId>,
     peer: Arc<Peer>,
     pub(crate) connection_pool: Arc<parking_lot::Mutex<ConnectionPool>>,
     app_state: Arc<AppState>,
@@ -169,10 +169,10 @@ where
 }
 
 impl Server {
-    pub fn new(epoch: ServerId, app_state: Arc<AppState>, executor: Executor) -> Arc<Self> {
+    pub fn new(id: ServerId, app_state: Arc<AppState>, executor: Executor) -> Arc<Self> {
         let mut server = Self {
-            epoch: parking_lot::Mutex::new(epoch),
-            peer: Peer::new(epoch.0 as u32),
+            id: parking_lot::Mutex::new(id),
+            peer: Peer::new(id.0 as u32),
             app_state,
             executor,
             connection_pool: Default::default(),
@@ -241,7 +241,7 @@ impl Server {
     }
 
     pub async fn start(&self) -> Result<()> {
-        let epoch = *self.epoch.lock();
+        let server_id = *self.id.lock();
         let app_state = self.app_state.clone();
         let peer = self.peer.clone();
         let timeout = self.executor.sleep(CLEANUP_TIMEOUT);
@@ -254,7 +254,7 @@ impl Server {
         tracing::info!("begin deleting stale projects");
         app_state
             .db
-            .delete_stale_projects(epoch, &app_state.config.zed_environment)
+            .delete_stale_projects(&app_state.config.zed_environment, server_id)
             .await?;
         tracing::info!("finish deleting stale projects");
 
@@ -266,7 +266,7 @@ impl Server {
                 tracing::info!("cleanup timeout expired, retrieving stale rooms");
                 if let Some(room_ids) = app_state
                     .db
-                    .stale_room_ids(epoch, &app_state.config.zed_environment)
+                    .stale_room_ids(&app_state.config.zed_environment, server_id)
                     .await
                     .trace_err()
                 {
@@ -278,7 +278,7 @@ impl Server {
                         let mut delete_live_kit_room = false;
 
                         if let Ok(mut refreshed_room) =
-                            app_state.db.refresh_room(room_id, epoch).await
+                            app_state.db.refresh_room(room_id, server_id).await
                         {
                             tracing::info!(
                                 room_id = room_id.0,
@@ -354,7 +354,7 @@ impl Server {
 
                 app_state
                     .db
-                    .delete_stale_servers(epoch, &app_state.config.zed_environment)
+                    .delete_stale_servers(server_id, &app_state.config.zed_environment)
                     .await
                     .trace_err();
             }
@@ -370,10 +370,15 @@ impl Server {
     }
 
     #[cfg(test)]
-    pub fn reset(&self, epoch: ServerId) {
+    pub fn reset(&self, id: ServerId) {
         self.teardown();
-        *self.epoch.lock() = epoch;
-        self.peer.reset(epoch.0 as u32);
+        *self.id.lock() = id;
+        self.peer.reset(id.0 as u32);
+    }
+
+    #[cfg(test)]
+    pub fn id(&self) -> ServerId {
+        *self.id.lock()
     }
 
     fn add_handler<F, Fut, M>(&mut self, handler: F) -> &mut Self
@@ -1156,7 +1161,7 @@ async fn join_project(
         .iter()
         .map(|collaborator| {
             let peer_id = proto::PeerId {
-                epoch: collaborator.connection_server_id.0 as u32,
+                owner_id: collaborator.connection_server_id.0 as u32,
                 id: collaborator.connection_id as u32,
             };
             proto::Collaborator {
@@ -1412,7 +1417,7 @@ where
             .find(|collaborator| collaborator.is_host)
             .ok_or_else(|| anyhow!("host not found"))?;
         ConnectionId {
-            epoch: host.connection_server_id.0 as u32,
+            owner_id: host.connection_server_id.0 as u32,
             id: host.connection_id as u32,
         }
     };
@@ -1443,7 +1448,7 @@ async fn save_buffer(
             .find(|collaborator| collaborator.is_host)
             .ok_or_else(|| anyhow!("host not found"))?;
         ConnectionId {
-            epoch: host.connection_server_id.0 as u32,
+            owner_id: host.connection_server_id.0 as u32,
             id: host.connection_id as u32,
         }
     };
@@ -1459,13 +1464,13 @@ async fn save_buffer(
         .await?;
     collaborators.retain(|collaborator| {
         let collaborator_connection = ConnectionId {
-            epoch: collaborator.connection_server_id.0 as u32,
+            owner_id: collaborator.connection_server_id.0 as u32,
             id: collaborator.connection_id as u32,
         };
         collaborator_connection != session.connection_id
     });
     let project_connection_ids = collaborators.iter().map(|collaborator| ConnectionId {
-        epoch: collaborator.connection_server_id.0 as u32,
+        owner_id: collaborator.connection_server_id.0 as u32,
         id: collaborator.connection_id as u32,
     });
     broadcast(host_connection_id, project_connection_ids, |conn_id| {
diff --git a/crates/rpc/proto/zed.proto b/crates/rpc/proto/zed.proto
index 064bf6f50a4cd96dc40389c842fabce91497abb3..a91b191d57fe7a8c07648e9af7cd35a178326dcf 100644
--- a/crates/rpc/proto/zed.proto
+++ b/crates/rpc/proto/zed.proto
@@ -2,7 +2,7 @@ syntax = "proto3";
 package zed.messages;
 
 message PeerId {
-    uint32 epoch = 1;
+    uint32 owner_id = 1;
     uint32 id = 2;
 }
 
diff --git a/crates/rpc/src/macros.rs b/crates/rpc/src/macros.rs
index ebed976968e14590a472efffb3caf9d2eb25ed44..89e605540da1157f5530ad7236b23358dc127c1a 100644
--- a/crates/rpc/src/macros.rs
+++ b/crates/rpc/src/macros.rs
@@ -7,7 +7,7 @@ macro_rules! messages {
                     Some(Box::new(TypedEnvelope {
                         sender_id,
                         original_sender_id: envelope.original_sender_id.map(|original_sender| PeerId {
-                            epoch: original_sender.epoch,
+                            owner_id: original_sender.owner_id,
                             id: original_sender.id
                         }),
                         message_id: envelope.id,
diff --git a/crates/rpc/src/peer.rs b/crates/rpc/src/peer.rs
index fc6712e04fe5544c07141ce0dc3cff17a675eca4..59a30a0f4747107fb55a0ec3be456c9e6640958b 100644
--- a/crates/rpc/src/peer.rs
+++ b/crates/rpc/src/peer.rs
@@ -25,14 +25,14 @@ use tracing::instrument;
 
 #[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
 pub struct ConnectionId {
-    pub epoch: u32,
+    pub owner_id: u32,
     pub id: u32,
 }
 
 impl Into<PeerId> for ConnectionId {
     fn into(self) -> PeerId {
         PeerId {
-            epoch: self.epoch,
+            owner_id: self.owner_id,
             id: self.id,
         }
     }
@@ -41,7 +41,7 @@ impl Into<PeerId> for ConnectionId {
 impl From<PeerId> for ConnectionId {
     fn from(peer_id: PeerId) -> Self {
         Self {
-            epoch: peer_id.epoch,
+            owner_id: peer_id.owner_id,
             id: peer_id.id,
         }
     }
@@ -49,7 +49,7 @@ impl From<PeerId> for ConnectionId {
 
 impl fmt::Display for ConnectionId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}/{}", self.epoch, self.id)
+        write!(f, "{}/{}", self.owner_id, self.id)
     }
 }
 
@@ -157,7 +157,7 @@ impl Peer {
         let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded();
 
         let connection_id = ConnectionId {
-            epoch: self.epoch.load(SeqCst),
+            owner_id: self.epoch.load(SeqCst),
             id: self.next_connection_id.fetch_add(1, SeqCst),
         };
         let connection_state = ConnectionState {
diff --git a/crates/rpc/src/proto.rs b/crates/rpc/src/proto.rs
index 77d82ec3081514e5ab406ad68ac0e2940949e376..07c15e0f16d4a6fb8744d4fd431d351414f2582b 100644
--- a/crates/rpc/src/proto.rs
+++ b/crates/rpc/src/proto.rs
@@ -78,13 +78,13 @@ impl<T: EnvelopedMessage> AnyTypedEnvelope for TypedEnvelope<T> {
 
 impl PeerId {
     pub fn from_u64(peer_id: u64) -> Self {
-        let epoch = (peer_id >> 32) as u32;
+        let owner_id = (peer_id >> 32) as u32;
         let id = peer_id as u32;
-        Self { epoch, id }
+        Self { owner_id, id }
     }
 
     pub fn as_u64(self) -> u64 {
-        ((self.epoch as u64) << 32) | (self.id as u64)
+        ((self.owner_id as u64) << 32) | (self.id as u64)
     }
 }
 
@@ -94,8 +94,8 @@ impl Eq for PeerId {}
 
 impl Ord for PeerId {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.epoch
-            .cmp(&other.epoch)
+        self.owner_id
+            .cmp(&other.owner_id)
             .then_with(|| self.id.cmp(&other.id))
     }
 }
@@ -108,14 +108,14 @@ impl PartialOrd for PeerId {
 
 impl std::hash::Hash for PeerId {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.epoch.hash(state);
+        self.owner_id.hash(state);
         self.id.hash(state);
     }
 }
 
 impl fmt::Display for PeerId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}/{}", self.epoch, self.id)
+        write!(f, "{}/{}", self.owner_id, self.id)
     }
 }
 
@@ -124,7 +124,7 @@ impl FromStr for PeerId {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut components = s.split('/');
-        let epoch = components
+        let owner_id = components
             .next()
             .ok_or_else(|| anyhow!("invalid peer id {:?}", s))?
             .parse()?;
@@ -132,7 +132,7 @@ impl FromStr for PeerId {
             .next()
             .ok_or_else(|| anyhow!("invalid peer id {:?}", s))?
             .parse()?;
-        Ok(PeerId { epoch, id })
+        Ok(PeerId { owner_id, id })
     }
 }
 
@@ -542,20 +542,23 @@ mod tests {
 
     #[gpui::test]
     fn test_converting_peer_id_from_and_to_u64() {
-        let peer_id = PeerId { epoch: 10, id: 3 };
+        let peer_id = PeerId {
+            owner_id: 10,
+            id: 3,
+        };
         assert_eq!(PeerId::from_u64(peer_id.as_u64()), peer_id);
         let peer_id = PeerId {
-            epoch: u32::MAX,
+            owner_id: u32::MAX,
             id: 3,
         };
         assert_eq!(PeerId::from_u64(peer_id.as_u64()), peer_id);
         let peer_id = PeerId {
-            epoch: 10,
+            owner_id: 10,
             id: u32::MAX,
         };
         assert_eq!(PeerId::from_u64(peer_id.as_u64()), peer_id);
         let peer_id = PeerId {
-            epoch: u32::MAX,
+            owner_id: u32::MAX,
             id: u32::MAX,
         };
         assert_eq!(PeerId::from_u64(peer_id.as_u64()), peer_id);