diff --git a/sway-lsp/benches/lsp_benchmarks/compile.rs b/sway-lsp/benches/lsp_benchmarks/compile.rs
index 743fcbc592c..ae5d0ed787b 100644
--- a/sway-lsp/benches/lsp_benchmarks/compile.rs
+++ b/sway-lsp/benches/lsp_benchmarks/compile.rs
@@ -14,7 +14,7 @@ fn benchmarks(c: &mut Criterion) {
         .unwrap()
         .block_on(async { black_box(super::compile_test_project().await) });
 
-    let sync = state.sync_workspace.get().unwrap();
+    let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
     let build_plan = session
         .build_plan_cache
         .get_or_update(&sync.workspace_manifest_path(), || {
diff --git a/sway-lsp/benches/lsp_benchmarks/mod.rs b/sway-lsp/benches/lsp_benchmarks/mod.rs
index 0c527618263..550172eb570 100644
--- a/sway-lsp/benches/lsp_benchmarks/mod.rs
+++ b/sway-lsp/benches/lsp_benchmarks/mod.rs
@@ -17,7 +17,7 @@ pub async fn compile_test_project() -> (Url, Arc<Session>, ServerState, Engines)
     let state = ServerState::default();
     let engines_clone = state.engines.read().clone();
     let session = Arc::new(Session::new());
-    let sync = state.get_or_init_global_sync_workspace(&uri).await.unwrap();
+    let sync = state.get_or_init_sync_workspace(&uri).await.unwrap();
     let temp_uri = sync.workspace_to_temp_url(&uri).unwrap();
 
     state.documents.handle_open_file(&temp_uri).await;
diff --git a/sway-lsp/benches/lsp_benchmarks/requests.rs b/sway-lsp/benches/lsp_benchmarks/requests.rs
index 825a481a93d..783339729c9 100644
--- a/sway-lsp/benches/lsp_benchmarks/requests.rs
+++ b/sway-lsp/benches/lsp_benchmarks/requests.rs
@@ -10,7 +10,7 @@ fn benchmarks(c: &mut Criterion) {
     let (uri, session, state, engines) = Runtime::new()
         .unwrap()
         .block_on(async { black_box(super::compile_test_project().await) });
-    let sync = state.sync_workspace.get().unwrap();
+    let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
     let config = sway_lsp::config::Config::default();
     let position = Position::new(1717, 24);
     let range = Range::new(Position::new(1628, 0), Position::new(1728, 0));
@@ -55,12 +55,12 @@ fn benchmarks(c: &mut Criterion) {
     });
 
     c.bench_function("find_all_references", |b| {
-        b.iter(|| session.token_references(&uri, position, &state.token_map, &engines, sync))
+        b.iter(|| session.token_references(&uri, position, &state.token_map, &engines, &sync))
     });
 
     c.bench_function("goto_definition", |b| {
         b.iter(|| {
-            session.token_definition_response(&uri, position, &engines, &state.token_map, sync)
+            session.token_definition_response(&uri, position, &engines, &state.token_map, &sync)
         })
     });
 
@@ -78,7 +78,7 @@ fn benchmarks(c: &mut Criterion) {
 
     c.bench_function("prepare_rename", |b| {
         b.iter(|| {
-            capabilities::rename::prepare_rename(&engines, &state.token_map, &uri, position, sync)
+            capabilities::rename::prepare_rename(&engines, &state.token_map, &uri, position, &sync)
         })
     });
 
@@ -90,7 +90,7 @@ fn benchmarks(c: &mut Criterion) {
                 "new_token_name".to_string(),
                 &uri,
                 position,
-                sync,
+                &sync,
             )
         })
     });
