fix(app): wait for peer bucket metadata reload

crates/e2e_test/src/cluster_concurrency_test.rs

@@ -15,12 +15,14 @@
 use crate::common::RustFSTestClusterEnvironment;
 use aws_sdk_s3::Client;
 use aws_sdk_s3::error::SdkError;
+use aws_sdk_s3::types::{CorsConfiguration, CorsRule};
 use bytes::Bytes;
 use std::sync::Arc;
 use tokio::sync::Barrier;
 use tracing::{info, warn};
 
 const BUCKET: &str = "conditional-put-race-bucket";
+const BUCKET_METADATA_RELOAD_BUCKET: &str = "bucket-metadata-reload-barrier";
 
 async fn cleanup_object(client: &Client, key: &str) {
     if let Err(e) = client.delete_object().bucket(BUCKET).key(key).send().await {
@@ -28,6 +30,16 @@ async fn cleanup_object(client: &Client, key: &str) {
     }
 }
 
+async fn assert_bucket_cors_missing(client: &Client) {
+    let result = client.get_bucket_cors().bucket(BUCKET_METADATA_RELOAD_BUCKET).send().await;
+    match result {
+        Err(SdkError::ServiceError(error)) => {
+            assert_eq!(error.err().meta().code(), Some("NoSuchCORSConfiguration"));
+        }
+        result => panic!("expected the peer to report a missing CORS configuration: {result:?}"),
+    }
+}
+
 async fn conditional_put(
     client: &Client,
     key: &str,
@@ -236,3 +248,48 @@ async fn test_conditional_put_basic_cluster() -> Result<(), Box<dyn std::error::
     cleanup_object(&client, test_key).await;
     Ok(())
 }
+
+#[tokio::test]
+async fn test_bucket_cors_write_is_visible_on_peer_before_response() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    crate::common::init_logging();
+
+    let mut cluster = RustFSTestClusterEnvironment::new(2).await?;
+    cluster.start().await?;
+    cluster.create_test_bucket(BUCKET_METADATA_RELOAD_BUCKET).await?;
+
+    let writer = cluster.create_s3_client(0)?;
+    let reader = cluster.create_s3_client(1)?;
+    assert_bucket_cors_missing(&reader).await;
+
+    let rule = CorsRule::builder()
+        .allowed_methods("GET")
+        .allowed_origins("https://example.com")
+        .build()?;
+    let configuration = CorsConfiguration::builder().cors_rules(rule).build()?;
+
+    writer
+        .put_bucket_cors()
+        .bucket(BUCKET_METADATA_RELOAD_BUCKET)
+        .cors_configuration(configuration)
+        .send()
+        .await?;
+
+    let response = reader.get_bucket_cors().bucket(BUCKET_METADATA_RELOAD_BUCKET).send().await?;
+    let rules = response.cors_rules();
+    assert_eq!(
+        rules.len(),
+        1,
+        "peer should observe the committed CORS rule before the write response returns"
+    );
+    assert_eq!(rules[0].allowed_methods(), ["GET"]);
+    assert_eq!(rules[0].allowed_origins(), ["https://example.com"]);
+
+    writer
+        .delete_bucket_cors()
+        .bucket(BUCKET_METADATA_RELOAD_BUCKET)
+        .send()
+        .await?;
+    assert_bucket_cors_missing(&reader).await;
+    writer.delete_bucket().bucket(BUCKET_METADATA_RELOAD_BUCKET).send().await?;
+    Ok(())
+}

crates/ecstore/src/cluster/rpc/peer_rest_client.rs

@@ -85,6 +85,7 @@ const PEER_REST_RECOVERY_MAX_ATTEMPTS: u32 = 60;
 const PEER_REST_RECOVERY_MAX_BACKOFF: Duration = Duration::from_secs(30);
 const SCANNER_ACTIVITY_MAX_MESSAGE_SIZE: usize = 1024;
 const REPLICATION_STATS_MAX_MESSAGE_SIZE: usize = 8 * 1024 * 1024;
+const BUCKET_METADATA_RELOAD_TIMEOUT: Duration = Duration::from_secs(5);
 
 /// Error for a peer that reported `success = false` without an `error_info` payload.
 ///
