fix: seed newly registered file provider domain

Author: misrasaurabh1

apps/desktop/src-tauri/src/main.rs

@@ -8800,15 +8800,15 @@ fn activate_virtual_projection_mount(
     {
         wait_for_virtual_projection_mount_point_children(state_root, mount)?;
     }
-    register_virtual_projection(state_root, mount)?;
+    let macos_domain_registration = register_virtual_projection(state_root, mount)?;
     prefetch_virtual_projection_root(state_root, mount)?;
     if wait_for_entities
         && !virtual_projection_waits_for_mount_point_children_before_registration(&mount.projection)
     {
         wait_for_mount_entities(state_root, &mount.mount_id)?;
     }
     ensure_virtual_projection_runtime(state_root, mount)?;
-    refresh_virtual_projection_mount_activation(mount);
+    refresh_virtual_projection_mount_activation(mount, macos_domain_registration);
     recover_virtual_projection_mount_root_if_needed(state_root, mount)?;
     desktop_log(
         "info",
@@ -8885,7 +8885,7 @@ fn recover_macos_file_provider_mount_root_if_needed(
     );
     prefetch_virtual_projection_root(state_root, mount)?;
     ensure_virtual_projection_runtime(state_root, mount)?;
-    refresh_virtual_projection_mount_activation(mount);
+    refresh_virtual_projection_mount_activation(mount, MacosFileProviderDomainRegistration::Reused);
 
     wait_for_macos_file_provider_mount_root_recovery(
         &root,
@@ -9786,6 +9786,12 @@ enum VirtualProjectionRefreshAction {
     ReimportThenSignal(String),
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum MacosFileProviderDomainRegistration {
+    Created,
+    Reused,
+}
+
 impl VirtualProjectionRefreshAction {
     fn identifier(&self) -> &str {
         match self {
@@ -9800,8 +9806,11 @@ fn signal_virtual_projection_refresh(mount: &MountConfig) {
     }
 }
 
-fn refresh_virtual_projection_mount_activation(mount: &MountConfig) {
-    for action in virtual_projection_mount_activation_refresh_actions(mount) {
+fn refresh_virtual_projection_mount_activation(
+    mount: &MountConfig,
+    domain_registration: MacosFileProviderDomainRegistration,
+) {
+    for action in virtual_projection_mount_activation_refresh_actions(mount, domain_registration) {
         run_virtual_projection_refresh_action(mount, &action);
     }
 }
@@ -9839,12 +9848,19 @@ fn virtual_projection_refresh_actions(mount: &MountConfig) -> Vec<VirtualProject
 
 fn virtual_projection_mount_activation_refresh_actions(
     mount: &MountConfig,
+    domain_registration: MacosFileProviderDomainRegistration,
 ) -> Vec<VirtualProjectionRefreshAction> {
     if mount.projection == ProjectionMode::MacosFileProvider {
-        return vec![
+        let mut actions = vec![
             VirtualProjectionRefreshAction::Signal(ROOT_CONTAINER_IDENTIFIER.to_string()),
             VirtualProjectionRefreshAction::ReimportThenSignal(mount_point_identifier(mount)),
         ];
+        if domain_registration == MacosFileProviderDomainRegistration::Created {
+            actions.push(VirtualProjectionRefreshAction::Signal(
+                "working-set".to_string(),
+            ));
+        }
+        return actions;
     }
     virtual_projection_refresh_actions(mount)
 }
@@ -9934,35 +9950,62 @@ fn refresh_macos_virtual_projection(
     Ok(())
 }
 
-fn register_virtual_projection(state_root: &Path, mount: &MountConfig) -> Result<(), String> {
+fn register_virtual_projection(
+    state_root: &Path,
+    mount: &MountConfig,
+) -> Result<MacosFileProviderDomainRegistration, String> {
     match mount.projection {
         ProjectionMode::MacosFileProvider => {
             register_macos_virtual_projection(&mount.mount_id.0, &mount.root.display().to_string())
         }
-        ProjectionMode::LinuxFuse => register_linux_virtual_projection(state_root, mount),
-        ProjectionMode::PlainFiles => Ok(()),
-        ProjectionMode::WindowsCloudFiles => register_windows_virtual_projection(state_root, mount),
+        ProjectionMode::LinuxFuse => register_linux_virtual_projection(state_root, mount)
+            .map(|_| MacosFileProviderDomainRegistration::Reused),
+        ProjectionMode::PlainFiles => Ok(MacosFileProviderDomainRegistration::Reused),
+        ProjectionMode::WindowsCloudFiles => register_windows_virtual_projection(state_root, mount)
+            .map(|_| MacosFileProviderDomainRegistration::Reused),
     }
 }
 
 #[cfg(target_os = "macos")]
-fn register_macos_virtual_projection(_mount_id: &str, _root: &str) -> Result<(), String> {
-    register_macos_file_provider_domain(
+fn register_macos_virtual_projection(
+    _mount_id: &str,
+    _root: &str,
+) -> Result<MacosFileProviderDomainRegistration, String> {
+    let report = register_macos_file_provider_domain(
         localityd::file_provider::MACOS_FILE_PROVIDER_DOMAIN_ID,
         localityd::file_provider::MACOS_FILE_PROVIDER_DISPLAY_NAME,
     )
-    .map(|_| ())
     .map_err(|error| {
         format!(
             "Could not register macOS File Provider: {}",
             error.message()
         )
-    })
+    })?;
+    Ok(macos_file_provider_domain_registration(
+        &report.helper_report,
+    ))
 }
 
 #[cfg(not(target_os = "macos"))]
-fn register_macos_virtual_projection(_mount_id: &str, _root: &str) -> Result<(), String> {
-    Ok(())
+fn register_macos_virtual_projection(
+    _mount_id: &str,
+    _root: &str,
+) -> Result<MacosFileProviderDomainRegistration, String> {
+    Ok(MacosFileProviderDomainRegistration::Reused)
+}
+
+fn macos_file_provider_domain_registration(
+    helper_report: &serde_json::Value,
+) -> MacosFileProviderDomainRegistration {
+    if helper_report
+        .get("registrationCreated")
+        .and_then(serde_json::Value::as_bool)
+        == Some(true)
+    {
+        MacosFileProviderDomainRegistration::Created
+    } else {
+        MacosFileProviderDomainRegistration::Reused
+    }
 }
 
 #[cfg(target_os = "linux")]
@@ -12027,14 +12070,14 @@ mod tests {
     use super::{
         ActionReport, DESKTOP_ACTIVITY_LIMIT, DESKTOP_INSTALL_MARKER_VERSION,
         LIVE_MODE_REMOTE_FAST_FORWARD_LEASE, LIVE_MODE_RUNNER_ACTIVE_INTERVAL,
-        LIVE_MODE_RUNNER_PERIODIC_RECHECK, MonitorScreenBounds, PendingChange, ScreenBounds,
-        TerminalCliLinkState, TrayVisualState, VirtualProjectionRefreshAction,
-        acknowledge_install_state_at, activity_timestamp, clear_mount_cached_projection,
-        clear_state_root_contents, clear_visible_projection_paths, conflict_preview,
-        connection_metadata_changed, current_daemon_build_id, current_desktop_build_id,
-        diff_report_message, exact_located_entity_record, exact_notion_entry_matches,
-        failed_push_summary, has_unresolved_conflict_markers, hydration_after_editor_write,
-        inspect_install_state, install_terminal_cli_link_at,
+        LIVE_MODE_RUNNER_PERIODIC_RECHECK, MacosFileProviderDomainRegistration,
+        MonitorScreenBounds, PendingChange, ScreenBounds, TerminalCliLinkState, TrayVisualState,
+        VirtualProjectionRefreshAction, acknowledge_install_state_at, activity_timestamp,
+        clear_mount_cached_projection, clear_state_root_contents, clear_visible_projection_paths,
+        conflict_preview, connection_metadata_changed, current_daemon_build_id,
+        current_desktop_build_id, diff_report_message, exact_located_entity_record,
+        exact_notion_entry_matches, failed_push_summary, has_unresolved_conflict_markers,
+        hydration_after_editor_write, inspect_install_state, install_terminal_cli_link_at,
         install_terminal_cli_link_in_path_dirs, is_notion_access_lost_message,
         is_unsupported_schema_version_message, live_mode_claim_remote_fast_forward_key,
         live_mode_enabled_mount, live_mode_local_reconcile_targets_for_mount_at,
@@ -12044,7 +12087,7 @@ mod tests {
         live_mode_should_reconcile_local_target_for_key, live_mode_target,
         live_mode_tick_from_snapshot, live_mode_wake_generation, load_desktop_activity,
         macos_app_bundle_for_exe, macos_file_provider_child_item_count,
-        macos_file_provider_mount_root_health_error,
+        macos_file_provider_domain_registration, macos_file_provider_mount_root_health_error,
         macos_file_provider_mount_root_inspection_recovery_reason,
         macos_file_provider_mount_root_is_missing, macos_file_provider_mount_root_recovery_reason,
         mark_mount_live_mode_syncing, mount_has_pending_local_changes,
@@ -14998,7 +15041,7 @@ mod tests {
     }
 
     #[test]
-    fn macos_file_provider_refresh_is_scoped_to_the_new_mount() {
+    fn macos_file_provider_reused_domain_refresh_is_scoped_to_the_new_mount() {
         let mount = MountConfig::new(
             MountId::new("google-calendar-main"),
             "google-calendar",
@@ -15007,7 +15050,10 @@ mod tests {
         .projection(ProjectionMode::MacosFileProvider);
 
         assert_eq!(
-            virtual_projection_mount_activation_refresh_actions(&mount),
+            virtual_projection_mount_activation_refresh_actions(
+                &mount,
+                MacosFileProviderDomainRegistration::Reused,
+            ),
             vec![
                 VirtualProjectionRefreshAction::Signal("root".to_string()),
                 VirtualProjectionRefreshAction::ReimportThenSignal(
@@ -15017,6 +15063,44 @@ mod tests {
         );
     }
 
+    #[test]
+    fn macos_file_provider_new_domain_seeds_the_working_set_once() {
+        let mount = MountConfig::new(
+            MountId::new("notion-main"),
+            "notion",
+            "/tmp/Locality/notion",
+        )
+        .projection(ProjectionMode::MacosFileProvider);
+
+        assert_eq!(
+            virtual_projection_mount_activation_refresh_actions(
+                &mount,
+                MacosFileProviderDomainRegistration::Created,
+            ),
+            vec![
+                VirtualProjectionRefreshAction::Signal("root".to_string()),
+                VirtualProjectionRefreshAction::ReimportThenSignal("mount:notion-main".to_string(),),
+                VirtualProjectionRefreshAction::Signal("working-set".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn macos_file_provider_registration_report_defaults_to_reused() {
+        assert_eq!(
+            macos_file_provider_domain_registration(&serde_json::json!({
+                "registrationCreated": true,
+            })),
+            MacosFileProviderDomainRegistration::Created
+        );
+        assert_eq!(
+            macos_file_provider_domain_registration(&serde_json::json!({
+                "message": "already registered loc",
+            })),
+            MacosFileProviderDomainRegistration::Reused
+        );
+    }
+
     #[test]
     fn macos_file_provider_visible_refresh_never_reimports_the_shared_root() {
         let mount = MountConfig::new(

docs/desktop-app.md

@@ -213,14 +213,17 @@ Later source mounts reuse the existing shared File Provider domain. Adding a
 top-level source folder such as `google-calendar-main` signals the domain root
 enumerator so macOS can discover that one child, but must not reimport the
 shared root, replace its registration, or disturb sibling mounts such as
-`notion`. Registration is idempotent when the shared domain already exists;
-automatic setup treats that registration as authoritative rather than removing
-and recreating it to repair metadata. Reimport and readiness repair stay scoped
-to the new mount-point identifier. Mount-point appearance gets an initial
-30-second wait and one 30-second scoped refresh window; if it is still
-unavailable, Locality reports a recoverable preparation warning without
-resetting the domain. Whole-domain unregister or reset is reserved for explicit
-repair flows, never automatic source activation.
+`notion`. A newly created domain also receives one non-destructive working-set
+signal after its first source is ready; macOS requires that initial enumeration
+to seed the otherwise-empty File Provider database. Later source activation
+does not repeat the working-set signal. Registration is idempotent when the
+shared domain already exists; automatic setup treats that registration as
+authoritative rather than removing and recreating it to repair metadata.
+Reimport and readiness repair stay scoped to the new mount-point identifier.
+Mount-point appearance gets an initial 30-second wait and one 30-second scoped
+refresh window; if it is still unavailable, Locality reports a recoverable
+preparation warning without resetting the domain. Whole-domain unregister or
+reset is reserved for explicit repair flows, never automatic source activation.
 
 The final ready screen must not appear until File Provider approval, the
 CloudStorage root, and the mount root are all verified successfully.

platform/macos/LocalityFileProvider/README.md

@@ -69,13 +69,15 @@ in Finder. Opening the raw mount root is not enough to test lazy enumeration:
 Finder must enter the File Provider domain so directory listings call
 `file_provider_children` on `localityd`.
 
-Mount activation signals the shared domain root after adding a source. Because
-macOS creates that source folder asynchronously, Locality briefly waits for the
-new mount point before inspecting it. If the folder remains absent or File
-Provider reports an unhealthy replica, Locality resets and re-registers the
-shared domain, refreshes it from durable mount state, and waits for the source
-folder to become healthy. Reconnecting an existing source retries this
-activation path instead of only reloading daemon mounts.
+Mount activation signals the shared domain root after adding a source. A newly
+registered domain also receives one working-set signal to seed macOS's initially
+empty File Provider database. Later source mounts do not repeat that global
+signal: their reimport and readiness repair stay scoped to the new mount-point
+identifier. Because macOS creates a source folder asynchronously, Locality waits
+for it before inspecting it and retries the scoped refresh once. Automatic
+activation never resets or re-registers the shared domain. Reconnecting an
+existing source retries this activation path instead of only reloading daemon
+mounts.
 
 Delete support still returns unsupported. Creates and renames are represented as
 daemon virtual mutations and stay pending until the normal review and push flow

platform/macos/LocalityFileProvider/Sources/LocalityFileProviderCtl/main.swift

@@ -94,7 +94,8 @@ private enum Command {
           domain: DomainReport(existing),
           domains: nil,
           url: nil,
-          message: "already registered \(mountId)"
+          message: "already registered \(mountId)",
+          registrationCreated: false
         )
       }
 
@@ -120,7 +121,8 @@ private enum Command {
           domain: DomainReport(existing),
           domains: nil,
           url: nil,
-          message: "already registered \(mountId)"
+          message: "already registered \(mountId)",
+          registrationCreated: false
         )
       }
       return FileProviderCtlReport(
@@ -129,7 +131,8 @@ private enum Command {
         domain: DomainReport(domain),
         domains: nil,
         url: nil,
-        message: "registered \(mountId)"
+        message: "registered \(mountId)",
+        registrationCreated: true
       )
     case .open(let mountId):
       guard let domain = try getDomains().first(where: { $0.identifier.rawValue == mountId }) else {
@@ -283,6 +286,25 @@ private struct FileProviderCtlReport: Encodable {
   let domains: [DomainReport]?
   let url: String?
   let message: String
+  let registrationCreated: Bool?
+
+  init(
+    ok: Bool,
+    action: String,
+    domain: DomainReport?,
+    domains: [DomainReport]?,
+    url: String?,
+    message: String,
+    registrationCreated: Bool? = nil
+  ) {
+    self.ok = ok
+    self.action = action
+    self.domain = domain
+    self.domains = domains
+    self.url = url
+    self.message = message
+    self.registrationCreated = registrationCreated
+  }
 }
 
 private struct DomainReport: Encodable {