diff --git a/sway-lsp/benches/lsp_benchmarks/token_map.rs b/sway-lsp/benches/lsp_benchmarks/token_map.rs
index 7eb7fa00591..e1e823e646d 100644
--- a/sway-lsp/benches/lsp_benchmarks/token_map.rs
+++ b/sway-lsp/benches/lsp_benchmarks/token_map.rs
@@ -6,7 +6,7 @@ fn benchmarks(c: &mut Criterion) {
     let (uri, _, state, engines) = Runtime::new()
         .unwrap()
         .block_on(async { black_box(super::compile_test_project().await) });
-    let sync = state.sync_workspace.get().unwrap();
+    let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
     let position = Position::new(1716, 24);
     let path = uri.to_file_path().unwrap();
     let program_id = sway_lsp::core::session::program_id_from_path(&path, &engines).unwrap();
diff --git a/sway-lsp/src/capabilities/hover/mod.rs b/sway-lsp/src/capabilities/hover/mod.rs
index 460e5a10d4a..5a52b7d920f 100644
--- a/sway-lsp/src/capabilities/hover/mod.rs
+++ b/sway-lsp/src/capabilities/hover/mod.rs
@@ -52,6 +52,7 @@ pub fn hover_data(
     }
 
     let client_config = state.config.read().client.clone();
+    let sync = state.get_sync_workspace_for_uri(url).unwrap();
     let contents = match &token.declared_token_ident(engines) {
         Some(decl_ident) => {
             let t = state.token_map.try_get(decl_ident).try_unwrap()?;
@@ -62,7 +63,7 @@ pub fn hover_data(
                 decl_token,
                 &decl_ident.name,
                 client_config,
-                state.sync_workspace(),
+                &sync,
             )
         }
         // The `TypeInfo` of the token does not contain an `Ident`. In this case,
@@ -73,7 +74,7 @@ pub fn hover_data(
             token,
             &ident.name,
             client_config,
-            state.sync_workspace(),
+            &sync,
         ),
     };
 
diff --git a/sway-lsp/src/handlers/notification.rs b/sway-lsp/src/handlers/notification.rs
index 8eb1fa01a38..793e578389d 100644
--- a/sway-lsp/src/handlers/notification.rs
+++ b/sway-lsp/src/handlers/notification.rs
@@ -2,7 +2,7 @@
 //! Protocol. This module specifically handles notification messages sent by the Client.
 
 use crate::{
-    core::{document::Documents, session::Session},
+    core::{document::Documents, session::Session, sync::SyncWorkspace},
     error::LanguageServerError,
     server_state::{CompilationContext, ServerState, TaskMessage},
 };
@@ -21,14 +21,14 @@ pub async fn handle_did_open_text_document(
     params: DidOpenTextDocumentParams,
 ) -> Result<(), LanguageServerError> {
     let file_uri = &params.text_document.uri;
-    // Initialize the SyncWorkspace if it doesn't exist.
-    let _ = state.get_or_init_global_sync_workspace(file_uri).await?;
+    // Initialize the SyncWorkspace for this file if it doesn't exist.
+    let sync_workspace = state.get_or_init_sync_workspace(file_uri).await?;
 
     // Get or create a session for the original file URI.
     let (uri, session) = state.uri_and_session_from_workspace(&params.text_document.uri)?;
     state.documents.handle_open_file(&uri).await;
 
-    send_new_compilation_request(state, session.clone(), &uri, None, false);
+    send_new_compilation_request(state, session.clone(), &uri, None, false, sync_workspace);
     state.is_compiling.store(true, Ordering::SeqCst);
     state.wait_for_parsing().await;
     state
@@ -44,6 +44,7 @@ fn send_new_compilation_request(
     uri: &Url,
     version: Option<i32>,
     optimized_build: bool,
+    sync_workspace: Arc<SyncWorkspace>,
 ) {
     let file_versions = file_versions(&state.documents, uri, version.map(|v| v as u64));
 
@@ -72,7 +73,7 @@ fn send_new_compilation_request(
             optimized_build,
             gc_options: state.config.read().garbage_collection.clone(),
             file_versions,
-            sync: Some(state.sync_workspace.get().unwrap().clone()),
+            sync: Some(sync_workspace),
         }));
 }
 
@@ -88,6 +89,7 @@ pub async fn handle_did_change_text_document(
     }
 
     let (uri, session) = state.uri_and_session_from_workspace(&params.text_document.uri)?;
+    let sync_workspace = state.get_sync_workspace_for_uri(&params.text_document.uri)?;
     state
         .documents
         .write_changes_to_file(&uri, &params.content_changes)
@@ -100,6 +102,7 @@ pub async fn handle_did_change_text_document(
         Some(params.text_document.version),
         // TODO: Set this back to true once https://github.com/FuelLabs/sway/issues/6576 is fixed.
         false,
+        sync_workspace,
     );
     Ok(())
 }