@@ -1328,27 +1329,38 @@ impl PeerRestClient {
     }
 
     pub async fn load_bucket_metadata(&self, bucket: &str, scanner_maintenance_change: bool) -> Result<()> {
-        self.finalize_result(
-            async {
-                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadBucketMetadataRequest {
-                    bucket: bucket.to_string(),
-                    scanner_maintenance_change,
-                });
-                set_tonic_mutation_body_digest(&mut request)?;
-
-                let response = client.load_bucket_metadata(request).await?.into_inner();
-                if !response.success {
-                    if let Some(msg) = response.error_info {
-                        return Err(Error::other(msg));
-                    }
-                    return Err(peer_failure_without_details("load_bucket_metadata", Some(bucket)));
-                }
-                Ok(())
+        let result = tokio::time::timeout(BUCKET_METADATA_RELOAD_TIMEOUT, async {
+            let result = self.load_bucket_metadata_once(bucket, scanner_maintenance_change).await;
+            if let Err(err) = &result
+                && Self::is_network_like_error(err)
+            {
+                self.prepare_retry().await;
+                return self.load_bucket_metadata_once(bucket, scanner_maintenance_change).await;
             }
-            .await,
-        )
+            result
+        })
         .await
+        .unwrap_or_else(|_| Err(Error::other(format!("load_bucket_metadata({bucket}) timed out"))));
+        self.finalize_result(result).await
+    }
+
+    async fn load_bucket_metadata_once(&self, bucket: &str, scanner_maintenance_change: bool) -> Result<()> {
+        let mut client = self.get_client().await?;
+        let mut request = Request::new(LoadBucketMetadataRequest {
+            bucket: bucket.to_string(),
+            scanner_maintenance_change,
+        });
+        set_tonic_mutation_body_digest(&mut request)?;
+        request.set_timeout(BUCKET_METADATA_RELOAD_TIMEOUT);
+
+        let response = client.load_bucket_metadata(request).await?.into_inner();
+        if !response.success {
+            if let Some(msg) = response.error_info {
+                return Err(Error::other(msg));
+            }
+            return Err(peer_failure_without_details("load_bucket_metadata", Some(bucket)));
+        }
+        Ok(())
     }
 
     pub async fn delete_bucket_metadata(&self, bucket: &str) -> Result<()> {

crates/ecstore/src/cluster/rpc/remote_disk.rs

@@ -50,10 +50,10 @@ use rustfs_protos::evict_failed_connection;
 use rustfs_protos::proto_gen::node_service::RenamePartRequest;
 use rustfs_protos::proto_gen::node_service::{
     BatchReadVersionRequest, BatchReadVersionResponse, CheckPartsRequest, DeletePathsRequest, DeleteRequest,
-    DeleteVersionRequest, DeleteVersionsRequest, DeleteVersionsResponse, DeleteVolumeRequest, DiskInfoRequest, ListDirRequest,
-    ListVolumesRequest, MakeVolumeRequest, MakeVolumesRequest, PreparePartTransactionRequest, ReadAllRequest,
-    ReadMetadataRequest, ReadMultipleRequest, ReadMultipleResponse, ReadPartsRequest, ReadVersionRequest, ReadXlRequest,
-    RenameDataRequest, RenameFileRequest, SettlePartTransactionRequest, SnapshotLeaseReleaseRequest, SnapshotLeaseRenewRequest,
+    DeleteVersionRequest, DeleteVersionsRequest, DeleteVolumeRequest, DiskInfoRequest, ListDirRequest, ListVolumesRequest,
+    MakeVolumeRequest, MakeVolumesRequest, PreparePartTransactionRequest, ReadAllRequest, ReadMetadataRequest,
+    ReadMultipleRequest, ReadMultipleResponse, ReadPartsRequest, ReadVersionRequest, ReadXlRequest, RenameDataRequest,
+    RenameFileRequest, SettlePartTransactionRequest, SnapshotLeaseReleaseRequest, SnapshotLeaseRenewRequest,
     SnapshotLeaseRequest, SnapshotLeaseResponse, StatVolumeRequest, UpdateMetadataRequest, VerifyFileRequest, WriteAllRequest,
     WriteMetadataRequest, node_service_client::NodeServiceClient,
 };
@@ -112,28 +112,6 @@ const EVENT_REMOTE_DISK_RPC: &str = "remote_disk_rpc";
 const SNAPSHOT_LEASE_PROTOCOL_VERSION: u32 = 1;
 pub const REMOTE_SNAPSHOT_LEASE_TTL: Duration = Duration::from_secs(60);
 
-fn decode_delete_versions_errors(response: DeleteVersionsResponse, expected_len: usize) -> Vec<Option<Error>> {
-    if !response.item_errors.is_empty() {
-        if response.item_errors.len() != expected_len {
-            return vec![Some(Error::other("malformed delete_versions item errors")); expected_len];
-        }
-        return response
-            .item_errors
-            .into_iter()
-            .map(|error| (error.code != 0).then(|| error.into()))
-            .collect();
-    }
-
-    if response.errors.len() != expected_len {
-        return vec![Some(Error::other("malformed delete_versions errors")); expected_len];
-    }
-    response
-        .errors
-        .into_iter()
-        .map(|error| (!error.is_empty()).then(|| Error::other(error)))
-        .collect()
-}
-
 fn snapshot_lease_token_from_response(response: SnapshotLeaseResponse) -> Result<SnapshotLeaseToken> {
     if !response.success {
         return Err(response.error.unwrap_or_default().into());
@@ -2428,6 +2406,8 @@ impl DiskAPI for RemoteDisk {
             return errors;
         }
 
+        // TODO(backlog): replace string errors with typed `StorageError` variants
+
         let result = self
             .execute_with_timeout(
                 || async {
@@ -2459,7 +2439,17 @@ impl DiskAPI for RemoteDisk {
             }
             return errors;
         }
-        decode_delete_versions_errors(response, versions.len())
+        response
+            .errors
+            .iter()
+            .map(|error| {
+                if error.is_empty() {
+                    None
+                } else {
+                    Some(Error::other(error.to_string()))
+                }
+            })
+            .collect()
     }
 
     #[tracing::instrument(level = "trace", skip_all)]
@@ -3770,63 +3760,6 @@ mod tests {
 
     static INIT: Once = Once::new();
 
-    #[test]
-    fn delete_versions_response_preserves_typed_item_errors() {
-        let errors = decode_delete_versions_errors(
-            DeleteVersionsResponse {
-                success: true,
-                errors: vec!["file not found".to_string(), String::new()],
-                error: None,
-                item_errors: vec![
-                    rustfs_protos::proto_gen::node_service::Error {
-                        code: DiskError::FileNotFound.to_u32(),
-                        error_info: "file not found".to_string(),
-                    },
-                    rustfs_protos::proto_gen::node_service::Error::default(),
-                ],
-            },
-            2,
-        );
-
-        assert!(matches!(errors.as_slice(), [Some(DiskError::FileNotFound), None]));
-    }
-
-    #[test]
-    fn delete_versions_response_accepts_legacy_string_errors() {
-        let errors = decode_delete_versions_errors(
-            DeleteVersionsResponse {
-                success: true,
-                errors: vec!["legacy error".to_string(), String::new()],
-                error: None,
-                item_errors: Vec::new(),
-            },
-            2,
-        );
-
-        assert_eq!(errors.len(), 2);
-        assert_eq!(errors[0].as_ref().map(ToString::to_string).as_deref(), Some("io error legacy error"));
-        assert!(errors[1].is_none());
-    }
-
-    #[test]
-    fn delete_versions_response_rejects_misaligned_item_errors() {
-        let errors = decode_delete_versions_errors(
-            DeleteVersionsResponse {
-                success: true,
-                errors: vec!["file not found".to_string()],
-                error: None,
-                item_errors: vec![rustfs_protos::proto_gen::node_service::Error {
-                    code: DiskError::FileNotFound.to_u32(),
-                    error_info: "file not found".to_string(),
-                }],
-            },
-            2,
-        );
-
-        assert_eq!(errors.len(), 2);
-        assert!(errors.iter().all(Option::is_some));
-    }
-
     #[test]
     fn disk_mutation_digest_marks_rolling_compatibility() {
         let mut request = Request::new(());

crates/filemeta/src/metacache.rs

@@ -21,7 +21,6 @@ use arc_swap::ArcSwapOption;
 use rmp::Marker;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
-use std::collections::{HashMap, HashSet};
 use std::str::from_utf8;
 use std::{
     fmt::Debug,
@@ -38,10 +37,8 @@ use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use tokio::spawn;
 use tokio::sync::Mutex;
 use tracing::{debug, warn};
-use uuid::Uuid;
 
 const SLASH_SEPARATOR: &str = "/";
-pub const MAX_META_CACHE_HEAL_CANDIDATES: usize = 1024;
 
 #[derive(Clone, Debug, Default)]
 pub struct MetadataResolutionParams {
@@ -69,41 +66,6 @@ pub struct MetaCacheEntry {
     pub reusable: bool,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum MetaCacheHealCandidateKind {
-    Object,
-    DeleteMarker,
-    UnversionedObject,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct MetaCacheHealCandidate {
-    pub object: String,
-    pub version_id: Option<Uuid>,
-    pub kind: MetaCacheHealCandidateKind,
-    /// Number of raw disk entries that carried this validated version.
-    pub replica_count: usize,
-}
-
-impl MetaCacheHealCandidate {
-    pub fn validated_version(&self) -> Option<Uuid> {
-        match self.kind {
-            MetaCacheHealCandidateKind::Object | MetaCacheHealCandidateKind::DeleteMarker => self.version_id,
-            MetaCacheHealCandidateKind::UnversionedObject => None,
-        }
-    }
-
-    pub fn is_unversioned(&self) -> bool {
-        self.kind == MetaCacheHealCandidateKind::UnversionedObject
-    }
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct MetaCacheHealDiscovery {
-    pub candidates: Vec<MetaCacheHealCandidate>,
-    pub unverified_count: usize,
-}
-
 impl MetaCacheEntry {
     pub fn marshal_msg(&self) -> Result<Vec<u8>> {
         let mut wr = Vec::new();
@@ -408,176 +370,6 @@ impl MetaCacheEntries {
         })
     }
 
-    /// Discover validated object/delete-marker versions and safe unversioned
-    /// inspection candidates in the raw entries without applying read quorum.
-    /// This is intentionally separate from [`Self::resolve`]: a sub-quorum
-    /// version is a valid heal target even though it must not participate in
-    /// normal reads or writes.
-    ///
-    /// The validated list is bounded and deduplicated by object, version id,
-    /// and metadata kind; each candidate retains the number of raw disk
-    /// entries that carried it so callers can classify sub-quorum versions.
-    /// Entries whose xl.meta cannot be decoded are counted separately for
-    /// discovery accounting; they never become versionless destructive heal
-    /// requests and do not consume the validated quota. An
-    /// [`MetaCacheHealCandidateKind::UnversionedObject`] is always consumed by
-    /// a non-destructive scanner request.
-    pub fn discover_heal_candidates(&self, bucket: &str, max_candidates: usize) -> MetaCacheHealDiscovery {
-        let limit = max_candidates.min(MAX_META_CACHE_HEAL_CANDIDATES);
-        if limit == 0 || bucket.is_empty() {
-            return MetaCacheHealDiscovery::default();
-        }
-
-        let mut discovery = MetaCacheHealDiscovery {
-            candidates: Vec::<MetaCacheHealCandidate>::with_capacity(limit.min(self.0.len())),
-            unverified_count: 0,
-        };
-        let mut seen: HashMap<(String, Option<Uuid>, MetaCacheHealCandidateKind), usize> =
-            HashMap::with_capacity(limit.min(self.0.len()));
-
-        for entry in self.0.iter().flatten() {
-            if !valid_heal_candidate_name(bucket, entry) {
-                continue;
-            }
-
-            let meta = match FileMeta::load(&entry.metadata) {
-                Ok(meta) => meta,
-                Err(_) => {
-                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                    continue;
-                }
-            };
-            let mut entry_seen = HashSet::new();
-
-            for shallow in meta.versions {
-                let version = match shallow.parse_version_meta() {
-                    Ok(version) if version.valid() => version,
-                    Ok(_) | Err(_) => {
-                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                        continue;
-                    }
-                };
-                if version.free_version() {
-                    continue;
-                }
-
-                let payload_header = version.header();
-                if normalize_version_id(shallow.header.version_id) != normalize_version_id(payload_header.version_id)
-                    || shallow.header.version_type != payload_header.version_type
-                {
-                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                    continue;
-                }
-
-                let (kind, version_id) = match version.version_type {
-                    VersionType::Object
-                        if version.object.is_some() && version.delete_marker.is_none() && version.legacy_object.is_none() =>
-                    {
-                        match version.object.as_ref().and_then(|object| object.version_id) {
-                            Some(id) if !id.is_nil() => (MetaCacheHealCandidateKind::Object, Some(id)),
-                            Some(_) | None => (MetaCacheHealCandidateKind::UnversionedObject, None),
-                        }
-                    }
-                    VersionType::Delete
-                        if version.delete_marker.is_some() && version.object.is_none() && version.legacy_object.is_none() =>
-                    {
-                        let Some(id) = version.delete_marker.as_ref().and_then(|marker| marker.version_id) else {
-                            discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                            continue;
-                        };
-                        if id.is_nil() {
-                            discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                            continue;
-                        }
-                        (MetaCacheHealCandidateKind::DeleteMarker, Some(id))
-                    }
-                    VersionType::Legacy
-                        if version.legacy_object.is_some() && version.object.is_none() && version.delete_marker.is_none() =>
-                    {
-                        let Some(legacy) = version.legacy_object.as_ref() else {
-                            continue;
-                        };
-                        if legacy.version_id.is_empty() {
-                            (MetaCacheHealCandidateKind::UnversionedObject, None)
-                        } else {
-                            let Ok(id) = Uuid::parse_str(&legacy.version_id) else {
-                                discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                                continue;
-                            };
-                            if id.is_nil() {
-                                discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                                continue;
-                            }
-                            (MetaCacheHealCandidateKind::Object, Some(id))
-                        }
-                    }
-                    _ => {
-                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                        continue;
-                    }
-                };
-
-                if normalize_version_id(payload_header.version_id) != version_id {
-                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                    continue;
-                }
-
-                // `all_parts=true` is the trust-boundary check for versioned
-                // candidates. A null/legacy object may still need the old
-                // non-destructive inspection fallback when its part arrays
-                // are parseable but incomplete; never use that fallback for
-                // a candidate carrying a real version id.
-                let file_info = match version.clone().into_fileinfo(bucket, &entry.name, true) {
-                    Ok(file_info) => file_info,
-                    Err(_) if version_id.is_none() && matches!(kind, MetaCacheHealCandidateKind::UnversionedObject) => {
-                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                        match version.into_fileinfo(bucket, &entry.name, false) {
-                            Ok(file_info) => file_info,
-                            Err(_) => continue,
-                        }
-                    }
-                    Err(_) => {
-                        discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                        continue;
-                    }
-                };
-                if file_info.volume != bucket || file_info.name != entry.name {
-                    discovery.unverified_count = discovery.unverified_count.saturating_add(1);
-                    continue;
-                }
-
-                let candidate = MetaCacheHealCandidate {
-                    object: entry.name.clone(),
-                    version_id,
-                    kind,
-                    replica_count: 1,
-                };
-                let key = (candidate.object.clone(), candidate.version_id, candidate.kind.clone());
-                if !entry_seen.contains(&key) {
-                    // Keep per-entry dedupe bounded as well as the global
-                    // candidate union. Once the cap is reached, only keys
-                    // already present in the global map may update replica
-                    // counts; novel versions are accounting-only.
-                    if entry_seen.len() >= limit && !seen.contains_key(&key) {
-                        continue;
-                    }
-                    entry_seen.insert(key.clone());
-                }
-                if let Some(index) = seen.get(&key).copied() {
-                    discovery.candidates[index].replica_count = discovery.candidates[index].replica_count.saturating_add(1);
-                } else {
-                    seen.insert(key, discovery.candidates.len());
-                    discovery.candidates.push(candidate);
-                    if discovery.candidates.len() >= limit {
-                        return discovery;
-                    }
-                }
-            }
-        }
-
-        discovery
-    }
-
     fn resolve_inner(&self, mut params: MetadataResolutionParams, enforce_write_quorum: bool) -> Option<MetaCacheEntry> {
         if self.0.is_empty() {
             debug!(
@@ -754,28 +546,6 @@ impl MetaCacheEntries {
     }
 }
 
-fn valid_heal_candidate_name(bucket: &str, entry: &MetaCacheEntry) -> bool {
-    if bucket.is_empty() || entry.name.is_empty() || entry.is_dir() || entry.name.contains('\0') {
-        return false;
-    }
-
-    // Validate raw key components without normalizing them. A dot component
-    // could otherwise escape the bucket when the key is later mapped back to
-    // a disk path; a final empty component is retained for valid keys ending
-    // in '/'.
-    let mut components = entry.name.split('/').peekable();
-    while let Some(component) = components.next() {
-        if component == "." || component == ".." || (component.is_empty() && components.peek().is_some()) {
-            return false;
-        }
-    }
-    true
-}
-
-fn normalize_version_id(version_id: Option<Uuid>) -> Option<Uuid> {
-    version_id.filter(|id| !id.is_nil())
-}
-
 #[derive(Debug, Default)]
 pub struct MetaCacheEntriesSortedResult {
     pub entries: Option<MetaCacheEntriesSorted>,
@@ -1221,7 +991,7 @@ impl<T: Clone + Debug + Send + Sync + 'static> Cache<T> {
 mod tests {
     use super::*;
     use crate::test_data::create_real_xlmeta;
-    use crate::{FileMetaVersion, MetaDeleteMarker, MetaObjectV1, MetaObjectV1Erasure, MetaObjectV1Stat, TRANSITION_COMPLETE};
+    use crate::{FileMetaVersion, MetaDeleteMarker, TRANSITION_COMPLETE};
     use std::collections::HashMap;
     use std::io::Cursor;
     use std::sync::{
@@ -1822,277 +1592,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn discover_heal_candidates_keeps_sub_quorum_versions_and_deduplicates() {
-        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
-        let entries = MetaCacheEntries(vec![
-            Some(metacache_entry_single_version(1, now, "one")),
-            Some(metacache_entry_single_version(2, now, "two")),
-            Some(metacache_entry_single_version(2, now, "two")),
-            Some(metacache_entry_single_version(3, now, "three")),
-        ]);
-
-        let discovery = entries.discover_heal_candidates("bucket", 16);
-        let ids: std::collections::HashSet<Uuid> = discovery
-            .candidates
-            .iter()
-            .filter_map(|candidate| candidate.version_id)
-            .collect();
-        assert_eq!(
-            ids,
-            [Uuid::from_u128(1), Uuid::from_u128(2), Uuid::from_u128(3)]
-                .into_iter()
-                .collect()
-        );
-        assert_eq!(discovery.candidates.len(), 3, "duplicate tied versions must be emitted once");
-        assert_eq!(
-            discovery
-                .candidates
-                .iter()
-                .find(|candidate| candidate.version_id == Some(Uuid::from_u128(2)))
-                .expect("duplicate version should be discovered")
-                .replica_count,
-            2
-        );
-    }
-
-    #[test]
-    fn discover_heal_candidates_covers_divergent_quorum_boundaries_n2_n4_n6() {
-        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
-
-        for (disk_count, quorum) in [(2usize, 1usize), (4, 2), (6, 3)] {
-            let target_id = Uuid::from_u128(0x1000 + disk_count as u128);
-            for target_replicas in [quorum.saturating_sub(1), quorum, quorum + 1] {
-                let entries = (0..disk_count)
-                    .map(|disk| {
-                        let version_id = if disk < target_replicas {
-                            target_id
-                        } else {
-                            Uuid::from_u128(0x2000 + disk as u128)
-                        };
-                        Some(metacache_entry_single_version(version_id.as_u128(), now, "divergent"))
-                    })
-                    .collect();
-                let discovery = MetaCacheEntries(entries).discover_heal_candidates("bucket", 32);
-                let target = discovery
-                    .candidates
-                    .iter()
-                    .find(|candidate| candidate.version_id == Some(target_id));
-                assert_eq!(target.is_some(), target_replicas > 0, "N={disk_count}, replicas={target_replicas}");
-                if let Some(target) = target {
-                    assert_eq!(target.replica_count, target_replicas);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn discover_heal_candidates_separates_delete_markers_and_preserves_unversioned_objects() {
-        let mut marker_meta = FileMeta::new();
-        marker_meta
-            .add_version(FileInfo {
-                volume: "bucket".to_string(),
-                name: "object".to_string(),
-                version_id: Some(Uuid::from_u128(99)),
-                deleted: true,
-                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp")),
-                ..Default::default()
-            })
-            .expect("delete marker should be added");
-        let marker = MetaCacheEntry {
-            name: "object".to_string(),
-            metadata: marker_meta.marshal_msg().expect("delete marker metadata should marshal"),
-            cached: Some(marker_meta),
-            reusable: false,
-        };
-
-        let unversioned_entry = metacache_entry_with_mod_time(
-            OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp"),
-            "unversioned",
-        );
-        let discovery = MetaCacheEntries(vec![Some(marker), Some(unversioned_entry)]).discover_heal_candidates("bucket", 16);
-        assert!(discovery.candidates.iter().any(|candidate| {
-            candidate.kind == MetaCacheHealCandidateKind::DeleteMarker && candidate.version_id == Some(Uuid::from_u128(99))
-        }));
-        assert!(discovery.candidates.iter().any(|candidate| {
-            candidate.kind == MetaCacheHealCandidateKind::UnversionedObject && candidate.version_id.is_none()
-        }));
-    }
-
-    #[test]
-    fn discover_heal_candidates_skips_free_versions() {
-        let object_id = Uuid::from_u128(100);
-        let free_id = Uuid::from_u128(101);
-        let mut meta = FileMeta::new();
-        meta.add_version(FileInfo {
-            volume: "bucket".to_string(),
-            name: "object".to_string(),
-            version_id: Some(object_id),
-            transition_status: TRANSITION_COMPLETE.to_string(),
-            transitioned_objname: "remote/object".to_string(),
-            transition_version_id: Some(Uuid::from_u128(102)),
-            transition_tier: "WARM".to_string(),
-            mod_time: Some(OffsetDateTime::now_utc()),
-            ..Default::default()
-        })
-        .expect("transitioned object should be added");
-        let mut delete = FileInfo {
-            volume: "bucket".to_string(),
-            name: "object".to_string(),
-            version_id: Some(object_id),
-            mod_time: Some(OffsetDateTime::now_utc()),
-            ..Default::default()
-        };
-        delete.set_tier_free_version_id(&free_id.to_string());
-        meta.delete_version(&delete).expect("free version should be persisted");
-
-        let discovery = MetaCacheEntries(vec![Some(MetaCacheEntry {
-            name: "object".to_string(),
-            metadata: meta.marshal_msg().expect("free version metadata should marshal"),
-            cached: Some(meta),
-            reusable: false,
-        })])
-        .discover_heal_candidates("bucket", 16);
-        assert!(discovery.candidates.is_empty());
-    }
-
-    #[test]
-    fn discover_heal_candidates_preserves_unversioned_legacy_object() {
-        let legacy = MetaObjectV1 {
-            version: "1.0.1".to_string(),
-            format: "xl".to_string(),
-            stat: MetaObjectV1Stat {
-                size: 1,
-                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp")),
-                name: "object".to_string(),
-                ..Default::default()
-            },
-            erasure: MetaObjectV1Erasure {
-                data_blocks: 4,
-                parity_blocks: 2,
-                index: 1,
-                distribution: vec![1, 2, 3, 4, 5, 6],
-                ..Default::default()
-            },
-            ..Default::default()
-        };
-        let version = FileMetaVersion {
-            version_type: VersionType::Legacy,
-            legacy_object: Some(legacy),
-            ..Default::default()
-        };
-        let mut meta = FileMeta::new();
-        meta.versions
-            .push(FileMetaShallowVersion::try_from(version).expect("legacy metadata should marshal"));
-        let discovery = MetaCacheEntries(vec![Some(MetaCacheEntry {
-            name: "object".to_string(),
-            metadata: meta.marshal_msg().expect("legacy metadata should marshal"),
-            cached: Some(meta),
-            reusable: false,
-        })])
-        .discover_heal_candidates("bucket", 16);
-        assert!(discovery.candidates.iter().any(|candidate| {
-            candidate.kind == MetaCacheHealCandidateKind::UnversionedObject && candidate.version_id.is_none()
-        }));
-    }
-
-    #[test]
-    fn discover_heal_candidates_rejects_nil_and_malformed_metadata_and_is_bounded() {
-        let now = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");
-        let mut nil = metacache_entry_single_version(1, now, "nil");
-        let mut nil_meta = FileMeta::load(&nil.metadata).expect("nil fixture should decode");
-        let mut nil_version = nil_meta.versions[0]
-            .parse_version_meta()
-            .expect("nil fixture version should decode");
-        nil_version.object.as_mut().expect("object fixture").version_id = Some(Uuid::nil());
-        nil_meta.versions[0] = FileMetaShallowVersion::try_from(nil_version).expect("nil fixture should marshal");
-        nil.metadata = nil_meta.marshal_msg().expect("nil fixture metadata should marshal");
-
-        let mut mismatched = metacache_entry_single_version(2, now, "mismatched");
-        let mut mismatched_meta = FileMeta::load(&mismatched.metadata).expect("mismatched fixture should decode");
-        mismatched_meta.versions[0].header.version_id = Some(Uuid::from_u128(200));
-        mismatched.metadata = mismatched_meta.marshal_msg().expect("mismatched metadata should marshal");
-
-        let mut short_parts = metacache_entry_single_version(3, now, "short-parts");
-        let mut short_parts_meta = FileMeta::load(&short_parts.metadata).expect("short-parts fixture should decode");
-        let mut short_parts_version = short_parts_meta.versions[0]
-            .parse_version_meta()
-            .expect("short-parts fixture version should decode");
-        let object = short_parts_version.object.as_mut().expect("object fixture");
-        object.part_numbers = vec![1];
-        object.part_actual_sizes = vec![1];
-        object.part_sizes.clear();
-        short_parts_meta.versions[0] = FileMetaShallowVersion::try_from(short_parts_version).expect("short-parts should marshal");
-        short_parts.metadata = short_parts_meta.marshal_msg().expect("short-parts metadata should marshal");
-
-        let mut short_unversioned = metacache_entry_with_mod_time(now, "short-unversioned");
-        let mut short_unversioned_meta =
-            FileMeta::load(&short_unversioned.metadata).expect("short-unversioned fixture should decode");
-        let mut short_unversioned_version = short_unversioned_meta.versions[0]
-            .parse_version_meta()
-            .expect("short-unversioned version should decode");
-        let unversioned_object = short_unversioned_version.object.as_mut().expect("unversioned object fixture");
-        unversioned_object.part_numbers = vec![1];
-        unversioned_object.part_actual_sizes = vec![1];
-        unversioned_object.part_sizes.clear();
-        short_unversioned_meta.versions[0] =
-            FileMetaShallowVersion::try_from(short_unversioned_version).expect("short-unversioned should marshal");
-        short_unversioned.metadata = short_unversioned_meta
-            .marshal_msg()
-            .expect("short-unversioned metadata should marshal");
-
-        let mut malformed = nil.clone();
-        malformed.name = "malformed".to_string();
-        malformed.metadata = vec![1, 2, 3];
-
-        let entries = MetaCacheEntries(
-            std::iter::once(Some(nil))
-                .chain(std::iter::once(Some(mismatched)))
-                .chain(std::iter::once(Some(short_parts)))
-                .chain(std::iter::once(Some(short_unversioned)))
-                .chain(std::iter::once(Some(malformed)))
-                .chain((0..32).map(|id| Some(metacache_entry_single_version(id + 10, now, "bounded"))))
-                .collect(),
-        );
-        let discovery = entries.discover_heal_candidates("bucket", 5);
-        assert!(discovery.candidates.len() <= 5);
-        assert!(
-            !discovery
-                .candidates
-                .iter()
-                .any(|candidate| candidate.version_id == Some(Uuid::nil()))
-        );
-        assert!(
-            !discovery
-                .candidates
-                .iter()
-                .any(|candidate| candidate.version_id == Some(Uuid::from_u128(2)))
-        );
-        assert!(
-            !discovery
-                .candidates
-                .iter()
-                .any(|candidate| candidate.version_id == Some(Uuid::from_u128(3)))
-        );
-        assert!(discovery.candidates.iter().any(|candidate| {
-            candidate.kind == MetaCacheHealCandidateKind::UnversionedObject && candidate.version_id.is_none()
-        }));
-        assert!(
-            discovery.unverified_count >= 1,
-            "malformed and rejected metadata must remain observable during discovery"
-        );
-
-        for invalid_name in ["../object", "object//", "object\0name"] {
-            let mut entry = metacache_entry_single_version(400, now, invalid_name);
-            entry.name = invalid_name.to_string();
-            let discovery = MetaCacheEntries(vec![Some(entry)]).discover_heal_candidates("bucket", 5);
-            assert!(
-                discovery.candidates.is_empty(),
-                "invalid key should not become a heal candidate: {invalid_name:?}"
-            );
-        }
-    }
-
     #[test]
     fn resolve_rejects_partial_latest_and_returns_committed_previous_metadata() {
         let old_mod_time = OffsetDateTime::from_unix_timestamp(1_705_312_300).expect("valid timestamp");

crates/heal/src/heal/channel.rs

@@ -1640,60 +1640,6 @@ mod tests {
         assert_eq!(payload["items"].as_array().expect("items should be an array").len(), 0);
     }
 
-    #[tokio::test]
-    async fn test_process_query_request_reports_displaced_terminal_detail() {
-        let heal_manager = Arc::new(HealManager::new(
-            Arc::new(MockStorage),
-            Some(HealConfig {
-                queue_size: 1,
-                ..HealConfig::default()
-            }),
-        ));
-        let mut displaced = HealRequest::new(
-            HealType::Bucket {
-                bucket: "displaced-channel".to_string(),
-            },
-            HealOptions::default(),
-            HealPriority::Low,
-        );
-        displaced.id = "displaced-channel-task".to_string();
-        let displaced_id = displaced.id.clone();
-        heal_manager
-            .submit_heal_request(displaced)
-            .await
-            .expect("initial channel task should queue");
-        heal_manager
-            .submit_heal_request(HealRequest::new(
-                HealType::Bucket {
-                    bucket: "successor-channel".to_string(),
-                },
-                HealOptions::default(),
-                HealPriority::High,
-            ))
-            .await
-            .expect("successor channel task should displace the initial task");
-
-        let processor = HealChannelProcessor::new(heal_manager);
-        let (tx, rx) = oneshot::channel();
-        processor
-            .process_query_request("displaced-channel".to_string(), displaced_id, None, tx)
-            .await
-            .expect("displaced query should process");
-        let response = rx
-            .await
-            .expect("query response should be returned")
-            .expect("displaced query should remain successful");
-        let payload: serde_json::Value = serde_json::from_slice(response.data.as_deref().expect("status payload should exist"))
-            .expect("status payload should be json");
-        assert_eq!(payload["summary"], "stopped");
-        assert!(
-            response
-                .error
-                .as_deref()
-                .is_some_and(|detail| detail.contains("reason=displaced"))
-        );
-    }
-
     #[tokio::test]
     async fn test_process_query_request_reports_running_for_queued_task() {
         let heal_manager = create_test_heal_manager();

crates/heal/src/heal/manager.rs

@@ -40,7 +40,6 @@ use tracing::{debug, error, info, warn};
 use super::{DiskError, Endpoint, HealDiskExt as _, local_disk_map_read};
 
 const KEEP_HEAL_TASK_STATUS_DURATION: Duration = Duration::from_secs(10 * 60);
-const DISPLACED_HEAL_REASON: &str = "reason=displaced; retry_hint=submit_again";
 const LOG_COMPONENT_HEAL: &str = "heal";
 const LOG_SUBSYSTEM_DISK_SCANNER: &str = "disk_scanner";
 const LOG_SUBSYSTEM_MANAGER: &str = "manager";
@@ -121,30 +120,26 @@ struct MrfRepairNoticeTarget {
     version_id: Option<[u8; 16]>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 struct HealAdmissionDecision {
     result: HealAdmissionResult,
-    displaced_request: Option<HealRequest>,
+    displaced_task_id: Option<String>,
 }
 
 impl HealAdmissionDecision {
     const fn new(result: HealAdmissionResult) -> Self {
         Self {
             result,
-            displaced_request: None,
+            displaced_task_id: None,
         }
     }
 
-    fn accepted_with_displacement(displaced_request: HealRequest) -> Self {
+    fn accepted_with_displacement(displaced_task_id: String) -> Self {
         Self {
             result: HealAdmissionResult::Accepted,
-            displaced_request: Some(displaced_request),
+            displaced_task_id: Some(displaced_task_id),
         }
     }
-
-    fn displaced_task_id(&self) -> Option<&str> {
-        self.displaced_request.as_ref().map(|request| request.id.as_str())
-    }
 }
 
 fn lock_mrf_repair_notice_targets(
@@ -156,55 +151,6 @@ fn lock_mrf_repair_notice_targets(
     }
 }
 
-fn lock_displaced_terminals(
-    registry: &StdMutex<HashMap<String, Arc<CompletedHealStatus>>>,
-) -> StdMutexGuard<'_, HashMap<String, Arc<CompletedHealStatus>>> {
-    match registry.lock() {
-        Ok(guard) => guard,
-        Err(poisoned) => poisoned.into_inner(),
-    }
-}
-
-fn record_displaced_terminal(
-    registry: &StdMutex<HashMap<String, Arc<CompletedHealStatus>>>,
-    request: &HealRequest,
-) -> Arc<CompletedHealStatus> {
-    let terminal = Arc::new(CompletedHealStatus {
-        heal_type: request.heal_type.clone(),
-        status: HealTaskStatus::Failed {
-            error: format!("heal task displaced by a higher-priority request ({DISPLACED_HEAL_REASON})"),
-        },
-        result_items_truncated: false,
-        completed_at: SystemTime::now(),
-        seqed_items: Vec::new(),
-        next_seq: 0,
-        min_seq: 0,
-    });
-    let mut terminals = lock_displaced_terminals(registry);
-    prune_completed_heal_statuses(&mut terminals);
-    terminals.insert(request.id.clone(), Arc::clone(&terminal));
-    terminal
-}
-
-async fn remove_displaced_task_aliases(
-    aliases: &Arc<Mutex<HashMap<String, HealTaskAlias>>>,
-    terminals: &StdMutex<HashMap<String, Arc<CompletedHealStatus>>>,
-    task_id: &str,
-    terminal: &Arc<CompletedHealStatus>,
-) {
-    let mut aliases = aliases.lock().await;
-    let alias_ids = aliases
-        .iter()
-        .filter_map(|(alias_id, alias)| (alias.task_id == task_id).then_some(alias_id.clone()))
-        .collect::<Vec<_>>();
-    let mut displaced_terminals = lock_displaced_terminals(terminals);
-    prune_completed_heal_statuses(&mut displaced_terminals);
-    for alias_id in alias_ids {
-        displaced_terminals.insert(alias_id, Arc::clone(terminal));
-    }
-    aliases.retain(|alias_id, alias| alias_id != task_id && alias.task_id != task_id);
-}
-
 async fn remove_task_aliases_for_task(registry: &Arc<Mutex<HashMap<String, HealTaskAlias>>>, task_id: &str) {
     registry
         .lock()
@@ -672,14 +618,6 @@ pub struct HealManager {
     /// are shared so the lookup helper can hand a completed entry to a
     /// caller without cloning the retained result window.
     completed_heals: Arc<Mutex<HashMap<String, Arc<CompletedHealStatus>>>>,
-    /// Terminals for requests removed by priority displacement. An Accepted
-    /// task ID remains queryable for the same process lifetime and the normal
-    /// ten-minute status TTL; clients should treat `reason=displaced` as a
-    /// terminal result and submit a fresh request. This sidecar is synchronous
-    /// so admission can publish the terminal while the queue transition is
-    /// still under its lock, without awaiting another tokio lock. Queue state
-    /// is process-local, so this guarantee does not extend across restart.
-    displaced_terminals: Arc<StdMutex<HashMap<String, Arc<CompletedHealStatus>>>>,
     /// Client tokens merged into an existing task id.
     task_aliases: Arc<Mutex<HashMap<String, HealTaskAlias>>>,
     /// Heal tasks waiting for a retry backoff to expire.
@@ -721,7 +659,6 @@ struct HealQueueContext<'a> {
     heal_queue: &'a Arc<Mutex<PriorityHealQueue>>,
     active_heals: &'a Arc<Mutex<HashMap<String, Arc<HealTask>>>>,
     completed_heals: &'a Arc<Mutex<HashMap<String, Arc<CompletedHealStatus>>>>,
-    displaced_terminals: &'a Arc<StdMutex<HashMap<String, Arc<CompletedHealStatus>>>>,
     task_aliases: &'a Arc<Mutex<HashMap<String, HealTaskAlias>>>,
     retrying_heals: &'a Arc<Mutex<HashMap<String, RetryingHeal>>>,
     mrf_repair_notice_targets: &'a Arc<StdMutex<HashMap<String, Vec<MrfRepairNoticeTarget>>>>,
@@ -937,7 +874,7 @@ impl HealManager {
                         result = "accepted_by_displacement",
                         "Heal queue request accepted by displacement"
                     });
-                    return HealAdmissionDecision::accepted_with_displacement(displaced);
+                    return HealAdmissionDecision::accepted_with_displacement(displaced.id);
                 }
 
                 demote_to_debug_when!(per_object_request, warn, target: "rustfs::heal::manager", {
@@ -1168,7 +1105,6 @@ impl HealManager {
             active_heals: Arc::new(Mutex::new(HashMap::new())),
             heal_queue: Arc::new(Mutex::new(PriorityHealQueue::new())),
             completed_heals: Arc::new(Mutex::new(HashMap::new())),
-            displaced_terminals: Arc::new(StdMutex::new(HashMap::new())),
             task_aliases: Arc::new(Mutex::new(HashMap::new())),
             retrying_heals: Arc::new(Mutex::new(HashMap::new())),
             mrf_repair_notice_targets: Arc::new(StdMutex::new(HashMap::new())),
@@ -1273,10 +1209,6 @@ impl HealManager {
         active_heals.clear();
         publish_active_heal_count(&active_heals);
         self.completed_heals.lock().await.clear();
-        // Do not let the synchronous guard live across the following async lock.
-        {
-            lock_displaced_terminals(&self.displaced_terminals).clear();
-        }
         self.task_aliases.lock().await.clear();
         self.retrying_heals.lock().await.clear();
         lock_mrf_repair_notice_targets(&self.mrf_repair_notice_targets).clear();
@@ -1527,11 +1459,7 @@ impl HealManager {
             task_id = queued_id.to_owned();
         }
         let should_notify = matches!(admission, HealAdmissionResult::Accepted) && config.event_driven_scheduler_enable;
-        let displaced_task_id = admission_decision.displaced_task_id().map(ToOwned::to_owned);
-        let displaced_terminal = admission_decision
-            .displaced_request
-            .as_ref()
-            .map(|request| record_displaced_terminal(&self.displaced_terminals, request));
+        let displaced_task_id = admission_decision.displaced_task_id;
         if matches!(admission, HealAdmissionResult::Accepted | HealAdmissionResult::Merged)
             && let Some(target) = mrf_notice_target
         {
@@ -1545,12 +1473,8 @@ impl HealManager {
         drop(queue);
         drop(active_heals);
 
-        if let (Some(displaced_task_id), Some(displaced_terminal)) = (displaced_task_id, displaced_terminal) {
-            // The queue has already removed the displaced request, so the
-            // synchronous terminal sidecar was published before aliases and
-            // MRF ownership are cleaned up.
-            remove_displaced_task_aliases(&self.task_aliases, &self.displaced_terminals, &displaced_task_id, &displaced_terminal)
-                .await;
+        if let Some(displaced_task_id) = displaced_task_id {
+            self.remove_aliases_for_task(&displaced_task_id).await;
         }
 
         if should_notify {
@@ -1625,15 +1549,6 @@ impl HealManager {
             }
         }
 
-        if terminal_completed.is_none() {
-            let mut displaced_terminals = lock_displaced_terminals(&self.displaced_terminals);
-            prune_completed_heal_statuses(&mut displaced_terminals);
-            terminal_completed = displaced_terminals
-                .get(canonical_task_id)
-                .filter(|terminal| matches_path(&terminal.heal_type))
-                .cloned();
-        }
-
         match terminal_completed {
             Some(completed) => TaskStateLookup::Completed(completed),
             None => TaskStateLookup::NotFound,
@@ -1754,19 +1669,9 @@ impl HealManager {
 
         let mut completed_heals = self.completed_heals.lock().await;
         prune_completed_heal_statuses(&mut completed_heals);
-        if completed_heals
+        completed_heals
             .values()
             .any(|completed| heal_type_matches_path(&completed.heal_type, heal_path))
-        {
-            return true;
-        }
-        drop(completed_heals);
-
-        let mut displaced_terminals = lock_displaced_terminals(&self.displaced_terminals);
-        prune_completed_heal_statuses(&mut displaced_terminals);
-        displaced_terminals
-            .values()
-            .any(|terminal| heal_type_matches_path(&terminal.heal_type, heal_path))
     }
 
     /// Get task progress

crates/heal/src/heal/manager/auto_scan.rs

@@ -21,7 +21,6 @@ impl HealManager {
         let heal_queue = self.heal_queue.clone();
         let active_heals = self.active_heals.clone();
         let task_aliases = self.task_aliases.clone();
-        let displaced_terminals = self.displaced_terminals.clone();
         let mrf_repair_notice_targets = self.mrf_repair_notice_targets.clone();
         let storage = self.storage.clone();
         let replacement_recovery_anchors = self.replacement_recovery_anchors.clone();
@@ -482,10 +481,6 @@ impl HealManager {
                             let admission = admission_decision.result;
                             let should_notify =
                                 matches!(admission, HealAdmissionResult::Accepted) && config.event_driven_scheduler_enable;
-                            let displaced_terminal = admission_decision
-                                .displaced_request
-                                .as_ref()
-                                .map(|request| record_displaced_terminal(&displaced_terminals, request));
                             if matches!(admission, HealAdmissionResult::Accepted)
                                 && let Some(anchor) = recovery_anchor
                             {
@@ -496,16 +491,8 @@ impl HealManager {
                             }
                             drop(queue);
                             drop(config);
-                            if let (Some(displaced_task_id), Some(displaced_terminal)) =
-                                (admission_decision.displaced_task_id().map(ToOwned::to_owned), displaced_terminal)
-                            {
-                                remove_displaced_task_aliases(
-                                    &task_aliases,
-                                    &displaced_terminals,
-                                    &displaced_task_id,
-                                    &displaced_terminal,
-                                )
-                                .await;
+                            if let Some(displaced_task_id) = admission_decision.displaced_task_id {
+                                remove_task_aliases_for_task(&task_aliases, &displaced_task_id).await;
                                 lock_mrf_repair_notice_targets(&mrf_repair_notice_targets).remove(&displaced_task_id);
                             }
                             if matches!(admission, HealAdmissionResult::Accepted) {

crates/heal/src/heal/manager/scheduler.rs

@@ -21,7 +21,6 @@ impl HealManager {
         let heal_queue = self.heal_queue.clone();
         let active_heals = self.active_heals.clone();
         let completed_heals = self.completed_heals.clone();
-        let displaced_terminals = self.displaced_terminals.clone();
         let task_aliases = self.task_aliases.clone();
         let retrying_heals = self.retrying_heals.clone();
         let mrf_repair_notice_targets = self.mrf_repair_notice_targets.clone();
@@ -54,7 +53,6 @@ impl HealManager {
                             heal_queue: &heal_queue,
                             active_heals: &active_heals,
                             completed_heals: &completed_heals,
-                            displaced_terminals: &displaced_terminals,
                             task_aliases: &task_aliases,
                             retrying_heals: &retrying_heals,
                             mrf_repair_notice_targets: &mrf_repair_notice_targets,
@@ -73,7 +71,6 @@ impl HealManager {
                             heal_queue: &heal_queue,
                             active_heals: &active_heals,
                             completed_heals: &completed_heals,
-                            displaced_terminals: &displaced_terminals,
                             task_aliases: &task_aliases,
                             retrying_heals: &retrying_heals,
                             mrf_repair_notice_targets: &mrf_repair_notice_targets,
@@ -101,7 +98,6 @@ impl HealManager {
             heal_queue,
             active_heals,
             completed_heals,
-            displaced_terminals,
             task_aliases,
             retrying_heals,
             mrf_repair_notice_targets,
@@ -187,7 +183,6 @@ impl HealManager {
                 let active_heals_clone = active_heals.clone();
                 let heal_queue_clone = heal_queue.clone();
                 let completed_heals_clone = completed_heals.clone();
-                let displaced_terminals_clone = displaced_terminals.clone();
                 let task_aliases_clone = task_aliases.clone();
                 let retrying_heals_clone = retrying_heals.clone();
                 let mrf_repair_notice_targets_clone = mrf_repair_notice_targets.clone();
@@ -368,7 +363,6 @@ impl HealManager {
                         let retry_heal_queue = heal_queue_clone.clone();
                         let retrying_heals_for_spawn = retrying_heals_clone.clone();
                         let retry_task_aliases = task_aliases_clone.clone();
-                        let retry_displaced_terminals = displaced_terminals_clone.clone();
                         let retry_mrf_repair_notice_targets = mrf_repair_notice_targets_clone.clone();
                         let retry_completed_heals = completed_heals_clone.clone();
                         let retry_notify = notify_clone.clone();
@@ -436,14 +430,6 @@ impl HealManager {
                                 let admission = admission_decision.result;
                                 let should_notify = matches!(admission, HealAdmissionResult::Accepted)
                                     && retry_config.event_driven_scheduler_enable;
-                                // Publish the terminal synchronously while the
-                                // queue transition is protected. The subsequent
-                                // queue -> retrying handoff retains the lock order
-                                // used by operations_snapshot.
-                                let displaced_terminal = admission_decision
-                                    .displaced_request
-                                    .as_ref()
-                                    .map(|request| record_displaced_terminal(&retry_displaced_terminals, request));
                                 match admission {
                                     HealAdmissionResult::Accepted => {
                                         // Transfer ownership while holding queue -> retrying,
@@ -451,18 +437,10 @@ impl HealManager {
                                         #[cfg(test)]
                                         pause_retry_ownership_transition(&retry_request_id, true).await;
                                         retrying_heals_for_spawn.lock().await.remove(&retry_request_id);
-                                        let displaced_task_id = admission_decision.displaced_task_id().map(ToOwned::to_owned);
+                                        let displaced_task_id = admission_decision.displaced_task_id;
                                         drop(queue);
-                                        if let (Some(displaced_task_id), Some(displaced_terminal)) =
-                                            (displaced_task_id, displaced_terminal)
-                                        {
-                                            remove_displaced_task_aliases(
-                                                &retry_task_aliases,
-                                                &retry_displaced_terminals,
-                                                &displaced_task_id,
-                                                &displaced_terminal,
-                                            )
-                                            .await;
+                                        if let Some(displaced_task_id) = displaced_task_id {
+                                            remove_task_aliases_for_task(&retry_task_aliases, &displaced_task_id).await;
                                             remove_mrf_repair_notice_targets(
                                                 &retry_mrf_repair_notice_targets,
                                                 &displaced_task_id,

crates/heal/src/heal/manager/tests.rs

@@ -84,7 +84,6 @@ async fn process_manager_queue_once(manager: &HealManager) {
         heal_queue: &manager.heal_queue,
         active_heals: &manager.active_heals,
         completed_heals: &manager.completed_heals,
-        displaced_terminals: &manager.displaced_terminals,
         task_aliases: &manager.task_aliases,
         retrying_heals: &manager.retrying_heals,
         mrf_repair_notice_targets: &manager.mrf_repair_notice_targets,
@@ -2779,10 +2778,7 @@ async fn test_high_priority_request_displaces_lower_priority_when_queue_full() {
         HealAdmissionResult::Accepted
     );
     assert_eq!(manager.get_queue_length().await, 1);
-    assert!(matches!(
-        manager.get_task_status(&low_id).await,
-        Ok(HealTaskStatus::Failed { error }) if error.contains("reason=displaced")
-    ));
+    assert!(matches!(manager.get_task_status(&low_id).await, Err(Error::TaskNotFound { .. })));
     assert_eq!(
         manager
             .get_task_status(&high_id)
@@ -2792,263 +2788,6 @@ async fn test_high_priority_request_displaces_lower_priority_when_queue_full() {
     );
 }
 
-#[tokio::test]
-async fn displaced_task_remains_queryable() {
-    let manager = HealManager::new(
-        Arc::new(MockStorage),
-        Some(HealConfig {
-            queue_size: 1,
-            ..HealConfig::default()
-        }),
-    );
-    let mut displaced = HealRequest::new(
-        HealType::Bucket {
-            bucket: "displaced-bucket".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    displaced.id = "displaced-task".to_string();
-    let displaced_id = displaced.id.clone();
-    manager
-        .submit_heal_request(displaced)
-        .await
-        .expect("displaced request should queue");
-
-    let successor = HealRequest::new(
-        HealType::Bucket {
-            bucket: "successor-bucket".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::High,
-    );
-    manager
-        .submit_heal_request(successor)
-        .await
-        .expect("successor should displace low work");
-
-    let report = manager
-        .get_task_report(&displaced_id)
-        .await
-        .expect("displaced report should remain queryable");
-    assert!(matches!(report.status, HealTaskStatus::Failed { ref error } if error.contains("reason=displaced")));
-}
-
-#[tokio::test]
-async fn displaced_archive_failure_keeps_queryable_terminal() {
-    let manager = HealManager::new(Arc::new(MockStorage), None);
-    let mut request = HealRequest::new(
-        HealType::Bucket {
-            bucket: "archive-failure".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    request.id = "archive-failure-task".to_string();
-    let request_id = request.id.clone();
-    // The synchronous sidecar is the authoritative fallback when the normal
-    // completed-task archive has no entry (the failure window that must not
-    // turn an Accepted ID into NotFound).
-    record_displaced_terminal(&manager.displaced_terminals, &request);
-    assert!(manager.completed_heals.lock().await.is_empty());
-    assert!(matches!(
-        manager.get_task_status(&request_id).await,
-        Ok(HealTaskStatus::Failed { error }) if error.contains("reason=displaced")
-    ));
-}
-
-#[tokio::test]
-async fn scheduler_retry_displacement_keeps_evicted_task_queryable() {
-    let manager = Arc::new(HealManager::new(
-        Arc::new(MockStorage),
-        Some(HealConfig {
-            queue_size: 1,
-            event_driven_scheduler_enable: false,
-            ..HealConfig::default()
-        }),
-    ));
-    let mut retry_request = HealRequest::object("retry-transition".to_string(), "object".to_string(), None);
-    retry_request.priority = HealPriority::High;
-    let retry_id = retry_request.id.clone();
-    manager
-        .submit_heal_request(retry_request)
-        .await
-        .expect("retry request should queue");
-
-    // Process exactly one queue cycle so the retry task is spawned without a
-    // background scheduler consuming the filler request before the retry wakes.
-    process_manager_queue_once(&manager).await;
-    tokio::time::timeout(Duration::from_secs(1), async {
-        loop {
-            if manager.retrying_heals.lock().await.contains_key(&retry_id) {
-                break;
-            }
-            tokio::task::yield_now().await;
-        }
-    })
-    .await
-    .expect("retry request should enter backoff");
-
-    let filler = HealRequest::new(
-        HealType::Bucket {
-            bucket: "retry-displaced-filler".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    let filler_id = filler.id.clone();
-    manager
-        .submit_heal_request(filler)
-        .await
-        .expect("filler request should occupy the queue");
-
-    tokio::time::timeout(Duration::from_secs(5), async {
-        loop {
-            if matches!(
-                manager.get_task_status(&filler_id).await,
-                Ok(HealTaskStatus::Failed { ref error }) if error.contains("reason=displaced")
-            ) {
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .expect("retry admission should displace the filler request");
-    assert_eq!(manager.get_queue_length().await, 1);
-    assert_eq!(
-        manager.get_task_status(&retry_id).await.expect("retry should be queued"),
-        HealTaskStatus::Pending
-    );
-}
-
-#[tokio::test]
-async fn concurrent_displacers_produce_one_terminal_generation() {
-    let manager = Arc::new(HealManager::new(
-        Arc::new(MockStorage),
-        Some(HealConfig {
-            queue_size: 1,
-            ..HealConfig::default()
-        }),
-    ));
-    let mut displaced = HealRequest::new(
-        HealType::Bucket {
-            bucket: "concurrent-displaced".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    displaced.id = "concurrent-displaced-task".to_string();
-    let displaced_id = displaced.id.clone();
-    manager
-        .submit_heal_request(displaced)
-        .await
-        .expect("initial request should queue");
-
-    let first = HealRequest::new(
-        HealType::Bucket {
-            bucket: "concurrent-successor-a".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::High,
-    );
-    let second = HealRequest::new(
-        HealType::Bucket {
-            bucket: "concurrent-successor-b".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::High,
-    );
-    let (first_result, second_result) = tokio::join!(manager.submit_heal_request(first), manager.submit_heal_request(second));
-    let accepted = [&first_result, &second_result]
-        .into_iter()
-        .filter(|result| matches!(result, Ok(HealAdmissionResult::Accepted)))
-        .count();
-    assert_eq!(accepted, 1, "exactly one concurrent displacer should win the full queue");
-    assert!(
-        first_result.is_ok() && second_result.is_ok(),
-        "the losing request should receive a typed Full result"
-    );
-    let terminals = lock_displaced_terminals(&manager.displaced_terminals);
-    assert_eq!(terminals.len(), 1);
-    assert!(terminals.contains_key(&displaced_id));
-}
-
-#[tokio::test]
-async fn successor_chain_is_bounded_and_authorized() {
-    let manager = HealManager::new(
-        Arc::new(MockStorage),
-        Some(HealConfig {
-            queue_size: 1,
-            ..HealConfig::default()
-        }),
-    );
-    let mut original = HealRequest::new(
-        HealType::Bucket {
-            bucket: "authorized-original".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    original.id = "authorized-original-task".to_string();
-    let original_id = original.id.clone();
-    manager.submit_heal_request(original).await.expect("original should queue");
-    let mut duplicate = HealRequest::new(
-        HealType::Bucket {
-            bucket: "authorized-original".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    duplicate.id = "authorized-duplicate-task".to_string();
-    let duplicate_id = duplicate.id.clone();
-    manager
-        .submit_heal_request(duplicate)
-        .await
-        .expect("same-target duplicate should merge");
-    let successor = HealRequest::new(
-        HealType::Bucket {
-            bucket: "authorized-successor".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::High,
-    );
-    let successor_id = successor.id.clone();
-    manager.submit_heal_request(successor).await.expect("successor should queue");
-    assert!(manager.task_aliases.lock().await.is_empty());
-    assert!(matches!(manager.get_task_status(&original_id).await, Ok(HealTaskStatus::Failed { .. })));
-    assert!(matches!(manager.get_task_status(&duplicate_id).await, Ok(HealTaskStatus::Failed { .. })));
-    assert_eq!(
-        manager
-            .get_task_status(&successor_id)
-            .await
-            .expect("successor should remain queued"),
-        HealTaskStatus::Pending
-    );
-}
-
-#[tokio::test]
-async fn displaced_terminal_expires_after_bounded_ttl() {
-    let manager = HealManager::new(Arc::new(MockStorage), None);
-    let mut request = HealRequest::new(
-        HealType::Bucket {
-            bucket: "expires".to_string(),
-        },
-        HealOptions::default(),
-        HealPriority::Low,
-    );
-    request.id = "expires-task".to_string();
-    let request_id = request.id.clone();
-    record_displaced_terminal(&manager.displaced_terminals, &request);
-    {
-        let mut terminals = lock_displaced_terminals(&manager.displaced_terminals);
-        let entry =
-            Arc::get_mut(terminals.get_mut(&request_id).expect("terminal should be retained")).expect("test owns terminal entry");
-        entry.completed_at = SystemTime::now() - KEEP_HEAL_TASK_STATUS_DURATION - Duration::from_secs(1);
-    }
-    assert!(matches!(manager.get_task_status(&request_id).await, Err(Error::TaskNotFound { .. })));
-}
-
 #[tokio::test]
 async fn test_displacing_registered_mrf_task_drops_notice_ownership() {
     let storage: Arc<dyn HealStorageAPI> = Arc::new(MockStorage);

crates/protos/src/generated/proto_gen/node_service.rs

@@ -722,10 +722,6 @@ pub struct DeleteVersionsResponse {
     pub errors: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
     #[prost(message, optional, tag = "3")]
     pub error: ::core::option::Option<Error>,
-    /// Senders dual-write the legacy strings and typed entries. Receivers prefer typed entries
-    /// when present and fall back to strings for peers that predate this field. Code zero means success.
-    #[prost(message, repeated, tag = "4")]
-    pub item_errors: ::prost::alloc::vec::Vec<Error>,
 }
 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct ReadMultipleRequest {

crates/protos/src/node.proto

@@ -493,9 +493,6 @@ message DeleteVersionsResponse {
   bool success = 1;
   repeated string errors = 2;
   optional Error error = 3;
-  // Senders dual-write the legacy strings and typed entries. Receivers prefer typed entries
-  // when present and fall back to strings for peers that predate this field. Code zero means success.
-  repeated Error item_errors = 4;
 }
 
 message ReadMultipleRequest {

crates/scanner/src/scanner_folder.rs

@@ -43,7 +43,7 @@ use rustfs_common::metrics::{
     UpdateCurrentPathFn, current_path_updater, global_metrics,
 };
 use rustfs_common::trace_bus::{TraceEvent, TraceFunc, TraceKind, trace_emit, trace_subscriber_count};
-use rustfs_filemeta::{MAX_META_CACHE_HEAL_CANDIDATES, MetaCacheEntries, MetaCacheEntry, MetaCacheHealCandidateKind};
+use rustfs_filemeta::{MetaCacheEntries, MetaCacheEntry, MetadataResolutionParams};
 use rustfs_utils::path::{SLASH_SEPARATOR, path_join_buf};
 use s3s::dto::{BucketLifecycleConfiguration, ObjectLockConfiguration, VersioningConfiguration};
 use time::OffsetDateTime;
@@ -96,10 +96,6 @@ const METRIC_SCANNER_EXCESS_OBJECT_VERSION_SIZE_TOTAL: &str = "rustfs_scanner_ex
 const METRIC_SCANNER_EXCESS_FOLDERS_TOTAL: &str = "rustfs_scanner_excess_folders_total";
 const METRIC_SCANNER_PENDING_HEAL_PRUNE_TOTAL: &str = "rustfs_scanner_pending_heal_prune_total";
 const METRIC_SCANNER_PENDING_HEAL_MALFORMED_TOTAL: &str = "rustfs_scanner_pending_heal_malformed_total";
-const METRIC_SCANNER_HEAL_DISCOVERY_CANDIDATES_TOTAL: &str = "rustfs_scanner_heal_discovery_candidates_total";
-const METRIC_SCANNER_HEAL_DISCOVERY_SUB_QUORUM_TOTAL: &str = "rustfs_scanner_heal_discovery_sub_quorum_total";
-const METRIC_SCANNER_HEAL_DISCOVERY_UNVERIFIED_TOTAL: &str = "rustfs_scanner_heal_discovery_unverified_total";
-const METRIC_SCANNER_HEAL_DISCOVERY_QUEUED_TOTAL: &str = "rustfs_scanner_heal_discovery_queued_total";
 const MAX_PENDING_SCANNER_HEAL_RETRIES_PER_BUCKET: usize = 128;
 
 // --- scanner excess alerts as S3 notification events (rustfs/backlog#1868) --
@@ -887,7 +883,7 @@ impl FolderScanner {
         object: Option<String>,
         version_id: Option<String>,
         request: HealChannelRequest,
-    ) -> Result<HealAdmissionResult, ScannerError> {
+    ) -> Result<(), ScannerError> {
         let candidate_type = pending_scanner_heal_candidate_type(kind);
         let priority = request.priority;
         let scan_mode = request.scan_mode.unwrap_or(self.scan_mode);
@@ -915,7 +911,7 @@ impl FolderScanner {
                     error = %err,
                     "Scanner deferred heal request after channel error"
                 );
-                return Ok(HealAdmissionResult::Full);
+                return Ok(());
             }
         };
         self.update_pending_scanner_heal_after_admission(
@@ -927,7 +923,7 @@ impl FolderScanner {
             result,
         );
         if result.is_admitted() {
-            return Ok(result);
+            return Ok(());
         }
 
         record_high_priority_heal_escalation(candidate_type, priority, result);
@@ -948,7 +944,7 @@ impl FolderScanner {
             state = "high_priority_not_admitted",
             "Scanner high-priority heal admission failed"
         );
-        Ok(result)
+        Ok(())
     }
 
     pub fn set_heal_object_select(&mut self, prob: u32) {
@@ -1740,7 +1736,14 @@ impl FolderScanner {
                 break;
             }
 
-            let mut previous_bucket = String::new();
+            let mut resolver = MetadataResolutionParams {
+                dir_quorum: self.disks_quorum,
+                obj_quorum: self.disks_quorum,
+                bucket: "".to_string(),
+                strict: false,
+                ..Default::default()
+            };
+
             for name in abandoned_children {
                 if !self.should_heal().await {
                     break;
@@ -1748,7 +1751,7 @@ impl FolderScanner {
 
                 let (bucket, prefix) = path2_bucket_object(name.as_str());
 
-                if bucket != previous_bucket {
+                if bucket != resolver.bucket {
                     self.send_required_scanner_heal_request(
                         PendingScannerHealKind::Bucket,
                         bucket.clone(),
@@ -1757,9 +1760,10 @@ impl FolderScanner {
                         build_bucket_heal_request(bucket.clone(), HealChannelPriority::High),
                     )
                     .await?;
-                    previous_bucket = bucket.clone();
                 }
 
+                resolver.bucket = bucket.clone();
+
                 let child_ctx = ctx.child_token();
 
                 let (agreed_tx, mut agreed_rx) = mpsc::channel::<String>(1);
@@ -1876,7 +1880,6 @@ impl FolderScanner {
                 let mut agreed_closed = false;
                 let mut partial_closed = false;
                 let mut finished_closed = false;
-                let mut seen_heal_candidates: HashSet<(String, Option<String>, MetaCacheHealCandidateKind)> = HashSet::new();
 
                 loop {
                     if agreed_closed && partial_closed && finished_closed {
@@ -1901,56 +1904,65 @@ impl FolderScanner {
                                 break;
                             }
 
-                            let discovery = entries.discover_heal_candidates(&bucket, MAX_META_CACHE_HEAL_CANDIDATES);
-                            counter!(METRIC_SCANNER_HEAL_DISCOVERY_CANDIDATES_TOTAL)
-                                .increment(u64::try_from(discovery.candidates.len()).unwrap_or(u64::MAX));
-                            counter!(METRIC_SCANNER_HEAL_DISCOVERY_SUB_QUORUM_TOTAL).increment(
-                                u64::try_from(
-                                    discovery
-                                        .candidates
-                                        .iter()
-                                        .filter(|candidate| candidate.replica_count < disks_quorum)
-                                        .count(),
-                                )
-                                .unwrap_or(u64::MAX),
-                            );
-                            counter!(METRIC_SCANNER_HEAL_DISCOVERY_UNVERIFIED_TOTAL).increment(
-                                u64::try_from(discovery.unverified_count).unwrap_or(u64::MAX),
-                            );
+                            let Some(entry) = resolve_object_heal_entry(&entries, resolver.clone()) else {
+                                continue;
+                            };
 
-                            for candidate in discovery.candidates {
-                                let version_id = candidate.validated_version().map(|id| id.to_string());
-                                let identity = (candidate.object.clone(), version_id.clone(), candidate.kind.clone());
-                                if seen_heal_candidates.len() >= MAX_META_CACHE_HEAL_CANDIDATES
-                                    && !seen_heal_candidates.contains(&identity)
-                                {
+                            (self.update_current_path)(&entry.name).await;
+
+                            if entry.is_dir() {
+                                continue;
+                            }
+
+                            let fivs = match entry.file_info_versions(&bucket) {
+                                Ok(fivs) => fivs,
+                                Err(e) => {
+                                    error!(
+                                        target: "rustfs::scanner::folder",
+                                        event = EVENT_SCANNER_FOLDER_STATE,
+                                        component = LOG_COMPONENT_SCANNER,
+                                        subsystem = LOG_SUBSYSTEM_FOLDER,
+                                        bucket = %bucket,
+                                        entry = %entry.name,
+                                        state = "file_info_versions_failed",
+                                        error = %e,
+                                        "Scanner list_path_raw failed to resolve file versions"
+                                    );
+                                    self.send_required_scanner_heal_request(
+                                        PendingScannerHealKind::Object,
+                                        bucket.clone(),
+                                        Some(entry.name.clone()),
+                                        None,
+                                        build_object_heal_request(
+                                            bucket.clone(),
+                                            entry.name.clone(),
+                                            None,
+                                            self.scan_mode,
+                                            HealChannelPriority::High,
+                                        ),
+                                    )
+                                    .await?;
+                                    found_objects = true;
                                     continue;
                                 }
-                                if !seen_heal_candidates.insert(identity) {
-                                    continue;
-                                }
-                                let mut request = build_object_heal_request(
-                                    bucket.clone(),
-                                    candidate.object.clone(),
-                                    version_id.clone(),
-                                    self.scan_mode,
-                                    HealChannelPriority::High,
-                                );
-                                if candidate.is_unversioned() {
-                                    request.remove_corrupted = Some(false);
-                                }
-                                (self.update_current_path)(&candidate.object).await;
-                                let admission = self.send_required_scanner_heal_request(
+                            };
+
+                            for fiv in fivs.versions {
+                                let version_id = fiv.version_id.and_then(|v| if v.is_nil() { None } else { Some(v.to_string()) });
+                                self.send_required_scanner_heal_request(
                                     PendingScannerHealKind::Object,
                                     bucket.clone(),
-                                    Some(candidate.object.clone()),
-                                    version_id,
-                                    request,
+                                    Some(entry.name.clone()),
+                                    version_id.clone(),
+                                    build_object_heal_request(
+                                        bucket.clone(),
+                                        entry.name.clone(),
+                                        version_id,
+                                        self.scan_mode,
+                                        HealChannelPriority::High,
+                                    ),
                                 )
                                 .await?;
-                                if admission.is_admitted() {
-                                    counter!(METRIC_SCANNER_HEAL_DISCOVERY_QUEUED_TOTAL).increment(1);
-                                }
                                 found_objects = true;
                             }
 

crates/scanner/src/scanner_folder/item_actions.rs

@@ -13,8 +13,6 @@
 // limitations under the License.
 /// Per-object scan actions: ScannerItem, the get-size failure policy, and the heal/ILM admission helpers.
 use super::*;
-#[cfg(test)]
-use rustfs_filemeta::MetadataResolutionParams;
 
 /// Cached folder information for scanning
 #[derive(Clone, Debug)]
@@ -90,7 +88,6 @@ pub(super) fn build_object_heal_request(
     }
 }
 
-#[cfg(test)]
 pub(super) fn resolve_object_heal_entry(
     entries: &MetaCacheEntries,
     resolver: MetadataResolutionParams,

crates/scanner/src/scanner_folder/ledger.rs

@@ -305,17 +305,13 @@ pub(super) fn build_pending_scanner_heal_request(entry: &PendingScannerHeal) ->
     match entry.kind {
         PendingScannerHealKind::Bucket => Some(build_bucket_heal_request(entry.bucket.clone(), HealChannelPriority::High)),
         PendingScannerHealKind::Object => entry.object.as_ref().map(|object| {
-            let mut request = build_object_heal_request(
+            build_object_heal_request(
                 entry.bucket.clone(),
                 object.clone(),
                 entry.version_id.clone(),
                 entry.scan_mode,
                 HealChannelPriority::High,
-            );
-            if entry.version_id.is_none() {
-                request.remove_corrupted = Some(false);
-            }
-            request
+            )
         }),
     }
 }

crates/scanner/src/scanner_folder/tests.rs

@@ -17,7 +17,7 @@ use crate::SCANNER_SLEEPER;
 use super::*;
 use crate::storage_api::VersionPurgeStatusType;
 use crate::{DiskOption, Endpoint, STORAGE_FORMAT_FILE, TierStats, new_disk, storageclass};
-use rustfs_filemeta::{FileInfo, FileMeta, MetadataResolutionParams};
+use rustfs_filemeta::{FileInfo, FileMeta};
 use std::io::Write;
 #[cfg(unix)]
 use std::os::unix::fs::{PermissionsExt, symlink};
@@ -1121,17 +1121,6 @@ fn test_pending_heal_reconstructs_object_request_with_version() {
     assert_eq!(request.source, HealRequestSource::Scanner);
 }
 
-#[test]
-fn test_pending_heal_reconstructs_unversioned_request_without_removal() {
-    let pending = pending_heal(PendingScannerHealKind::Object, "bucket", Some("object"), None, 1, 1);
-
-    let request = build_pending_scanner_heal_request(&pending).expect("unversioned object request should rebuild");
-
-    assert!(request.object_version_id.is_none());
-    assert_eq!(request.remove_corrupted, Some(false));
-    assert_eq!(request.recreate_missing, Some(false));
-}
-
 #[test]
 fn test_pending_heal_retry_candidates_respect_cap_and_order() {
     let pending: Vec<PendingScannerHeal> = (0..(MAX_PENDING_SCANNER_HEAL_RETRIES_PER_BUCKET + 2))
@@ -1334,20 +1323,6 @@ fn metadata_for_object(bucket: &str, object: &str) -> Vec<u8> {
     meta.marshal_msg().expect("test metadata should marshal")
 }
 
-fn metadata_for_object_version(bucket: &str, object: &str, version_id: Option<Uuid>) -> Vec<u8> {
-    let mut file_info = FileInfo::new(object, 4, 2);
-    file_info.volume = bucket.to_string();
-    file_info.name = object.to_string();
-    file_info.version_id = version_id;
-    file_info.versioned = version_id.is_some();
-    file_info.mod_time = Some(OffsetDateTime::now_utc());
-    file_info.size = 1;
-
-    let mut meta = FileMeta::new();
-    meta.add_version(file_info).expect("test metadata version should be accepted");
-    meta.marshal_msg().expect("test metadata should marshal")
-}
-
 async fn write_test_object_metadata(root: &std::path::Path, bucket: &str, object: &str) {
     write_test_object_metadata_bytes(root, bucket, object, &metadata_for_object(bucket, object)).await;
 }
@@ -1751,21 +1726,12 @@ async fn test_scan_folder_exits_when_abandoned_child_listing_finishes() {
     let _guard = TestGuard::new(60, 100, &mut scanner, temp_dir.clone());
     let heal_starts = Arc::new(AtomicUsize::new(0));
     let heal_starts_clone = heal_starts.clone();
-    let healed_versions = Arc::new(Mutex::new(Vec::<Option<String>>::new()));
-    let healed_versions_clone = healed_versions.clone();
     let mut heal_rx =
         rustfs_common::heal_channel::init_heal_channel().expect("heal channel should initialize once for scanner tests");
     let _heal_responder = tokio::spawn(async move {
         while let Some(command) = heal_rx.recv().await {
-            if let rustfs_common::heal_channel::HealChannelCommand::Start {
-                request, response_tx, ..
-            } = command
-            {
+            if let rustfs_common::heal_channel::HealChannelCommand::Start { response_tx, .. } = command {
                 heal_starts_clone.fetch_add(1, Ordering::Relaxed);
-                healed_versions_clone
-                    .lock()
-                    .expect("heal version capture lock should not be poisoned")
-                    .push(request.object_version_id);
                 let _ = response_tx.send(Ok(HealAdmissionResult::Accepted));
             }
         }
@@ -1773,18 +1739,13 @@ async fn test_scan_folder_exits_when_abandoned_child_listing_finishes() {
 
     let bucket = "src-archive";
     let object = "snapshots/37b3f20d941e2f5e6d99114d9bb2f3e67a8a2e5c9c4c5a1b0d6e7f8091a2b3c4";
-    let orphan_version = Uuid::from_u128(0x1934);
-    let shared_version = Uuid::from_u128(0x1935);
-    let orphan_metadata = metadata_for_object_version(bucket, object, Some(orphan_version));
-    let shared_metadata = metadata_for_object_version(bucket, object, Some(shared_version));
-    write_test_object_metadata_bytes(&temp_dir, bucket, object, &orphan_metadata).await;
-    let mut expected_metadata = vec![(temp_dir.join(bucket).join(object).join("xl.meta"), orphan_metadata.clone())];
+    let metadata = metadata_for_object(bucket, object);
+    write_test_object_metadata_bytes(&temp_dir, bucket, object, &metadata).await;
 
     let mut disks = vec![scanner.local_disk.clone()];
     for disk_name in ["disk2", "disk3", "disk4"] {
         let disk_root = temp_dir.join(disk_name);
-        write_test_object_metadata_bytes(&disk_root, bucket, object, &shared_metadata).await;
-        expected_metadata.push((disk_root.join(bucket).join(object).join("xl.meta"), shared_metadata.clone()));
+        write_test_object_metadata_bytes(&disk_root, bucket, object, &metadata).await;
         let endpoint = Endpoint::try_from(disk_root.to_string_lossy().as_ref()).expect("failed to create extra disk endpoint");
         let disk = new_disk(
             &endpoint,
@@ -1833,29 +1794,8 @@ async fn test_scan_folder_exits_when_abandoned_child_listing_finishes() {
         .new_cache
         .checked_flatten(bucket)
         .expect("healed cache must contain canonical child links");
-    // The fixture intentionally exposes two divergent version histories, so
-    // the scanner keeps both logical versions visible while discovering heals.
-    assert_eq!(root.objects, 2);
+    assert_eq!(root.objects, 1);
     assert!(heal_starts.load(Ordering::Relaxed) > 0, "test must execute the heal child-link path");
-    let orphan_version_text = orphan_version.to_string();
-    assert!(
-        healed_versions
-            .lock()
-            .expect("heal version capture lock should not be poisoned")
-            .iter()
-            .any(|version| version.as_deref() == Some(orphan_version_text.as_str())),
-        "sub-quorum orphan version must be submitted as an exact heal candidate"
-    );
-    for (path, expected) in expected_metadata {
-        assert_eq!(
-            tokio::fs::read(&path)
-                .await
-                .expect("scanner discovery must not delete metadata"),
-            expected,
-            "scanner discovery must not modify candidate metadata: {}",
-            path.display()
-        );
-    }
 }
 
 #[tokio::test]

rustfs/src/app/bucket_usecase.rs

@@ -513,13 +513,15 @@ fn sr_bucket_meta_item(bucket: String, item_type: &str) -> SRBucketMeta {
     }
 }
 
-fn notify_bucket_metadata_reload(
+async fn notify_bucket_metadata_reload(
     bucket: String,
     operation: &'static str,
     request_context: Option<request_context::RequestContext>,
     scanner_maintenance_change: bool,
 ) {
     record_local_scanner_maintenance_reload(&bucket, scanner_maintenance_change);
+    // Keep reload detached across request cancellation, but wait before a healthy peer can serve the previous config.
+    let (completed_tx, completed_rx) = tokio::sync::oneshot::channel();
     spawn_background_with_context(request_context, async move {
         if let Some(notification_sys) = current_notification_system() {
             let result = if scanner_maintenance_change {
@@ -531,7 +533,9 @@ fn notify_bucket_metadata_reload(
                 warn!(bucket = %bucket, error = %err, "failed to notify peers after {operation}");
             }
         }
+        let _ = completed_tx.send(());
     });
+    let _ = completed_rx.await;
 }
 
 fn record_local_scanner_maintenance_reload(bucket: &str, scanner_maintenance_change: bool) {
@@ -1476,7 +1480,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete bucket encryption", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "delete bucket encryption", request_context, false).await;
 
         let item = sr_bucket_meta_item(bucket.clone(), "sse-config");
         if let Err(err) = site_replication_bucket_meta_hook(item).await {
@@ -1508,7 +1512,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete bucket cors", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "delete bucket cors", request_context, false).await;
 
         let item = sr_bucket_meta_item(bucket.clone(), "cors-config");
         if let Err(err) = site_replication_bucket_meta_hook(item).await {
@@ -1540,7 +1544,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete bucket lifecycle", request_context, true);
+        notify_bucket_metadata_reload(bucket.clone(), "delete bucket lifecycle", request_context, true).await;
 
         let item = sr_bucket_meta_item(bucket.clone(), "lc-config");
         if let Err(err) = site_replication_bucket_meta_hook(item).await {
@@ -1572,7 +1576,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete bucket policy", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "delete bucket policy", request_context, false).await;
 
         let item = sr_bucket_meta_item(bucket.clone(), "policy");
         if let Err(err) = site_replication_bucket_meta_hook(item).await {
@@ -1630,7 +1634,7 @@ impl DefaultBucketUsecase {
         }
         drop(targets_guard);
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete bucket replication", request_context, true);
+        notify_bucket_metadata_reload(bucket.clone(), "delete bucket replication", request_context, true).await;
 
         let item = sr_bucket_meta_item(bucket.clone(), "replication-config");
         if let Err(err) = site_replication_bucket_meta_hook(item).await {
@@ -1655,7 +1659,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete bucket tagging", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "delete bucket tagging", request_context, false).await;
 
         let item = sr_bucket_meta_item(bucket.clone(), "tags");
         if let Err(err) = site_replication_bucket_meta_hook(item).await {
@@ -1688,7 +1692,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "delete public access block", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "delete public access block", request_context, false).await;
 
         Ok(S3Response::with_status(DeletePublicAccessBlockOutput::default(), StatusCode::NO_CONTENT))
     }
@@ -2143,7 +2147,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket encryption", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket encryption", request_context, false).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "sse-config");
         item.sse_config = Some(
@@ -2222,7 +2226,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket lifecycle", request_context, true);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket lifecycle", request_context, true).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "lc-config");
         item.expiry_lc_config =
@@ -2307,7 +2311,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket notification", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket notification", request_context, false).await;
 
         let region = resolve_notification_region(self.global_region(), request_region);
         let notify = current_notify_interface_for_context(self.context.as_deref());
@@ -2412,7 +2416,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket policy", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket policy", request_context, false).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "policy");
         item.policy = Some(serde_json::from_str(&policy).map_err(|e| s3_error!(InvalidArgument, "parse policy failed {:?}", e))?);
@@ -2447,7 +2451,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket cors", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket cors", request_context, false).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "cors-config");
         item.cors =
@@ -2491,7 +2495,7 @@ impl DefaultBucketUsecase {
             .map_err(ApiError::from)?;
         drop(targets_guard);
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket replication", request_context, true);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket replication", request_context, true).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "replication-config");
         item.replication_config = Some(
@@ -2531,7 +2535,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put public access block", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put public access block", request_context, false).await;
 
         Ok(S3Response::new(PutPublicAccessBlockOutput::default()))
     }
@@ -2560,7 +2564,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket tagging", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket tagging", request_context, false).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "tags");
         item.tags = Some(serialize_config(&tagging).and_then(|bytes| String::from_utf8(bytes).map_err(to_internal_error))?);
@@ -2593,7 +2597,7 @@ impl DefaultBucketUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        notify_bucket_metadata_reload(bucket.clone(), "put bucket versioning", request_context, false);
+        notify_bucket_metadata_reload(bucket.clone(), "put bucket versioning", request_context, false).await;
 
         let mut item = sr_bucket_meta_item(bucket.clone(), "version-config");
         item.versioning = Some(
@@ -3044,7 +3048,7 @@ mod tests {
                 "{method} should identify the bucket metadata operation in reload logs"
             );
             let expected_reload = format!(
-                "notify_bucket_metadata_reload(bucket.clone(), \"{operation}\", request_context, {scanner_maintenance_change});"
+                "notify_bucket_metadata_reload(bucket.clone(), \"{operation}\", request_context, {scanner_maintenance_change}).await;"
             );
             assert!(
                 body.contains(&expected_reload),

rustfs/src/storage/rpc/node_service/disk.rs

@@ -146,29 +146,6 @@ fn encode_file_info_msgpack(value: &FileInfo) -> std::result::Result<Vec<u8>, Di
     encode_msgpack_with_capacity(value, "FileInfo", FILE_INFO_MSGPACK_ENCODE_CAPACITY_HINT)
 }
 
-fn encode_delete_versions_errors(disk_errors: Vec<Option<DiskError>>) -> (Vec<String>, Vec<Error>) {
-    let mut errors = Vec::with_capacity(disk_errors.len());
-    let mut item_errors = Vec::with_capacity(disk_errors.len());
-    for error in disk_errors {
-        match error {
-            Some(error) => {
-                let code = match &error {
-                    DiskError::Io(source) if source.kind() == std::io::ErrorKind::NotFound => DiskError::FileNotFound.to_u32(),
-                    _ => error.to_u32(),
-                };
-                let error_info = error.to_string();
-                errors.push(error_info.clone());
-                item_errors.push(Error { code, error_info });
-            }
-            None => {
-                errors.push(String::new());
-                item_errors.push(Error::default());
-            }
-        }
-    }
-    (errors, item_errors)
-}
-
 fn encode_msgpack_named<T: serde::Serialize>(value: &T, value_name: &str) -> std::result::Result<Vec<u8>, DiskError> {
     let mut serializer = rmp_serde::Serializer::new(Vec::with_capacity(MSGPACK_ENCODE_CAPACITY_HINT)).with_struct_map();
     value
@@ -575,7 +552,6 @@ impl NodeService {
                             success: false,
                             errors: Vec::new(),
                             error: Some(DiskError::other(format!("decode FileInfoVersions failed: {err}")).into()),
-                            item_errors: Vec::new(),
                         }));
                     }
                 };
@@ -587,26 +563,30 @@ impl NodeService {
                         success: false,
                         errors: Vec::new(),
                         error: Some(DiskError::other(format!("decode DeleteOptions failed: {err}")).into()),
-                        item_errors: Vec::new(),
                     }));
                 }
             };
 
-            let (errors, item_errors) =
-                encode_delete_versions_errors(disk.delete_versions(&request.volume, versions, opts).await);
+            let errors = disk
+                .delete_versions(&request.volume, versions, opts)
+                .await
+                .into_iter()
+                .map(|error| match error {
+                    Some(e) => e.to_string(),
+                    None => "".to_string(),
+                })
+                .collect();
 
             Ok(Response::new(DeleteVersionsResponse {
                 success: true,
                 errors,
                 error: None,
-                item_errors,
             }))
         } else {
             Ok(Response::new(DeleteVersionsResponse {
                 success: false,
                 errors: Vec::new(),
                 error: Some(DiskError::other("cannot find disk".to_string()).into()),
-                item_errors: Vec::new(),
             }))
         }
     }
@@ -1632,8 +1612,8 @@ impl NodeService {
 mod tests {
     use super::{
         compat_response_json, decode_msgpack_or_json, decode_rename_data_request_file_info,
-        encode_batch_read_version_response_payloads, encode_delete_versions_errors, encode_file_info_msgpack, encode_msgpack,
-        encode_msgpack_named, encode_read_multiple_response_payloads, encode_rename_data_response_payloads,
+        encode_batch_read_version_response_payloads, encode_file_info_msgpack, encode_msgpack, encode_msgpack_named,
+        encode_read_multiple_response_payloads, encode_rename_data_response_payloads,
     };
     use crate::storage::rpc::node_service::make_server;
     use crate::storage::storage_api::ReadMultipleResp;
@@ -1652,18 +1632,6 @@ mod tests {
         count: u32,
     }
 
-    #[test]
-    fn delete_versions_response_dual_writes_typed_item_errors() {
-        let raw_not_found = super::DiskError::Io(std::io::Error::from(std::io::ErrorKind::NotFound));
-        let (errors, item_errors) = encode_delete_versions_errors(vec![Some(raw_not_found), None]);
-
-        assert!(errors[0].starts_with("io error "));
-        assert!(errors[1].is_empty());
-        assert_eq!(item_errors[0].code, super::DiskError::FileNotFound.to_u32());
-        assert_eq!(item_errors[0].error_info, errors[0]);
-        assert_eq!(item_errors[1].code, 0);
-    }
-
     #[tokio::test]
     #[serial]
     async fn handle_read_version_records_attribution_for_missing_disk() {