@@ -129,7 +132,8 @@ pub(crate) async fn handle_did_save_text_document(
         .pid_locked_files
         .remove_dirty_flag(&params.text_document.uri)?;
     let (uri, session) = state.uri_and_session_from_workspace(&params.text_document.uri)?;
-    send_new_compilation_request(state, session.clone(), &uri, None, false);
+    let sync_workspace = state.get_sync_workspace_for_uri(&params.text_document.uri)?;
+    send_new_compilation_request(state, session.clone(), &uri, None, false, sync_workspace);
     state.wait_for_parsing().await;
     state
         .publish_diagnostics(uri, params.text_document.uri, session)
@@ -147,7 +151,8 @@ pub(crate) fn handle_did_change_watched_files(
         match event.typ {
             FileChangeType::CHANGED => {
                 if event.uri.to_string().contains("Forc.toml") {
-                    state.sync_workspace.get().unwrap().sync_manifest()?;
+                    let sync_workspace = state.get_sync_workspace_for_uri(&event.uri)?;
+                    sync_workspace.sync_manifest()?;
                     // TODO: Recompile the project | see https://github.com/FuelLabs/sway/issues/7103
                 }
             }
diff --git a/sway-lsp/src/handlers/request.rs b/sway-lsp/src/handlers/request.rs
index 8284563abfd..0e9a4235ec1 100644
--- a/sway-lsp/src/handlers/request.rs
+++ b/sway-lsp/src/handlers/request.rs
@@ -80,14 +80,14 @@ pub fn handle_goto_definition(
         .uri_and_session_from_workspace(&params.text_document_position_params.text_document.uri)
     {
         Ok((uri, session)) => {
-            let sync = state.sync_workspace();
+            let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
             let position = params.text_document_position_params.position;
             Ok(session.token_definition_response(
                 &uri,
                 position,
                 &state.engines.read(),
                 &state.token_map,
-                sync,
+                &sync,
             ))
         }
         Err(err) => {
@@ -154,13 +154,13 @@ pub fn handle_prepare_rename(
 ) -> Result<Option<PrepareRenameResponse>> {
     match state.uri_from_workspace(&params.text_document.uri) {
         Ok(uri) => {
-            let sync = state.sync_workspace();
+            let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
             match capabilities::rename::prepare_rename(
                 &state.engines.read(),
                 &state.token_map,
                 &uri,
                 params.position,
-                sync,
+                &sync,
             ) {
                 Ok(res) => Ok(Some(res)),
                 Err(err) => {
@@ -181,14 +181,14 @@ pub fn handle_rename(state: &ServerState, params: RenameParams) -> Result<Option
         Ok(uri) => {
             let new_name = params.new_name;
             let position = params.text_document_position.position;
-            let sync = state.sync_workspace();
+            let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
             match capabilities::rename::rename(
                 &state.engines.read(),
                 &state.token_map,
                 new_name,
                 &uri,
                 position,
-                sync,
+                &sync,
             ) {
                 Ok(res) => Ok(Some(res)),
                 Err(err) => {
@@ -237,13 +237,13 @@ pub async fn handle_references(
     match state.uri_and_session_from_workspace(&params.text_document_position.text_document.uri) {
         Ok((uri, session)) => {
             let position = params.text_document_position.position;
-            let sync = state.sync_workspace();
+            let sync = state.get_sync_workspace_for_uri(&uri).unwrap();
             Ok(session.token_references(
                 &uri,
                 position,
                 &state.token_map,
                 &state.engines.read(),
-                sync,
+                &sync,
             ))
         }
         Err(err) => {
diff --git a/sway-lsp/src/server.rs b/sway-lsp/src/server.rs
index 3a1d6e6807f..8127777cacc 100644
--- a/sway-lsp/src/server.rs
+++ b/sway-lsp/src/server.rs
@@ -31,14 +31,14 @@ impl LanguageServer for ServerState {
         if let Err(err) = self.register_forc_toml_watcher().await {
             tracing::error!("Failed to register Forc.toml file watcher: {}", err);
         }
-        // Populate documents from temp dir
-        if let Some(sw) = self.sync_workspace.get() {
-            if let Ok(temp_dir) = sw.temp_dir() {
-                if let Err(err) = self.documents.store_sway_files_from_temp(temp_dir).await {
-                    tracing::warn!("Failed to populate documents from temp dir: {}", err);
-                }
-            }
-        }
+        // // Populate documents from temp dir
+        // if let Some(sw) = self.sync_workspace.get() {
+        //     if let Ok(temp_dir) = sw.temp_dir() {
+        //         if let Err(err) = self.documents.store_sway_files_from_temp(temp_dir).await {
+        //             tracing::warn!("Failed to populate documents from temp dir: {}", err);
+        //         }
+        //     }
+        // }
         tracing::info!("Sway Language Server Initialized");
     }
 
diff --git a/sway-lsp/src/server_state.rs b/sway-lsp/src/server_state.rs
index 68eda419385..a06b462debb 100644
--- a/sway-lsp/src/server_state.rs
+++ b/sway-lsp/src/server_state.rs
@@ -29,7 +29,7 @@ use std::{
     path::PathBuf,
     sync::{
         atomic::{AtomicBool, Ordering},
-        Arc, OnceLock,
+        Arc,
     },
 };
 use sway_core::Engines;
@@ -42,7 +42,7 @@ const DEFAULT_SESSION_CACHE_CAPACITY: usize = 4;
 pub struct ServerState {
     pub(crate) client: Option<Client>,
     pub config: Arc<RwLock<Config>>,
-    pub sync_workspace: OnceLock<Arc<SyncWorkspace>>,
+    pub sync_workspaces: DashMap<PathBuf, Arc<SyncWorkspace>>,
     pub token_map: Arc<TokenMap>,
     pub engines: Arc<RwLock<Engines>>,
     pub(crate) keyword_docs: Arc<KeywordDocs>,
@@ -70,7 +70,7 @@ impl Default for ServerState {
             token_map: Arc::new(TokenMap::new()),
             engines: Arc::new(RwLock::new(Engines::default())),
             config: Arc::new(RwLock::new(Config::default())),
-            sync_workspace: OnceLock::new(),
+            sync_workspaces: DashMap::new(),
             keyword_docs: Arc::new(KeywordDocs::new()),
             sessions: LruSessionCache::new(DEFAULT_SESSION_CACHE_CAPACITY),
             documents: Documents::new(),
@@ -317,9 +317,9 @@ impl ServerState {
             .send(TaskMessage::Terminate)
             .expect("failed to send terminate message");
 
-        // Delete the temporary directory.
-        if let Some(sw) = self.sync_workspace.get() {
-            sw.remove_temp_dir();
+        // Delete all temporary directories.
+        for entry in self.sync_workspaces.iter() {
+            entry.value().remove_temp_dir();
         }
 
         Ok(())
@@ -386,10 +386,7 @@ impl ServerState {
     /// Constructs and returns a [Url] from a given workspace URI.
     /// The returned URL represents the temp directory workspace.
     pub fn uri_from_workspace(&self, workspace_uri: &Url) -> Result<Url, LanguageServerError> {
-        let sw = self
-            .sync_workspace
-            .get()
-            .ok_or(LanguageServerError::GlobalWorkspaceNotInitialized)?; // Should be initialized by now.
+        let sw = self.get_sync_workspace_for_uri(workspace_uri)?;
 
         // Convert the workspace URI to its corresponding temporary URI.
         let temp_uri = sw.workspace_to_temp_url(workspace_uri)?;
@@ -432,39 +429,9 @@ impl ServerState {
         Ok(session)
     }
 
-    /// Gets the existing SyncWorkspace or initializes it if it doesn't exist.
-    /// This is specific to a single SyncWorkspace managed by an OnceLock.
-    pub async fn get_or_init_global_sync_workspace(
-        &self,
-        uri: &Url,
-    ) -> Result<Arc<SyncWorkspace>, LanguageServerError> {
-        if let Some(sw_arc) = self.sync_workspace.get() {
-            Ok(sw_arc.clone())
-        } else {
-            match self.initialize_workspace_sync(uri).await {
-                Ok(initialized_sw) => {
-                    if self.sync_workspace.set(initialized_sw).is_ok() {
-                        tracing::info!("SyncWorkspace successfully initialized and set.");
-                    } else {
-                        tracing::debug!(
-                            "SyncWorkspace was set by another concurrent operation after check."
-                        );
-                    }
-                    Ok(self.sync_workspace.get().unwrap().clone())
-                }
-                Err(e) => {
-                    tracing::error!("Failed to initialize global SyncWorkspace: {:?}. LSP functions requiring it may fail.", e);
-                    Err(e)
-                }
-            }
-        }
-    }
-
-    pub async fn initialize_workspace_sync(
-        &self,
-        file_uri_triggering_init: &Url,
-    ) -> Result<Arc<SyncWorkspace>, LanguageServerError> {
-        let path = PathBuf::from(file_uri_triggering_init.path());
+    /// Determines the workspace root for the given file URI.
+    fn find_workspace_root_for_uri(&self, file_uri: &Url) -> Result<PathBuf, LanguageServerError> {
+        let path = PathBuf::from(file_uri.path());
         let search_dir = path.parent().unwrap_or(&path);
 
         // Find the initial manifest (could be package or workspace)
@@ -513,8 +480,67 @@ impl ServerState {
             }
         };
 
+        Ok(actual_sync_root)
+    }
+
+    /// Gets the SyncWorkspace for the given URI.
+    pub fn get_sync_workspace_for_uri(
+        &self,
+        uri: &Url,
+    ) -> Result<Arc<SyncWorkspace>, LanguageServerError> {
+        let workspace_root = self.find_workspace_root_for_uri(uri)?;
+        self.sync_workspaces
+            .get(&workspace_root)
+            .map(|entry| entry.value().clone())
+            .ok_or(LanguageServerError::GlobalWorkspaceNotInitialized)
+    }
+
+    /// Gets the existing SyncWorkspace for a file URI or initializes it if it doesn't exist.
+    pub async fn get_or_init_sync_workspace(
+        &self,
+        uri: &Url,
+    ) -> Result<Arc<SyncWorkspace>, LanguageServerError> {
+        // First try to find the workspace root for this URI
+        let workspace_root = self.find_workspace_root_for_uri(uri)?;
+
+        // Check if we already have a SyncWorkspace for this root
+        if let Some(sw_arc) = self.sync_workspaces.get(&workspace_root) {
+            Ok(sw_arc.value().clone())
+        } else {
+            // Initialize a new workspace sync for this root
+            match self.initialize_workspace_sync(uri).await {
+                Ok(initialized_sw) => {
+                    let canonical_root = workspace_root
+                        .canonicalize()
+                        .unwrap_or(workspace_root.clone());
+                    self.sync_workspaces
+                        .insert(canonical_root.clone(), initialized_sw.clone());
+                    tracing::info!(
+                        "SyncWorkspace successfully initialized for {:?}",
+                        canonical_root
+                    );
+                    Ok(initialized_sw)
+                }
+                Err(e) => {
+                    tracing::error!(
+                        "Failed to initialize SyncWorkspace for {:?}: {:?}",
+                        workspace_root,
+                        e
+                    );
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    pub async fn initialize_workspace_sync(
+        &self,
+        file_uri_triggering_init: &Url,
+    ) -> Result<Arc<SyncWorkspace>, LanguageServerError> {
+        let actual_sync_root = self.find_workspace_root_for_uri(file_uri_triggering_init)?;
+
         tracing::debug!(
-            "Determined actual root for SyncWorkspace: {:?}",
+            "Initializing SyncWorkspace for root: {:?}",
             actual_sync_root
         );
 
@@ -531,18 +557,32 @@ impl ServerState {
         Ok(sw)
     }
 
-    /// Returns a cloned `Arc` of the `SyncWorkspace`.
-    ///
-    /// Panics if `sync_workspace` has not been initialized by a prior call to
-    /// `get_or_init_global_sync_workspace`. This scenario is not expected in normal operation.
-    pub fn sync_workspace(&self) -> &SyncWorkspace {
-        // `sync_workspace` is initialized once during the first call to `get_or_init_global_sync_workspace`.
-        // After initialization, it's always expected to be `Some`.
-        // Using `expect` here simplifies the code, as the `None` case should not occur in normal operation.
-        self.sync_workspace
-            .get()
-            .expect("SyncWorkspace not initialized")
+    /// Checks if a workspace is already initialized for the given URI
+    pub fn is_workspace_initialized(&self, uri: &Url) -> bool {
+        if let Ok(workspace_root) = self.find_workspace_root_for_uri(uri) {
+            self.sync_workspaces.contains_key(&workspace_root)
+        } else {
+            false
+        }
     }
+
+    // /// Returns a reference to the `SyncWorkspace` for backward compatibility.
+    // /// This will panic if called with a URI that doesn't have an initialized workspace.
+    // ///
+    // /// @deprecated Use `get_sync_workspace_for_uri` instead for proper error handling.
+    // pub fn sync_workspace(&self) -> &SyncWorkspace {
+    //     // This is a temporary compatibility method.
+    //     // In the old implementation, this would panic if called before initialization.
+    //     // We maintain that behavior here but log a warning.
+    //     tracing::warn!("sync_workspace() called without URI context - this is deprecated");
+
+    //     // Return the first workspace if any exists, otherwise panic
+    //     self.sync_workspaces
+    //         .iter()
+    //         .next()
+    //         .map(|entry| entry.value().as_ref())
+    //         .expect("SyncWorkspace not initialized")
+    // }
 }
 
 /// A Least Recently Used (LRU) cache for storing and managing `Session` objects.
diff --git a/sway-lsp/tests/lib.rs b/sway-lsp/tests/lib.rs
index 375b597caec..2fcbdd79296 100644
--- a/sway-lsp/tests/lib.rs
+++ b/sway-lsp/tests/lib.rs
@@ -166,7 +166,8 @@ fn did_open_all_std_lib_files() {
 
             // If the workspace is not initialized, we need to initialize it
             // Otherwise, we can just open the file
-            let uri = if service.inner().sync_workspace.get().is_none() {
+            let file_url = Url::from_file_path(&file).unwrap();
+            let uri = if !service.inner().is_workspace_initialized(&file_url) {
                 init_and_open(&mut service, file.to_path_buf()).await
             } else {
                 open(service.inner(), file.to_path_buf()).await
@@ -180,27 +181,22 @@ fn did_open_all_std_lib_files() {
     });
 }
 
-// Opens all members in the examples workspace and assert that we are able to return semantic tokens for each workspace member.
-// This test is expected to run for a while although should be much faster once https://github.com/FuelLabs/sway/pull/7139 is merged.
+// Opens all members in the workspaces and assert that we are able to return semantic tokens for each workspace member.
 #[test]
 fn did_open_all_members_in_examples() {
     run_async!({
         let (mut service, _) = LspService::new(ServerState::new);
         let examples_workspace_dir = sway_workspace_dir().join("examples");
-        let _test_programs_workspace_dir = sway_workspace_dir().join(in_language_test_dir());
-        let _sdk_harness_workspace_dir = sway_workspace_dir().join(sdk_harness_test_projects_dir());
+        let test_programs_workspace_dir = sway_workspace_dir().join(in_language_test_dir());
+        let sdk_harness_workspace_dir = sway_workspace_dir().join(sdk_harness_test_projects_dir());
 
-        // TODO: Support multiple workspaces: https://github.com/FuelLabs/sway/issues/7177
         let workspace_dirs = vec![
             &examples_workspace_dir,
-            //&test_programs_workspace_dir,
-            //&sdk_harness_workspace_dir,
+            &test_programs_workspace_dir,
+            &sdk_harness_workspace_dir,
         ];
 
-        //----------------------------------
         for workspace_dir in workspace_dirs {
-            // we need to init and open if this is the first time we are opening a workspace
-            // TODO: https://github.com/FuelLabs/sway/issues/7177
             let member_manifests = ManifestFile::from_dir(workspace_dir)
                 .unwrap()
                 .member_manifests()
@@ -213,10 +209,11 @@ fn did_open_all_members_in_examples() {
 
                 // If the workspace is not initialized, we need to initialize it
                 // Otherwise, we can just open the file
-                let uri = if service.inner().sync_workspace.get().is_none() {
-                    init_and_open(&mut service, dir.join("src/main.sw")).await
+                let path = dir.join("src/main.sw");
+                let uri = if service.inner().sync_workspaces.is_empty() {
+                    init_and_open(&mut service, path).await
                 } else {
-                    open(service.inner(), dir.join("src/main.sw")).await
+                    open(service.inner(), path).await
                 };
 
                 // Make sure that program was parsed and the token map is populated
@@ -251,7 +248,7 @@ fn sync_with_updates_to_manifest_in_workspace() {
         let (mut service, _) = LspService::new(ServerState::new);
         let workspace_dir = test_fixtures_dir().join("workspace");
         let path = workspace_dir.join("test-contract/src/main.sw");
-        let uri = init_and_open(&mut service, path).await;
+        let uri = init_and_open(&mut service, path.clone()).await;
 
         // add test-library as a dependency to the test-contract manifest file
         let test_lib_string = "test-library = { path = \"../test-library\" }";
@@ -270,7 +267,7 @@ fn sync_with_updates_to_manifest_in_workspace() {
         lsp::did_change_watched_files_notification(&mut service, params).await;
 
         // Check that the build plan now has 3 items
-        let (_, session) = service
+        let (uri, session) = service
             .inner()
             .uri_and_session_from_workspace(&uri)
             .unwrap();
@@ -279,8 +276,8 @@ fn sync_with_updates_to_manifest_in_workspace() {
             .get_or_update(
                 &service
                     .inner()
-                    .sync_workspace
-                    .get()
+                    .sync_workspaces
+                    .get(&path)
                     .unwrap()
                     .workspace_manifest_path(),
                 || sway_lsp::core::session::build_plan(&uri),