fix(data-usage): make empty checks exhaustive

fix(data-usage): preserve nonempty replication stats
2026-08-01 11:02:14 +00:00 · 2026-07-29 16:11:42 +08:00 · 2026-07-29 15:17:50 +08:00
410 changed files with 7577 additions and 58713 deletions
@@ -10,16 +10,10 @@ never weaken a check to get green.

 ## `check_layer_dependencies.sh` — layer DAG in `rustfs/src`

-Enforces `composition (server, startup/init) → interface (admin,
-storage/ecfs, storage/s3_api) → app → infra`; no upward imports. Server source
-files are composition roots, while imports of their exported HTTP contracts
-are classified as interface dependencies. Known legacy violations live in
+Enforces `interface (admin, storage/ecfs, storage/s3_api) → app → infra`; no
+upward imports. Known legacy violations live in
 `scripts/layer-dependency-baseline.txt`.

-Dedicated `*_test.rs` and `tests/` modules are outside this production guard.
-Inline `#[cfg(test)]` imports remain checked under their source file's layer;
-move architecture-crossing test scaffolding into a dedicated test module.
-
 - **New violation**: restructure your change so the dependency points
  downward (move the shared type/function to the lower layer).
 - **You legitimately removed a baseline entry**: run
@@ -1,21 +1,19 @@
 ---
 name: rustfs-release-publish
-description: "End-to-end RustFS release pipeline: first publish any merged-but-unreleased rustfs/console changes and wait for its latest Release asset, then bump RustFS version files on main directly to the final target, publish a visible GitHub prerelease from a preview tag without updating latest channels, validate it, and publish the final tag on the SAME commit. Use whenever the user wants to release/publish a RustFS version (发版/发布)."
+description: "End-to-end RustFS release pipeline: bump version files on main directly to the final target version, cut a preview tag on that commit, verify the CI build and release artifacts, run the downloaded binary locally and exercise the console, validate the server with the latest rc client, then publish the final tag on the SAME validated commit — never a new bump commit, never latest main. Use whenever the user wants to release/publish a RustFS version (发版/发布)."
 ---
 # RustFS Release Publish (preview-validated pipeline)

 This skill orchestrates a full release. It wraps `rustfs-release-version-bump` (which only edits version files and opens the PR) with a mandatory preview-tag validation loop before the final tag is published.

-Core design: **version files never carry a `-preview.N` suffix**. The preview suffix exists only in tag names. A preview tag creates a visible GitHub Release marked Prerelease and uploads versioned assets, but it never becomes GitHub Latest and never updates `*-latest`, `latest.json`, R2, Docker, or Helm channels. This works because the binary self-reports the git tag it was built from (`build::TAG` via shadow_rs, see `rustfs/src/config/cli.rs` `SHORT_VERSION`), and `build.yml` derives artifact names and preview classification from the tag name — Cargo.toml's version is only a no-tag fallback. Therefore the preview tag and the final tag can (and MUST) point at the exact same commit: what you validated is byte-for-byte the source that ships.
+Core design: **version files never carry a `-preview.N` suffix**. The preview suffix exists only in tag names. This works because the binary self-reports the git tag it was built from (`build::TAG` via shadow_rs, see `rustfs/src/config/cli.rs` `SHORT_VERSION`), and `build.yml` derives artifact names and prerelease classification from the tag name — Cargo.toml's version is only a no-tag fallback. Therefore the preview tag and the final tag can (and MUST) point at the exact same commit: what you validated is byte-for-byte the source that ships.

 Pipeline shape:

 ```
-check console main against its latest Release
-  -> if ahead: publish console -> wait for Release asset + latest API
-  -> bump RustFS version files to <target> (final version, ONE commit) -> merge
+bump version files to <target> (final version, ONE commit) -> merge
  -> tag <preview-tag> at that commit -> CI green
-  -> verify preview Release assets -> run binary locally + console checks
+  -> verify release artifacts -> run binary locally + console checks
  -> validate with latest rc client
  -> tag <target> at the SAME commit (zero delta) -> re-verify CI/release
 ```
@@ -25,7 +23,7 @@ On validation failure: fix lands on main via normal PR (version files are alread
 ## Required inputs

 - Final target version, for example `1.0.0-beta.10`.
- Preview iteration `N` (default: next unused preview tag for that target; check with `git tag -l '<target>-preview.*'` after `git fetch --tags`).
+- Preview iteration `N` (default: next unused preview tag for that target; check with `git tag -l '<target>-preview.*'` — and for stable targets `git tag -l '<target>-rc.*'` — after `git fetch --tags`).

 If the target version is missing or ambiguous, stop and ask before doing anything (see the semver gate below).

@@ -47,18 +45,14 @@ Rules:

 ## Preview tag naming

- Use `<target>-preview.N` for every target, e.g. `1.0.0-beta.10-preview.3` or `1.1.0-preview.1`.
- The canonical suffix is exactly `-preview.<digits>`. `build.yml` recognizes it before alpha/beta/rc classification and routes it to the preview-only path; any other tag containing `-preview` fails closed instead of being treated as a release.
- A preview Release MUST be published with `isPrerelease=true` and `isLatest=false`. Any `*-latest` preview asset or preview-triggered `latest.json`, R2, Docker, or Helm publication is a pipeline failure.
+- Prerelease target (contains `alpha`/`beta`/`rc`): preview tag is `<target>-preview.N`, e.g. `1.0.0-beta.10-preview.3`. It contains `beta`, so `build.yml`'s substring-based classification marks it prerelease — safe.
+- **Stable** target (e.g. `1.1.0`): NEVER tag `1.1.0-preview.N` — `build.yml` marks a tag prerelease only if its name contains `alpha`, `beta`, or `rc`, so `1.1.0-preview.N` would be treated as a stable release and overwrite `latest.json` as stable. Use `1.1.0-rc.N` as the preview tag instead.

 ## Hard rules

 - Version files (Cargo.toml, Cargo.lock, README, flake.nix, Chart.yaml, rustfs.spec) are bumped ONCE, directly to `<target>`. Never write a `-preview.N` suffix into any version file. If `rustfs-release-version-bump` is ever asked for a `-preview` version, that is a pipeline bug — stop.
- Preview Release assets are versioned and intentionally visible on the Releases page. Do not label them Latest or use them to update any latest distribution channel.
 - Tags have no `v` prefix. Always annotated: `git tag -a <tag> -m "Release <tag>"`.
 - The final tag MUST point at exactly `PREVIEW_HASH` — the commit the validated preview tag points at. Never tag current `main` HEAD (commits merged after validation are unvalidated), and never create an extra version-bump commit between preview and final.
- When a previous deliverable exists, GitHub Release notes for the preview and final tags MUST use it as their shared comparison baseline: the most recently published non-preview Release before the target. Internal `-preview.N` Releases are explicitly excluded from that selection, even when they point at the same commit as the final tag. If no previous deliverable exists, omit `previous_tag_name` and record that GitHub's default baseline fallback was used.
- Generated Release notes carry a workflow-management marker so retries can repair them. Before manually curating a generated body, remove that marker; unmarked non-placeholder notes are preserved by later workflow runs.
 - Phases run in order; a failure in any phase blocks everything after it. After the fix lands on main, restart from Phase 2 with the next preview iteration against the new `origin/main` hash — do not resume mid-pipeline against a stale hash.
 - If the release is abandoned after Phase 1 merged, main's version files claim a version that was never tagged. Either revert the bump PR or leave it to be overwritten by the next release — but tell the user explicitly and record the decision.
 - User-facing status updates in Chinese; commits, PR titles/bodies, and tag messages in English. No hard-wrapping in commit messages, PR bodies, or documentation prose — one logical line per sentence/paragraph, let soft wrap handle display.
@@ -69,61 +63,6 @@ Rules:
 - `gh auth status` works; confirm you can view `gh release list -L 3`.
 - Confirm the exact final target version with the user if not explicit.

-### Console release gate
-
-Complete this gate before changing any RustFS version file or creating any RustFS tag. RustFS `build.yml` downloads the asset returned by `repos/rustfs/console/releases/latest`, so a successful Console build alone is insufficient.
-
-1. Read the latest published Console tag and compare it with Console `main`:
-
-```bash
-CONSOLE_REPO="rustfs/console"
-CONSOLE_LATEST=$(gh api "repos/${CONSOLE_REPO}/releases/latest" --jq .tag_name)
-gh api "repos/${CONSOLE_REPO}/compare/${CONSOLE_LATEST}...main" \
-  --jq '{status, ahead_by, behind_by, commits: [.commits[] | {sha, message: .commit.message}]}'
-```
-
- `ahead_by == 0`: no merged Console change is waiting for release. Still verify the current latest asset using step 4, then continue to Phase 1.
- `ahead_by > 0` and `behind_by == 0`: publish Console before continuing. Report the merged commits and select the next unused `vX.Y.Z` tag. Default to the next patch version when the changes are fixes or backward-compatible UI work; stop for confirmation if a minor/major bump is plausible.
- Any diverged history or `behind_by > 0`: stop and resolve the Console release baseline explicitly. Do not guess a range or publish RustFS.
-
-2. Clone/fetch `rustfs/console` into a scratch directory and record its exact `main` commit. Before creating a tag, check for a `v*` tag or Release workflow already associated with that hash. If one is in progress, wait for it instead of creating another version:
-
-```bash
-CONSOLE_SCRATCH=$(mktemp -d)
-gh repo clone "$CONSOLE_REPO" "$CONSOLE_SCRATCH/console"
-git -C "$CONSOLE_SCRATCH/console" fetch origin main --tags
-CONSOLE_HASH=$(git -C "$CONSOLE_SCRATCH/console" rev-parse origin/main)
-git -C "$CONSOLE_SCRATCH/console" tag --points-at "$CONSOLE_HASH" 'v*'
-gh run list -R "$CONSOLE_REPO" --workflow release.yml --commit "$CONSOLE_HASH" --limit 5
-```
-
-If no release exists or is running for `CONSOLE_HASH`, create the selected annotated tag at that exact hash and push it:
-
-```bash
-git -C "$CONSOLE_SCRATCH/console" tag -a "<console-tag>" -m "Release <console-tag>" "$CONSOLE_HASH"
-git -C "$CONSOLE_SCRATCH/console" push origin "<console-tag>"
-```
-
-Console tags include the `v` prefix. Pushing the tag triggers `.github/workflows/release.yml` (`🚀 Release`). Remove `CONSOLE_SCRATCH` after the gate completes.
-
-3. Find the exact tag run and wait for completion:
-
-```bash
-gh run list -R "$CONSOLE_REPO" --workflow release.yml --branch "<console-tag>" --limit 1
-gh run watch -R "$CONSOLE_REPO" "<console-run-id>" --exit-status
-```
-
-4. Block until the published Release is non-draft, the latest endpoint returns the expected tag, and `rustfs-console-<console-tag>.zip` is uploaded, non-empty, and carries a `sha256:` digest:
-
-```bash
-gh release view -R "$CONSOLE_REPO" "<console-tag>" --json isDraft,isPrerelease,assets,url
-test "$(gh api "repos/${CONSOLE_REPO}/releases/latest" --jq .tag_name)" = "<console-tag>"
-test "$(gh api "repos/${CONSOLE_REPO}/releases/tags/<console-tag>" \
-  --jq '[.assets[] | select(.name == "rustfs-console-<console-tag>.zip" and .state == "uploaded" and .size > 0 and (.digest | startswith("sha256:")))] | length')" -eq 1
-```
-
-Treat a missing/mismatched asset, digest, latest tag, or failed/cancelled workflow as BLOCKED. Do not start Phase 1 until the Console gate passes. Record `CONSOLE_TAG`, `CONSOLE_HASH`, Console run URL, and Release URL for the final report.
-
 ## Phase 1 — Version bump to the final target (once)

 - If main's version files already read `<target>` (e.g. this is a restart after a failed preview), verify with `rg -n "<target>" Cargo.toml rustfs.spec helm/rustfs/Chart.yaml` and skip to Phase 2.
@@ -146,17 +85,16 @@ git push origin "<preview-tag>"

 Pushing the tag triggers `.github/workflows/build.yml` ("Build and Release"); `docker.yml` chains off it via `workflow_run`.

-The preview run builds versioned artifacts and publishes them in a GitHub prerelease. Its latest-channel, R2, Docker, and Helm jobs must be skipped. Those publication paths run only after the final tag is pushed.
-
 On a restart (N+1), refresh `PREVIEW_HASH=$(git rev-parse origin/main)` first — it must contain the fix — and re-report it.

-## Phase 3 — CI and preview Release verification
+## Phase 3 — CI and artifact verification

- Find and watch the tag build: `gh run list --workflow build.yml --branch "<preview-tag>" --limit 1` then `gh run watch <run-id>`. Every build matrix target must succeed (linux x86_64/aarch64 × musl/gnu, macos-aarch64, windows-x86_64).
- Confirm the Release publication jobs (`create-release`, `upload-release-assets`, and `publish-release`) succeed while `update-latest-version` is skipped.
- Verify `gh release view "<preview-tag>" --json isPrerelease,assets,url`: `isPrerelease` must be `true`, and the Release must contain all 6 versioned platform zips, checksums, SBOM, and provenance with no `-latest` assets. Confirm `gh api repos/{owner}/{repo}/releases/latest --jq .tag_name` does not return `<preview-tag>`.
- Record `PREVIOUS_DELIVERABLE`, selected from published Releases by `publishedAt` after excluding the current tag and every `-preview.N` tag. Verify `gh release view "<preview-tag>" --json body --jq .body` contains `## What's Changed` and, when `PREVIOUS_DELIVERABLE` exists, `**Full Changelog**: https://github.com/rustfs/rustfs/compare/<PREVIOUS_DELIVERABLE>...<preview-tag>`. For a repository with no previous deliverable, verify a Full Changelog link exists and record the GitHub baseline fallback.
- Confirm preview-triggered Docker and Helm jobs are skipped. Preview validation covers the built RustFS binaries, embedded console, and rc compatibility; Docker image construction and Helm publication are deferred to the final tag because the Dockerfiles consume GitHub Release assets.
+- Watch the tag build: `gh run list --workflow build.yml --limit 5` then `gh run watch <run-id>`. Every matrix target must succeed (linux x86_64/aarch64 × musl/gnu, macos-aarch64, windows-x86_64) plus the release and latest.json jobs.
+- Verify the GitHub release: `gh release view "<preview-tag>" --json isPrerelease,assets`
+  - `isPrerelease` must be `true`.
+  - Assets must include all 6 platform zips in both versioned (`rustfs-<platform>-v<tag>.zip`) and `-latest` forms, plus `SHA256SUMS`, `SHA512SUMS`, `rustfs-<tag>.sbom.cdx.json`, `rustfs-<tag>.provenance.json`.
+- Verify the chained Docker run succeeded: `gh run list --workflow docker.yml --limit 3`.
+- Checksum spot-check for the platform you will run locally: download the zip and `SHA256SUMS`, verify with `shasum -a 256 -c` (grep to one line).

 ## Phase 4 — Run the artifact locally, verify the console

@@ -219,15 +157,13 @@ git push origin "<target>"
 ```

 - CI rebuilds from the same source; the only changed input is the tag name, so the binary now self-reports `<target>`.
- Verify the final tag's complete publication path: all matrix and release jobs green; `gh release view "<target>"` shows the full versioned and `-latest` asset set plus checksums, SBOM, and provenance; Docker and Helm workflows succeed; `latest.json` points to `<target>`. A stable target must have `isPrerelease=false` and `isLatest=true`. An alpha/beta/rc target must have `isPrerelease=true`; GitHub does not permit prereleases to be Latest, but the project `latest.json` still advances to the final non-preview target.
- Verify the final Release body contains `## What's Changed` and a Full Changelog link. When `PREVIOUS_DELIVERABLE` exists, the link MUST be `https://github.com/rustfs/rustfs/compare/<PREVIOUS_DELIVERABLE>...<target>` and the baseline MUST equal the preview Release baseline; for example, both `1.0.0-beta.12-preview.1` and `1.0.0-beta.12` compare from `1.0.0-beta.11`.
+- Re-run the Phase 3 verification against the final tag: all matrix jobs green; `gh release view "<target>"` shows the full asset set; for a prerelease target `isPrerelease` is `true`, for a stable target it must be `false` and `latest.json` must be updated.
 - Optionally spot-check `./rustfs --version` from a final-tag artifact — it must report `<target>`.

 ## Output contract

 Always report:

- Console gate result: previous/latest Console tags, whether merged changes required a release, `CONSOLE_HASH`, and Console run/Release URLs when a release was published.
 - Target version, preview tag(s) used, `PREVIEW_HASH` (which both tags point at).
- Per-phase result (PASS/FAIL/BLOCKED) with key evidence: preview and final Release URLs, preview `isPrerelease`/`isLatest` state, final latest-channel state, console check results, and the rc command matrix.
+- Per-phase result (PASS/FAIL/BLOCKED) with key evidence: CI run URLs, release URLs, console check results, the rc command matrix.
 - Any deviation from this pipeline and why the user approved it.
@@ -18,7 +18,7 @@ Validated baseline: release pattern used in PR `#2957`.

 If target version is missing or ambiguous, stop and ask before editing.

-Reject any target version containing `-preview`: preview identifiers are tag-only (see `rustfs-release-publish`) and must never be written into version files. If asked for one, stop and point to the release pipeline instead of editing.
+Reject any target version containing a `-preview.` suffix: preview identifiers are tag-only (see `rustfs-release-publish`) and must never be written into version files. If asked for one, stop and point to the release pipeline instead of editing.

 ## Read before editing

@@ -300,6 +300,9 @@ path = "junit.xml"
 # negative-path siblings of each family stay in as regression guards.
 #   * rustfs#4843 — over-limit archive entry paths hard-reject the whole
 #     archive even under ignore-errors semantics.
+#   * rustfs#4846 — distributed-lock quorum tests misclassify as timeout
+#     under parallel load (multi-node in-process clusters; natural home is
+#     ci-7's nightly cluster lane).
 [profile.e2e-full]
 default-filter = """
    package(e2e_test)
@@ -308,6 +311,7 @@ default-filter = """
    & !test(/^replication_extension_test::/)
    & !test(/^multipart_auth_test::test_signed_put_object_extract_skips_invalid_entry_when_ignore_errors_enabled$/)
    & !test(/^snowball_auto_extract_test::tests::snowball_auto_extract_(ignores_invalid_entries_when_requested|supports_standard_headers_with_combined_extract_options)$/)
+    & !test(/^reliant::lock::test_distributed_lock_(2_nodes_grpc_read_survives_failed_node|4_nodes_grpc_read_write_quorum_split_with_two_failed_nodes)$/)
 """
 fail-fast = false

@@ -60,16 +60,6 @@ The file `prometheus-rules/rustfs-get-optimization-alerts.yaml` contains pre-con
 | `CodecStreamingFallbackSpike` | Warning | Codec streaming fallback > 10x baseline for 10m |
 | `IoQueueSaturation` | Warning | IO queue utilization > 90% for 5m |

-The file `prometheus-rules/rustfs-kms-alerts.yml` contains alerting rules for the KMS backend operation metrics. Thresholds are conservative defaults pending staging baseline calibration; response procedures live in `docs/operations/kms-observability-runbook.md`, and the matching dashboard is `deploy/observability/grafana/rustfs-kms-observability.json`.
-
-| Alert | Severity | Condition |
-|-------|----------|-----------|
-| `KmsBackendFatalErrors` | Critical | Fatal (non-retryable) attempt failures > 0 for 5m |
-| `KmsBackendHighErrorRate` | Critical | Non-success operation ratio > 5% for 10m (with traffic guard) |
-| `KmsBackendP99LatencyHigh` | Warning | Operation p99 duration (incl. retries) > 2s for 10m |
-| `KmsBackendAttemptFailureSpike` | Warning | Attempt failure rate > 0.5/s for 10m |
-| `KmsBackendRetryBudgetExhausted` | Warning | budget_exhausted / deadline_exceeded outcomes > 0.05/s for 10m |
-
 ### Enabling Alert Rules

 Add the alert rules file to your Prometheus configuration:
@@ -60,16 +60,6 @@
 | `CodecStreamingFallbackSpike` | 警告 | Codec streaming 回退 > 10x 基线，持续 10 分钟 |
 | `IoQueueSaturation` | 警告 | IO 队列利用率 > 90%，持续 5 分钟 |

-文件 `prometheus-rules/rustfs-kms-alerts.yml` 包含 KMS 后端操作指标的告警规则。阈值为保守默认值，待 staging 基线校准；响应流程见 `docs/operations/kms-observability-runbook.md`，配套仪表盘为 `deploy/observability/grafana/rustfs-kms-observability.json`。
-
-| 告警 | 级别 | 条件 |
-|------|------|------|
-| `KmsBackendFatalErrors` | 严重 | fatal（不可重试）尝试失败 > 0，持续 5 分钟 |
-| `KmsBackendHighErrorRate` | 严重 | 非 success 操作占比 > 5%，持续 10 分钟（含流量下限保护） |
-| `KmsBackendP99LatencyHigh` | 警告 | 操作 p99 耗时（含重试）> 2s，持续 10 分钟 |
-| `KmsBackendAttemptFailureSpike` | 警告 | 尝试失败率 > 0.5/s，持续 10 分钟 |
-| `KmsBackendRetryBudgetExhausted` | 警告 | budget_exhausted / deadline_exceeded 结果 > 0.05/s，持续 10 分钟 |
-
 ### 启用告警规则

 在 Prometheus 配置中添加告警规则文件：
@@ -1,188 +0,0 @@
-# Copyright 2024 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# =============================================================================
-# RustFS KMS backend — Prometheus alerting rules
-# =============================================================================
-#
-# Metric source: the KMS operation-policy choke point in
-# crates/kms/src/policy.rs. All label values are static enum strings
-# (operation, op_class, outcome, error_class); key identifiers, key material,
-# and tokens never appear in labels.
-#
-# Response procedures: docs/operations/kms-observability-runbook.md
-#
-# IMPORTANT — threshold status: every numeric threshold below is a
-# conservative default chosen without a production baseline. Calibrate against
-# a staging baseline before relying on these alerts for paging, and prefer
-# loosening over tightening until the baseline exists. Formal SLO targets are
-# deliberately not encoded here (see rustfs/backlog#1584).
-#
-# NOTE: prometheus.yml loads /etc/prometheus/rules/*.yml — keep the .yml
-# extension or the file is silently ignored by the docker-compose stack.
-#
-# Validate: promtool check rules rustfs-kms-alerts.yml
-# =============================================================================
-
-groups:
-  # ==========================================================================
-  # Critical alerts — immediate action required
-  # ==========================================================================
-  - name: rustfs-kms-critical
-    interval: 30s
-    rules:
-      # ------------------------------------------------------------------
-      # 1. KmsBackendFatalErrors
-      #    Any attempt failure classified as fatal (non-retryable): auth
-      #    or permission errors, malformed requests, missing keys. The
-      #    policy never retries these, so even a low rate means real
-      #    operations are failing right now.
-      # ------------------------------------------------------------------
-      - alert: KmsBackendFatalErrors
-        expr: |
-          sum by (operation) (rate(rustfs_kms_backend_attempt_failures_total{error_class="fatal"}[5m])) > 0
-        for: 5m
-        labels:
-          severity: critical
-          component: kms
-        annotations:
-          summary: "KMS backend fatal errors on operation {{ $labels.operation }}"
-          description: >-
-            Attempt failures classified as fatal are occurring at
-            {{ $value | printf "%.3f" }}/s on operation
-            {{ $labels.operation }}. Fatal failures are not retried:
-            each one is a KMS backend call that failed permanently
-            (authentication, permissions, malformed request, or a
-            missing key/version).
-          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmsbackendfatalerrors"
-
-      # ------------------------------------------------------------------
-      # 2. KmsBackendHighErrorRate
-      #    Sustained share of operations terminating without success
-      #    (fatal, budget_exhausted, deadline_exceeded). The cancelled
-      #    outcome is excluded because shutdowns legitimately produce it.
-      #    The traffic guard keeps a single failure on a near-idle
-      #    cluster from firing the alert.
-      #    Threshold: 5% for 10m — conservative default, calibrate
-      #    against a staging baseline.
-      # ------------------------------------------------------------------
-      - alert: KmsBackendHighErrorRate
-        expr: |
-          (
-            sum(rate(rustfs_kms_backend_operations_total{outcome!~"success|cancelled"}[5m]))
-            /
-            clamp_min(sum(rate(rustfs_kms_backend_operations_total[5m])), 1e-9)
-          ) > 0.05
-          and
-          sum(rate(rustfs_kms_backend_operations_total[5m])) > 0.02
-        for: 10m
-        labels:
-          severity: critical
-          component: kms
-        annotations:
-          summary: "KMS backend non-success ratio above 5% for 10m"
-          description: >-
-            {{ $value | humanizePercentage }} of KMS backend operations
-            are terminating in fatal, budget_exhausted, or
-            deadline_exceeded. Object encryption and decryption paths
-            depending on the KMS are degraded or failing.
-          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmsbackendhigherrorrate"
-
-  # ==========================================================================
-  # Warning alerts — investigation needed
-  # ==========================================================================
-  - name: rustfs-kms-warning
-    interval: 30s
-    rules:
-      # ------------------------------------------------------------------
-      # 3. KmsBackendP99LatencyHigh
-      #    p99 wall-clock duration of whole operations (attempts plus
-      #    backoff) is sustained above 2 seconds. Because the histogram
-      #    includes retries, a high p99 usually means the retry policy
-      #    is absorbing backend failures, not that every call is slow.
-      #    Threshold: 2s for 10m — conservative default, calibrate
-      #    against a staging baseline.
-      # ------------------------------------------------------------------
-      - alert: KmsBackendP99LatencyHigh
-        expr: |
-          histogram_quantile(0.99,
-            sum by (le) (rate(rustfs_kms_backend_operation_duration_seconds_bucket[5m]))
-          ) > 2
-        for: 10m
-        labels:
-          severity: warning
-          component: kms
-        annotations:
-          summary: "KMS backend operation p99 latency above 2s for 10m"
-          description: >-
-            The 99th-percentile KMS backend operation duration is
-            {{ $value | humanizeDuration }}, including retries and
-            backoff. Encryption and decryption latency is leaking into
-            S3 request latency.
-          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmsbackendp99latencyhigh"
-
-      # ------------------------------------------------------------------
-      # 4. KmsBackendAttemptFailureSpike
-      #    Aggregate attempt-failure rate (all error classes) sustained
-      #    above an absolute floor. An absolute threshold is used instead
-      #    of an offset-1d baseline ratio because fresh deployments have
-      #    no baseline and an empty offset vector would keep a ratio
-      #    alert from ever firing; switch to a baseline-relative form
-      #    (see rustfs-get-optimization-alerts.yaml for the pattern)
-      #    once a stable staging baseline exists.
-      #    Threshold: 0.5/s for 10m — conservative default, calibrate
-      #    against a staging baseline.
-      # ------------------------------------------------------------------
-      - alert: KmsBackendAttemptFailureSpike
-        expr: |
-          sum(rate(rustfs_kms_backend_attempt_failures_total[5m])) > 0.5
-        for: 10m
-        labels:
-          severity: warning
-          component: kms
-        annotations:
-          summary: "KMS backend attempt failures above 0.5/s for 10m"
-          description: >-
-            KMS backend attempts are failing at
-            {{ $value | printf "%.2f" }}/s across all error classes.
-            The retry policy may still be masking these from callers —
-            check the error-class breakdown before it stops absorbing
-            them.
-          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmsbackendattemptfailurespike"
-
-      # ------------------------------------------------------------------
-      # 5. KmsBackendRetryBudgetExhausted
-      #    Operations are running out of retry budget (budget_exhausted)
-      #    or operation deadline (deadline_exceeded). These surface to
-      #    callers as failed KMS operations even though every individual
-      #    failure was retryable — the backend is unhealthy for longer
-      #    than the policy can bridge.
-      #    Threshold: 0.05/s for 10m — conservative default, calibrate
-      #    against a staging baseline.
-      # ------------------------------------------------------------------
-      - alert: KmsBackendRetryBudgetExhausted
-        expr: |
-          sum by (outcome) (rate(rustfs_kms_backend_operations_total{outcome=~"budget_exhausted|deadline_exceeded"}[5m])) > 0.05
-        for: 10m
-        labels:
-          severity: warning
-          component: kms
-        annotations:
-          summary: "KMS backend operations exhausting retry budget ({{ $labels.outcome }})"
-          description: >-
-            KMS backend operations are terminating as
-            {{ $labels.outcome }} at {{ $value | printf "%.3f" }}/s.
-            Retryable failures are outlasting the retry budget, so
-            callers are seeing hard failures.
-          runbook_url: "https://github.com/rustfs/rustfs/blob/main/docs/operations/kms-observability-runbook.md#kmsbackendretrybudgetexhausted"
@@ -25,13 +25,9 @@ inputs:
    required: false
    default: "rustfs-deps"
  cache-save-if:
-    description: >-
-      Whether to save the cache. The fail-safe default is 'false': a caller that
-      wants to populate a cache must opt in explicitly, so a forgotten input
-      costs a cold cache (minutes) rather than silently consuming the
-      repository-wide 10GB Actions cache quota and evicting other lanes.
+    description: "Condition for saving cache"
    required: false
-    default: "false"
+    default: "true"
  install-cross-tools:
    description: "Install cross-compilation tools"
    required: false
@@ -40,43 +36,28 @@ inputs:
    description: "Target architecture to add"
    required: false
    default: ""
-  install-build-packaging-tools:
-    description: >-
-      Install musl-tools/zip/unzip, needed for musl linking and release
-      packaging. Off for CI test lanes, which use none of them.
+  github-token:
+    description: "GitHub token for API access"
    required: false
-    default: "true"
-  install-test-tools:
-    description: >-
-      Install cargo-nextest and the rustfmt/clippy components. Off for release
-      and audit lanes, which run no tests and no lints.
-    required: false
-    default: "true"
+    default: ""

 runs:
  using: "composite"
  steps:
-    # protobuf-compiler is deliberately absent: the setup-protoc step below
-    # installs 34.1 into the tool cache and prepends it to PATH, so the apt
-    # build (older, and never version-matched) was shadowed on every run and
-    # simply never used.
    - name: Install system dependencies (Ubuntu)
      if: runner.os == 'Linux'
      shell: bash
      run: |
        sudo apt-get update
        sudo apt-get install -y \
+          musl-tools \
          build-essential \
          pkg-config \
          libssl-dev \
-          ripgrep
-
-    # musl-gcc is needed by the native musl release leg, and zip/unzip by the
-    # release packaging steps. No CI test lane touches any of them.
-    - name: Install packaging and cross-linking dependencies (Ubuntu)
-      if: runner.os == 'Linux' && inputs.install-build-packaging-tools == 'true'
-      shell: bash
-      run: sudo apt-get install -y musl-tools zip unzip
+          ripgrep \
+          unzip \
+          zip \
+          protobuf-compiler

    - name: Install protoc
      uses: rustfs/setup-protoc@a3705324d8f9bf5b6c3573fb6cf8ae421db55dd6 # v3.0.1
@@ -94,7 +75,7 @@ runs:
      with:
        toolchain: ${{ inputs.rust-version }}
        targets: ${{ inputs.target }}
-        components: ${{ inputs.install-test-tools == 'true' && 'rustfmt, clippy' || '' }}
+        components: rustfmt, clippy

    - name: Install Zig
      if: inputs.install-cross-tools == 'true'
@@ -105,24 +86,12 @@ runs:
      uses: taiki-e/install-action@a21ae4029b089b9ddc45704028756f51ab8abe48 # cargo-zigbuild

    - name: Install cargo-nextest
-      if: inputs.install-test-tools == 'true'
      uses: taiki-e/install-action@96c7780c1d8a2b8723e12031def873a434d39d8d # nextest

    - name: Setup Rust cache
      uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
      with:
-        # false is rust-cache's own default. With true, cleanup.ts returns
-        # *before* pruning ~/.cargo/registry/src, and config.ts archives the
-        # whole registry — so every cache carried the unpacked source tree of
-        # every dependency, not just "a few extra crates".
-        #
-        # No coverage is lost: getPackages runs `cargo metadata --all-features`,
-        # a strict superset of any single lane's feature closure, and -sys crates
-        # are explicitly exempted from pruning (their src timestamps would
-        # otherwise trigger rebuilds). Anything pruned is re-unpacked from the
-        # .crate files still in registry/cache, whose mtimes crates.io
-        # normalises, so cargo fingerprints stay valid.
-        cache-all-crates: false
+        cache-all-crates: true
        cache-on-failure: true
        shared-key: ${{ inputs.cache-shared-key }}
        save-if: ${{ inputs.cache-save-if }}
@@ -37,7 +37,6 @@ jobs:
    name: Cancel Closed PR Runs
    if: github.event_name == 'pull_request' && github.event.action == 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Explain cancellation run
        run: echo "PR closed; this run only cancels older runs in the same concurrency group."
@@ -46,11 +45,8 @@ jobs:
    name: Architecture Migration Rules
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Install ripgrep
        run: |
@@ -23,8 +23,6 @@ on:
      - 'deny.toml'
      - '.github/actions/**'
      - '.github/workflows/**'
-      - 'scripts/release/create_or_update_release.sh'
-      - 'scripts/security/check_preview_release_workflow.sh'
      - 'scripts/security/check_workflow_pins.sh'
  pull_request:
    types: [ opened, synchronize, reopened, closed ]
@@ -35,16 +33,9 @@ on:
      - 'deny.toml'
      - '.github/actions/**'
      - '.github/workflows/**'
-      - 'scripts/release/create_or_update_release.sh'
-      - 'scripts/security/check_preview_release_workflow.sh'
      - 'scripts/security/check_workflow_pins.sh'
  schedule:
-    # Daily, not weekly. This schedule exists to catch RustSec advisories
-    # published against an unchanged dependency tree; at weekly cadence a new
-    # advisory could sit unnoticed for seven days. The check list is unchanged —
-    # splitting it into a light daily advisories-only run and a weekly full run
-    # would create runs where sources/bans/licenses go unverified.
-    - cron: '0 3 * * *' # Daily 03:00 UTC (staggered after the midnight ci/build crons)
+    - cron: '0 3 * * 0' # Weekly on Sunday 03:00 UTC (staggered after the midnight ci/build crons)
  workflow_dispatch:

 permissions:
@@ -64,7 +55,6 @@ jobs:
    name: Cancel Closed PR Runs
    if: github.event_name == 'pull_request' && github.event.action == 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Explain cancellation run
        run: echo "PR closed; this run only cancels older runs in the same concurrency group."
@@ -80,32 +70,11 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

-      # cargo-deny compiles nothing, so the full setup composite (apt packages,
-      # protoc, flatc, nextest, rustfmt/clippy) was pure overhead here. It does
-      # still need a real cargo: `cargo deny check` runs `cargo metadata`, and
-      # Cargo.toml pins datafusion and s3s as git dependencies, which must be
-      # materialised into ~/.cargo/git — a cold clone is hundreds of MB, so the
-      # cache stays.
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable
-
-      # Was relying on the composite's default, which used to be "true": every
-      # PR touching Cargo.toml/Cargo.lock saved a second, PR-scoped copy of this
-      # cache and pushed the main-scoped lanes out of the 10GB quota. The
-      # default is now "false", but state it explicitly — see
-      # scripts/security/check_cache_save_if.sh.
-      - name: Setup Rust cache
-        uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+      - name: Setup Rust environment
+        uses: ./.github/actions/setup
        with:
-          # Same reasoning as the setup composite: true archives every
-          # dependency's unpacked source tree.
-          cache-all-crates: false
-          cache-on-failure: true
-          shared-key: rustfs-cargo-deny
-          save-if: ${{ github.ref == 'refs/heads/main' }}
+          cache-shared-key: rustfs-cargo-deny

      - name: Install cargo-deny
        uses: taiki-e/install-action@bffeee26d4db9be238a4ea78d8826604ebcb594d # v2
@@ -123,28 +92,13 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Report unpinned GitHub Actions
        run: ./scripts/security/check_workflow_pins.sh --enforce

-      - name: Check setup cache-save-if is explicit
-        run: ./scripts/security/check_cache_save_if.sh
-
-      - name: Check every job declares a timeout
-        run: ./scripts/security/check_job_timeouts.sh
-
-      - name: Check checkouts clear their credentials
-        run: ./scripts/security/check_persist_credentials.sh
-
-      - name: Check preview release workflow policy
-        run: ./scripts/security/check_preview_release_workflow.sh
-
  dependency-review:
    name: Dependency Review
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    if: github.event_name == 'pull_request' && github.event.action != 'closed'
    permissions:
      contents: read
@@ -152,8 +106,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Dependency Review
        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5
@@ -166,28 +118,3 @@ jobs:
          # conscious re-review of the license/provenance claim (backlog#1181).
          allow-dependencies-licenses: pkg:cargo/rustfs-uring@0.1.0
          comment-summary-in-pr: always
-
-  alert-on-failure:
-    name: Alert on scheduled failure
-    # dependency-review is deliberately excluded: it only runs on pull_request,
-    # so it can never contribute a failure to a scheduled run.
-    needs: [cargo-deny, workflow-pin-report]
-    # A scheduled cargo-deny failure usually means the dependency tree just
-    # matched a newly published advisory — the single most important signal this
-    # workflow produces, and until now it was only visible to whoever happened to
-    # open the Actions tab. Same ci-8 mechanism coverage.yml and
-    # e2e-replication-nightly.yml already use.
-    if: always() && github.event_name == 'schedule' && contains(needs.*.result, 'failure')
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-      - name: Open or update failure-tracking issue
-        uses: ./.github/actions/schedule-failure-issue
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -50,18 +50,12 @@ on:
      - "**/*.svg"
      - ".gitignore"
      - ".dockerignore"
-      - "flake.lock"
  schedule:
    - cron: "0 1 * * 0" # Weekly on Sunday 01:00 UTC (staggered after the ci.yml midnight cron)
  workflow_dispatch:
    inputs:
      build_docker:
-        # Advisory only. docker.yml triggers on workflow_run and its job-level
-        # condition requires the triggering event to be a tag push, so a manual
-        # dispatch of this workflow never produces images regardless of this
-        # value. Kept because the summary step reports it; wiring it up would
-        # mean teaching docker.yml's version parser a second event shape.
-        description: "Build and push Docker images after binary build (ignored: dispatch runs never reach docker.yml)"
+        description: "Build and push Docker images after binary build"
        required: false
        default: true
        type: boolean
@@ -89,7 +83,6 @@ jobs:
  build-check:
    name: Build Strategy Check
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    outputs:
      should_build: ${{ steps.check.outputs.should_build }}
      build_type: ${{ steps.check.outputs.build_type }}
@@ -99,8 +92,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Determine build strategy
        id: check
@@ -116,21 +107,13 @@ jobs:

          # Determine build type based on trigger
          if [[ "${{ startsWith(github.ref, 'refs/tags/') }}" == "true" ]]; then
-            # Tag push - preview, release, or prerelease
+            # Tag push - release or prerelease
            should_build=true
            tag_name="${GITHUB_REF#refs/tags/}"
            version="${tag_name}"

-            # Preview tags publish a GitHub prerelease for validation, but
-            # must not update any latest channel.
-            if [[ "$tag_name" =~ -preview\.[0-9]+$ ]]; then
-              build_type="preview"
-              is_prerelease=true
-              echo "🔍 Preview build detected: $tag_name"
-            elif [[ "$tag_name" == *"-preview"* ]]; then
-              echo "❌ Invalid preview tag: $tag_name (expected suffix: -preview.<number>)" >&2
-              exit 1
-            elif [[ "$tag_name" == *"alpha"* ]] || [[ "$tag_name" == *"beta"* ]] || [[ "$tag_name" == *"rc"* ]]; then
+            # Check if this is a prerelease
+            if [[ "$tag_name" == *"alpha"* ]] || [[ "$tag_name" == *"beta"* ]] || [[ "$tag_name" == *"rc"* ]]; then
              build_type="prerelease"
              is_prerelease=true
              echo "🚀 Prerelease build detected: $tag_name"
@@ -173,7 +156,6 @@ jobs:
    name: Prepare Platform Matrix
    needs: build-check
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    outputs:
      matrix: ${{ steps.select.outputs.matrix }}
      selected: ${{ steps.select.outputs.selected }}
@@ -181,14 +163,10 @@ jobs:
      - name: Select target platforms
        id: select
        shell: bash
-        env:
-          # via env, not interpolation: a dispatch input is free-form text and
-          # would otherwise be pasted into the script for bash to evaluate.
-          RAW_PLATFORMS: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.platforms || 'all' }}
        run: |
          set -euo pipefail

-          selected="$RAW_PLATFORMS"
+          selected="${{ github.event_name == 'workflow_dispatch' && github.event.inputs.platforms || 'all' }}"
          selected="$(echo "${selected}" | tr -d '[:space:]')"
          if [[ -z "${selected}" ]]; then
            selected="all"
@@ -259,7 +237,6 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Setup Rust environment
@@ -268,17 +245,9 @@ jobs:
          rust-version: stable
          target: ${{ matrix.target }}
          cache-shared-key: build-${{ matrix.target }}
-          # main only. A cache saved on refs/tags/X is scoped to that tag: no
-          # other tag, no main run and no PR can restore it, so every release
-          # cycle wrote up to 12 entries of 1-2GB (preview tag plus final tag,
-          # six legs each) that nobody could read, evicting the hot lanes from
-          # the repo-wide 10GB quota. Tag builds still restore the main-scoped
-          # cache, since default-branch caches are readable from every ref.
-          # The one real cost: re-running a failed leg of the same tag no longer
-          # finds that tag's own warm cache and falls back to main's.
-          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/') }}
          install-cross-tools: ${{ matrix.cross }}
-          install-test-tools: 'false'

      - name: Download static console assets
        shell: bash
@@ -725,14 +694,9 @@ jobs:
    needs: [ build-check, build-rustfs ]
    if: always() && needs.build-check.outputs.should_build == 'true'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Build completion summary
        shell: bash
-        env:
-          # dispatch input via env: free-form text must not be pasted into the
-          # script for bash to evaluate.
-          INPUT_BUILD_DOCKER: ${{ github.event.inputs.build_docker }}
        run: |
          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
          VERSION="${{ needs.build-check.outputs.version }}"
@@ -750,10 +714,6 @@ jobs:
          echo ""

          case "$BUILD_TYPE" in
-            "preview")
-              echo "🔍 Preview artifacts are published in a GitHub prerelease"
-              echo "⏭️  Preview releases do not update latest channels"
-              ;;
            "development")
              echo "🛠️  Development build artifacts have been uploaded to OSS dev directory"
              echo "⚠️  This is a development build - not suitable for production use"
@@ -772,9 +732,7 @@ jobs:

          echo ""
          echo "🐳 Docker Images:"
-          if [[ "$BUILD_TYPE" == "preview" ]]; then
-            echo "⏭️  Preview tags do not publish Docker images"
-          elif [[ "$INPUT_BUILD_DOCKER" == "false" ]]; then
+          if [[ "${{ github.event.inputs.build_docker }}" == "false" ]]; then
            echo "⏭️  Docker image build was skipped (binary only build)"
          elif [[ "$BUILD_STATUS" == "success" ]]; then
            echo "🔄 Docker images will be built and pushed automatically via workflow_run event"
@@ -782,13 +740,12 @@ jobs:
            echo "❌ Docker image build will be skipped due to build failure"
          fi

-  # Create GitHub Release for every valid release tag, including previews
+  # Create GitHub Release (only for tag pushes)
  create-release:
    name: Create GitHub Release
    needs: [ build-check, build-rustfs ]
-    if: startsWith(github.ref, 'refs/tags/') && (needs.build-check.outputs.build_type == 'preview' || needs.build-check.outputs.build_type == 'release' || needs.build-check.outputs.build_type == 'prerelease')
+    if: startsWith(github.ref, 'refs/tags/') && needs.build-check.outputs.build_type != 'development'
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    permissions:
      contents: write
    outputs:
@@ -798,7 +755,6 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Create GitHub Release
@@ -811,12 +767,9 @@ jobs:
          VERSION="${{ needs.build-check.outputs.version }}"
          IS_PRERELEASE="${{ needs.build-check.outputs.is_prerelease }}"
          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-          TARGET_COMMITISH=$(git rev-parse --verify "refs/tags/${TAG}^{commit}")

          # Determine release type for title
-          if [[ "$BUILD_TYPE" == "preview" ]]; then
-            RELEASE_TYPE="preview"
-          elif [[ "$BUILD_TYPE" == "prerelease" ]]; then
+          if [[ "$BUILD_TYPE" == "prerelease" ]]; then
            if [[ "$TAG" == *"alpha"* ]]; then
              RELEASE_TYPE="alpha"
            elif [[ "$TAG" == *"beta"* ]]; then
@@ -830,34 +783,61 @@ jobs:
            RELEASE_TYPE="release"
          fi

-          # Create release title
-          if [[ "$IS_PRERELEASE" == "true" ]]; then
-            TITLE="RustFS $VERSION (${RELEASE_TYPE})"
+          # Check if release already exists
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "Release $TAG already exists"
+            RELEASE_ID=$(gh release view "$TAG" --json databaseId --jq '.databaseId')
+            RELEASE_URL=$(gh release view "$TAG" --json url --jq '.url')
          else
-            TITLE="RustFS $VERSION"
+            # Get release notes from tag message
+            RELEASE_NOTES=$(git tag -l --format='%(contents)' "${TAG}")
+            if [[ -z "$RELEASE_NOTES" || "$RELEASE_NOTES" =~ ^[[:space:]]*$ ]]; then
+              if [[ "$IS_PRERELEASE" == "true" ]]; then
+                RELEASE_NOTES="Pre-release ${VERSION} (${RELEASE_TYPE})"
+              else
+                RELEASE_NOTES="Release ${VERSION}"
+              fi
+            fi
+
+            # Create release title
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              TITLE="RustFS $VERSION (${RELEASE_TYPE})"
+            else
+              TITLE="RustFS $VERSION"
+            fi
+
+            # Create the release
+            PRERELEASE_FLAG=""
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              PRERELEASE_FLAG="--prerelease"
+            fi
+
+            gh release create "$TAG" \
+              --title "$TITLE" \
+              --notes "$RELEASE_NOTES" \
+              $PRERELEASE_FLAG \
+              --draft
+
+            RELEASE_ID=$(gh release view "$TAG" --json databaseId --jq '.databaseId')
+            RELEASE_URL=$(gh release view "$TAG" --json url --jq '.url')
          fi

-          ./scripts/release/create_or_update_release.sh \
-            "$TAG" \
-            "$TARGET_COMMITISH" \
-            "$TITLE" \
-            "$IS_PRERELEASE"
+          echo "release_id=$RELEASE_ID" >> "$GITHUB_OUTPUT"
+          echo "release_url=$RELEASE_URL" >> "$GITHUB_OUTPUT"
+          echo "Created release: $RELEASE_URL"

  # Prepare and upload release assets
  upload-release-assets:
    name: Upload Release Assets
    needs: [ build-check, build-rustfs, create-release ]
-    if: startsWith(github.ref, 'refs/tags/') && (needs.build-check.outputs.build_type == 'preview' || needs.build-check.outputs.build_type == 'release' || needs.build-check.outputs.build_type == 'prerelease')
+    if: startsWith(github.ref, 'refs/tags/') && needs.build-check.outputs.build_type != 'development'
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    permissions:
      contents: write
      actions: read
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Download all build artifacts
        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
@@ -940,10 +920,9 @@ jobs:
  # the pointed-to version is a prerelease.
  update-latest-version:
    name: Update Latest Version
-    needs: [ build-check, publish-release ]
-    if: startsWith(github.ref, 'refs/tags/') && (needs.build-check.outputs.build_type == 'release' || needs.build-check.outputs.build_type == 'prerelease')
+    needs: [ build-check, upload-release-assets ]
+    if: startsWith(github.ref, 'refs/tags/')
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    steps:
      - name: Update latest.json
        env:
@@ -1001,34 +980,51 @@ jobs:
  publish-release:
    name: Publish Release
    needs: [ build-check, create-release, upload-release-assets ]
-    if: startsWith(github.ref, 'refs/tags/') && (needs.build-check.outputs.build_type == 'preview' || needs.build-check.outputs.build_type == 'release' || needs.build-check.outputs.build_type == 'prerelease')
+    if: startsWith(github.ref, 'refs/tags/') && needs.build-check.outputs.build_type != 'development'
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    permissions:
      contents: write
    steps:
-      - name: Publish release
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
+
+      - name: Update release notes and publish
        env:
          GH_TOKEN: ${{ github.token }}
        shell: bash
        run: |
          TAG="${{ needs.build-check.outputs.version }}"
+          VERSION="${{ needs.build-check.outputs.version }}"
+          IS_PRERELEASE="${{ needs.build-check.outputs.is_prerelease }}"
          BUILD_TYPE="${{ needs.build-check.outputs.build_type }}"
-          RELEASE_ID="${{ needs.create-release.outputs.release_id }}"

-          # Publish the release and correct its channel state on retries.
-          # Only a stable final release may become GitHub Latest.
-          if [[ "$BUILD_TYPE" == "release" ]]; then
-            gh api --method PATCH "repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}" \
-              -F draft=false \
-              -F prerelease=false \
-              -f make_latest=true >/dev/null
+          # Determine release type
+          if [[ "$BUILD_TYPE" == "prerelease" ]]; then
+            if [[ "$TAG" == *"alpha"* ]]; then
+              RELEASE_TYPE="alpha"
+            elif [[ "$TAG" == *"beta"* ]]; then
+              RELEASE_TYPE="beta"
+            elif [[ "$TAG" == *"rc"* ]]; then
+              RELEASE_TYPE="rc"
+            else
+              RELEASE_TYPE="prerelease"
+            fi
          else
-            gh api --method PATCH "repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}" \
-              -F draft=false \
-              -F prerelease=true \
-              -f make_latest=false >/dev/null
+            RELEASE_TYPE="release"
          fi

+          # Get original release notes from tag
+          ORIGINAL_NOTES=$(git tag -l --format='%(contents)' "${TAG}")
+          if [[ -z "$ORIGINAL_NOTES" || "$ORIGINAL_NOTES" =~ ^[[:space:]]*$ ]]; then
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              ORIGINAL_NOTES="Pre-release ${VERSION} (${RELEASE_TYPE})"
+            else
+              ORIGINAL_NOTES="Release ${VERSION}"
+            fi
+          fi
+
+          # Publish the release (remove draft status)
+          gh release edit "$TAG" --draft=false
+
          echo "🎉 Released $TAG successfully!"
          echo "📄 Release URL: ${{ needs.create-release.outputs.release_url }}"
@@ -1,246 +0,0 @@
-# Copyright 2026 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Sole writer of the Rust dependency caches that ci.yml restores.
-#
-# Why this is a separate workflow rather than steps inside ci.yml: ci.yml's
-# concurrency group cancels in-progress runs on main pushes, and merges land far
-# faster than its 70-minute pipeline. Measured over 15 consecutive main pushes:
-# 12 cancelled, 2 failed, 0 succeeded. A cancelled run never reaches
-# Swatinem/rust-cache's post step (cache-on-failure does not cover cancellation),
-# so the writer lanes were saving nothing and every PR paid a cold restore —
-# 11.8-20.9 minutes of "Setup Rust environment" against 0.7-3.4 warm.
-#
-# Splitting cache writing out of the test pipeline lets ci.yml keep cancelling
-# superseded runs (which is correct — nobody needs test results for a commit
-# that is already three merges behind) while the caches still get written.
-#
-# The group below deliberately does NOT cancel in progress. GitHub keeps at most
-# one running plus one pending run per group, so a burst of merges collapses
-# into "current run finishes, newest queued run follows" rather than a pile-up.
-# That also bounds this workflow to one self-hosted runner at a time.
-#
-# Each job below owns exactly one shared-key and is the only place that sets
-# cache-save-if to anything but 'false' for it; every lane in ci.yml reads.
-# scripts/security/check_cache_save_if.sh keeps the declarations explicit.
-#
-# The builds are supersets of what the reading lanes compile, because a reader
-# restores only what the writer saved. Feature resolution matters here: a lane
-# built with e2e-test-hooks resolves dependency features differently, which
-# changes -Cmetadata, so the plain build does not cover it. See
-# rustfs/backlog#1600.
-
-name: Cache Warm
-
-on:
-  push:
-    branches: [ main ]
-    # Mirrors ci.yml's push paths-ignore: if a commit cannot change what ci.yml
-    # compiles, it cannot change what ci.yml needs restored either.
-    paths-ignore:
-      - "**.md"
-      - "docs/**"
-      - "deploy/**"
-      - "scripts/dev_*.sh"
-      - "scripts/probe.sh"
-      - "LICENSE*"
-      - ".gitignore"
-      - ".dockerignore"
-      - "README*"
-      - "**/*.png"
-      - "**/*.jpg"
-      - "**/*.svg"
-      - ".github/workflows/build.yml"
-      - ".github/workflows/docker.yml"
-      - ".github/workflows/audit.yml"
-  workflow_dispatch:
-    inputs:
-      emit_timings:
-        description: >-
-          Also emit cargo --timings for the ci-dev build and upload it. Used to
-          decide whether sccache is worth adopting (rustfs/backlog#1601 gate).
-        required: false
-        default: false
-        type: boolean
-
-permissions:
-  contents: read
-
-concurrency:
-  group: cache-warm
-  cancel-in-progress: false
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  # Readers: test-and-lint, test-ilm-integration-serial, build-rustfs-debug-binary,
-  # e2e-tests, e2e-full.
-  warm-ci-dev:
-    name: Warm ci-dev
-    runs-on: sm-standard-4
-    timeout-minutes: 90
-    env:
-      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: ci-dev
-          cache-save-if: 'true'
-          install-build-packaging-tools: 'false'
-
-      # rustfs/backlog#1601 gate. sccache can only cache compilation units whose
-      # --emit includes link, so it covers workspace rlibs and nothing else:
-      # clippy is metadata-only, and the ~100 test binaries, the rustfs bin and
-      # every build script invoke the system linker. Before spending a bucket,
-      # credentials and a supply-chain boundary on it, measure how much of the
-      # build is actually rlib codegen.
-      #
-      # Read from the report: workspace lib codegen as a share of the build, and
-      # s3select-query's own rlib as a share. The plan adopts sccache only above
-      # 50% and 25% respectively; if linking dominates instead, the answer is
-      # mold/lld plus split-debuginfo, which is exactly the part sccache cannot
-      # touch. Off by default — this doubles the ci-dev build.
-      - name: Build ci-dev superset (with --timings)
-        if: inputs.emit_timings
-        env:
-          CARGO_BUILD_JOBS: "2"
-        run: cargo build --workspace --all-targets --timings
-
-      - name: Upload cargo timings report
-        if: inputs.emit_timings
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
-        with:
-          name: cargo-timings-ci-dev
-          path: target/cargo-timings/
-          retention-days: 30
-          if-no-files-found: error
-
-      # --all-targets covers the test binaries nextest builds, including
-      # e2e_test, which test-and-lint's own run excludes. The second build adds
-      # the e2e-test-hooks feature resolution that build-rustfs-debug-binary uses
-      # and that no lint lane enables.
-      - name: Build ci-dev superset
-        env:
-          # Same limit ci.yml puts on its nextest step: this builds the same
-          # ~100 workspace test binaries, and three concurrent links saturate the
-          # self-hosted runner's overlay I/O and can wedge Cargo (#5394).
-          CARGO_BUILD_JOBS: "2"
-        run: |
-          cargo build --workspace --all-targets
-          cargo build -p rustfs --bins --features e2e-test-hooks
-
-      # Runs before rust-cache's post step, so these are the sizes it is about
-      # to archive. Reported so the cache-all-crates decision stays evidence-led:
-      # registry/src is what that flag prunes, registry/cache is what the pruned
-      # sources are re-unpacked from. See rustfs/backlog#1600.
-      - name: Report cache input sizes
-        if: always()
-        run: |
-          {
-            echo "### Cache input sizes (ci-dev)"
-            echo '```'
-            du -sh ~/.cargo/registry/src ~/.cargo/registry/cache ~/.cargo/registry/index \
-                   ~/.cargo/git target 2>/dev/null || true
-            echo '```'
-          } >> "$GITHUB_STEP_SUMMARY"
-
-  # Readers: test-and-lint-rio-v2, build-rustfs-debug-binary-rio-v2.
-  warm-ci-feat-rio:
-    name: Warm ci-feat-rio
-    runs-on: sm-standard-4
-    timeout-minutes: 90
-    env:
-      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: ci-feat-rio
-          cache-save-if: 'true'
-          install-build-packaging-tools: 'false'
-
-      - name: Build ci-feat-rio superset
-        run: |
-          cargo build -p rustfs -p rustfs-ecstore --all-targets --features rio-v2
-          cargo build -p rustfs --bins --features rio-v2,e2e-test-hooks
-
-  # Readers: the swift and sftp legs of test-and-lint-protocols. Built in
-  # sequence rather than as `--features swift,sftp`, which is a combination no
-  # lane actually compiles; running both leaves the union in target/.
-  warm-ci-feat-proto:
-    name: Warm ci-feat-proto
-    runs-on: sm-standard-4
-    timeout-minutes: 90
-    env:
-      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: ci-feat-proto
-          cache-save-if: 'true'
-          install-build-packaging-tools: 'false'
-
-      - name: Build ci-feat-proto superset
-        run: |
-          cargo build -p rustfs -p rustfs-protocols --all-targets --features swift
-          cargo build -p rustfs -p rustfs-protocols --all-targets --features sftp
-
-  # Reader: uring-integration. Runs on ubuntu-latest to match it: rust-cache's
-  # key covers runner.os and arch but not the runner label or image, so a cache
-  # written on sm-standard-4 would be restored by the hosted runner as if it
-  # belonged to it.
-  warm-ci-uring:
-    name: Warm ci-uring
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-
-      - name: Setup Rust environment
-        uses: ./.github/actions/setup
-        with:
-          rust-version: stable
-          cache-shared-key: ci-uring
-          cache-save-if: 'true'
-          install-build-packaging-tools: 'false'
-
-      - name: Install build dependencies
-        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
-
-      - name: Build ci-uring superset
-        run: cargo build -p rustfs-ecstore --all-targets
@@ -12,24 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-# Companion to ci.yml for required status checks.
+# Companion to ci.yml for the required "Test and Lint" status check.
 #
-# ci.yml skips docs-only pull requests via paths-ignore, but the branch ruleset
-# requires a check named "Test and Lint" — without this workflow a docs-only PR
-# would wait on it forever. This workflow triggers on exactly the paths ci.yml
-# ignores and reports success under the same job name. Mixed PRs trigger both
-# workflows and the real check still gates: a required check with any failing
-# run blocks the merge.
+# ci.yml skips docs-only pull requests via paths-ignore, but the branch
+# ruleset requires a check named "Test and Lint" — without this workflow a
+# docs-only PR would wait on that check forever. This workflow triggers on
+# exactly the paths ci.yml ignores and reports an instant success under the
+# same job name. Mixed PRs trigger both workflows and the real check still
+# gates: a required check with any failing run blocks the merge.
 # https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/defining-the-mergeability-of-pull-requests/troubleshooting-required-status-checks#handling-skipped-but-required-checks
 #
-# "Quick Checks" is mirrored here ahead of the ruleset change that will make it
-# required too (rustfs/backlog#1599). Until that change lands this job is
-# inert; mirroring it first is what lets the ruleset change happen without
-# stranding docs-only PRs on a check nobody reports.
-#
 # Keep the paths list below in sync with the pull_request paths-ignore list
-# in ci.yml, and keep the quick-checks steps below byte-identical to the
-# quick-checks job in ci.yml.
+# in ci.yml.

 name: Continuous Integration (docs only)

@@ -53,82 +47,17 @@ on:
      - ".github/workflows/build.yml"
      - ".github/workflows/docker.yml"
      - ".github/workflows/audit.yml"
-      - "flake.lock"

 permissions:
  contents: read

 jobs:
-  # Deliberately NOT a bare `echo`. Once "Quick Checks" becomes a required
-  # check, ci.yml gates every expensive job behind it, so a mixed PR reports
-  # two check runs with this name: the real one (45-51s) and this companion.
-  # GitHub has no written contract for how it picks between same-named
-  # required check runs ("latest wins" vs "any failure blocks"), so instead of
-  # relying on ordering we make both runs execute the same commands against
-  # the same merge ref — their conclusions are then necessarily identical and
-  # the choice does not matter. Keep these steps byte-identical to the
-  # quick-checks job in ci.yml (a guard script that asserts this, and the paths
-  # sync below, is tracked in rustfs/backlog#1603).
-  #
-  # For a genuinely docs-only PR this adds no strictness (no code changed, so
-  # fmt and the guards always pass) and costs ~50s of ubuntu-latest.
-  quick-checks:
-    name: Quick Checks
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-
-      - name: Install ripgrep
-        run: sudo apt-get update && sudo apt-get install -y ripgrep
-
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable
-        with:
-          components: rustfmt
-
-      - name: Check code formatting
-        run: cargo fmt --all --check
-
-      - name: Check unsafe code allowances
-        run: ./scripts/check_unsafe_code_allowances.sh
-
-      - name: Check layered dependencies
-        run: ./scripts/check_layer_dependencies.sh
-
-      - name: Check architecture migration rules
-        run: ./scripts/check_architecture_migration_rules.sh
-
-      - name: Check tokio io-uring feature guard
-        run: ./scripts/check_no_tokio_io_uring.sh
-
-      - name: Check extension schema boundaries
-        run: ./scripts/check_extension_schema_boundaries.sh
-
-      - name: Check body-cache whitelist guard
-        run: ./scripts/check_body_cache_whitelist.sh
-
-      - name: Check no planning docs committed
-        run: ./scripts/check_no_planning_docs.sh
-
-      - name: Check CI paths stay in sync
-        run: ./scripts/check_ci_paths_sync.sh
-
-      - name: Check io_uring lane --lib precondition
-        run: ./scripts/check_uring_lane_lib_only.sh
-
  test-and-lint:
    name: Test and Lint
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      # Docs-only PRs skip the full code CI, but they are exactly where a
      # planning-type document could be slipped in (git add -f bypasses
@@ -33,7 +33,6 @@ on:
      - ".github/workflows/build.yml"
      - ".github/workflows/docker.yml"
      - ".github/workflows/audit.yml"
-      - "flake.lock"
  pull_request:
    types: [ opened, synchronize, reopened, closed ]
    branches: [ main ]
@@ -55,7 +54,6 @@ on:
      - ".github/workflows/build.yml"
      - ".github/workflows/docker.yml"
      - ".github/workflows/audit.yml"
-      - "flake.lock"
  merge_group:
    types: [ checks_requested ]
  schedule:
@@ -83,7 +81,6 @@ jobs:
    name: Cancel Closed PR Runs
    if: github.event_name == 'pull_request' && github.event.action == 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Explain cancellation run
        run: echo "PR closed; this run only cancels older runs in the same concurrency group."
@@ -92,20 +89,13 @@ jobs:
    name: Typos
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Typos check with custom config file
        uses: crate-ci/typos@37bb98842b0d8c4ffebdb75301a13db0267cef89 # master

  # Fast, compile-free checks that fail early so contributors get feedback in
  # ~1 minute instead of waiting for the full test job.
-  #
-  # These steps are mirrored byte-for-byte in ci-docs-only.yml so that a mixed
-  # PR, which reports two check runs named "Quick Checks", cannot get one red
-  # and one green. Edit both jobs together.
  quick-checks:
    name: Quick Checks
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
@@ -114,8 +104,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Install ripgrep
        run: sudo apt-get update && sudo apt-get install -y ripgrep
@@ -149,48 +137,24 @@ jobs:
      - name: Check no planning docs committed
        run: ./scripts/check_no_planning_docs.sh

-      - name: Check CI paths stay in sync
-        run: ./scripts/check_ci_paths_sync.sh
-
-      - name: Check io_uring lane --lib precondition
-        run: ./scripts/check_uring_lane_lib_only.sh
-
  test-and-lint:
    name: Test and Lint
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    runs-on: sm-standard-4
    timeout-minutes: 90
-    # Both lines are required. Job-level `permissions` replaces the workflow
-    # block rather than merging with it, so declaring only `actions: write`
-    # would drop `contents: read` and break this job's checkout and the
-    # repo-token the setup action hands to setup-protoc.
-    permissions:
-      contents: read
-      actions: write
    env:
      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          # This job's token can cancel runs and delete Actions caches. Checkout
-          # otherwise writes it into .git/config, where a PR's own build.rs or
-          # proc-macro could read it back out.
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          # Every lane in this workflow reads its cache and none writes it.
-          # cache-warm.yml is the sole writer for all four keys: this workflow
-          # cancels superseded runs on main, and a cancelled run never reaches
-          # rust-cache's post step, so writing from here saved nothing (12 of 15
-          # consecutive main-push runs were cancelled). See rustfs/backlog#1600.
-          cache-shared-key: ci-dev
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-test
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      - name: Prepare test evidence
        run: |
@@ -205,24 +169,12 @@ jobs:
      # Clippy runs before the test pass: lint failures are the most common
      # CI-only breakage and should surface in minutes, not after 20+ minutes
      # of tests.
-      # Sampled too: clippy is the natural control arm for any CARGO_BUILD_JOBS
-      # experiment, since --all-targets is check-only for workspace members and
-      # never links the ~100 test binaries the limit exists to throttle.
      - name: Run clippy lints
-        run: |
-          ./scripts/ci/resource_sampler.sh start clippy
-          trap './scripts/ci/resource_sampler.sh stop' EXIT
-          cargo clippy --all-targets -- -D warnings
+        run: cargo clippy --all-targets -- -D warnings

      - name: Run nextest tests
-        env:
-          # Three concurrent workspace test links saturate the self-hosted
-          # runner's overlay I/O and can wedge Cargo until the 75m timeout.
-          CARGO_BUILD_JOBS: "2"
        run: |
          mkdir -p artifacts/test-and-lint
-          ./scripts/ci/resource_sampler.sh start nextest
-          trap './scripts/ci/resource_sampler.sh stop' EXIT
          set +e
          NEXTEST_HIDE_PROGRESS_BAR=1 timeout --verbose --signal=TERM --kill-after=30s 75m \
            cargo nextest run --profile ci --all --exclude e2e_test \
@@ -236,9 +188,6 @@ jobs:
            echo
            echo "Remaining test-related processes:"
            pgrep -af 'cargo|nextest|target/.*/deps/' || true
-            echo
-            echo "Kernel OOM / kill events:"
-            dmesg -T 2>/dev/null | grep -iE 'oom|out of memory|killed process' | tail -20 || true
          } > artifacts/test-and-lint/nextest-diagnostics.txt
          exit "${status}"

@@ -294,48 +243,6 @@ jobs:
      - name: Run rebalance/decommission migration proofs
        run: ./scripts/check_migration_gate_count.sh

-      # Early stop. Once this job has failed the PR cannot merge, so the sibling
-      # lanes are burning runners on a result nobody can act on: on run
-      # 30674613104 three lanes had already failed while Test and Lint and the
-      # rio-v2 variant kept going past 70 minutes.
-      #
-      # Only this job may cancel. The lanes that are NOT required checks
-      # (protocols, ILM, e2e, s3-tests) must never hold that power: a flake in
-      # one of them would turn the required "Test and Lint" into `cancelled`,
-      # which blocks the merge. Today a maintainer can merge with sftp red, and
-      # that has to stay true.
-      #
-      # These steps run last so the `if: always()` artifact upload above still
-      # captures logs and diagnostics before the run goes away.
-      - name: Annotate early-stop reason
-        if: failure() && github.event_name == 'pull_request'
-        run: |
-          echo "## CI early-stop" >> "$GITHUB_STEP_SUMMARY"
-          echo "Job \`${GITHUB_JOB}\` (Test and Lint) failed; cancelling run ${GITHUB_RUN_ID} to free runners." >> "$GITHUB_STEP_SUMMARY"
-          echo "Sibling jobs showing **cancelled** were stopped by this job, not by their own failure." >> "$GITHUB_STEP_SUMMARY"
-
-      # curl rather than `gh`: every existing `gh` call in this repo runs on
-      # ubuntu-latest, and the sm-standard-* images are custom and trimmed (they
-      # ship no C toolchain, see the e2e job below), so `gh` is not known to
-      # exist here.
-      #
-      # Fork PRs are excluded explicitly instead of relying on the error path:
-      # their GITHUB_TOKEN is forced read-only and job-level permissions cannot
-      # raise it, so the call would always 403. Skipping keeps their logs clean.
-      - name: Cancel run on failure (same-repo PR only)
-        if: >-
-          failure() && github.event_name == 'pull_request'
-          && github.event.pull_request.head.repo.full_name == github.repository
-        continue-on-error: true
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          curl -fsS -X POST \
-            -H "Authorization: Bearer ${GH_TOKEN}" \
-            -H "Accept: application/vnd.github+json" \
-            -H "X-GitHub-Api-Version: 2022-11-28" \
-            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}/cancel" || true
-
  # Dedicated serial lane for the ILM / lifecycle integration tests. These tests
  # drive the object layer through process-global singletons (the GLOBAL_ENV
  # ECStore, the global tier-config manager, background-expiry workers) and bind
@@ -349,7 +256,6 @@ jobs:
  test-ilm-integration-serial:
    name: ILM Integration (serial)
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    runs-on: sm-standard-4
    timeout-minutes: 45
    env:
@@ -357,16 +263,14 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-dev
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-ilm-serial
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      # test_transition_and_restore_flows was re-enabled by rustfs/backlog#1303:
      # its "missing xl.meta on disk2" was a test-util bug (open_disk hardcoded
@@ -389,7 +293,6 @@ jobs:
  test-and-lint-rio-v2:
    name: Test and Lint (rio-v2)
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    runs-on: sm-standard-4
    timeout-minutes: 60
    env:
@@ -397,16 +300,14 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-feat-rio
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-test-rio-v2
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      - name: Run rio-v2 clippy lints
        run: cargo clippy -p rustfs -p rustfs-ecstore --all-targets --features rio-v2 -- -D warnings
@@ -419,17 +320,10 @@ jobs:
  test-and-lint-protocols:
    name: "Test and Lint (${{ matrix.features.name }})"
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    runs-on: sm-standard-4
    timeout-minutes: 60
    strategy:
-      # On a PR, one failing protocol leg is enough to know the PR is not ready,
-      # so stop the sibling leg instead of paying another ~40 minutes for it.
-      # Everywhere else (main pushes, the merge queue, the weekly schedule) keep
-      # the full signal: there we want to know whether swift AND sftp are broken,
-      # not just whichever failed first. This is the only part of the early-stop
-      # work that also covers fork PRs, since it needs no token.
-      fail-fast: ${{ github.event_name == 'pull_request' }}
+      fail-fast: false
      matrix:
        features:
          - name: swift
@@ -441,16 +335,14 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-feat-proto
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-test-${{ matrix.features.name }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      - name: Run clippy with ${{ matrix.features.name }}
        run: |
@@ -463,7 +355,6 @@ jobs:
  build-rustfs-debug-binary:
    name: Build RustFS Debug Binary
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    runs-on: sm-standard-4
    timeout-minutes: 30
    env:
@@ -471,19 +362,17 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-dev
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-rustfs-debug-binary
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Build debug binary
-        run: cargo build -p rustfs --bins --features e2e-test-hooks
+        run: cargo build -p rustfs --bins

      - name: Upload debug binary
        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
@@ -496,7 +385,6 @@ jobs:
  build-rustfs-debug-binary-rio-v2:
    name: Build RustFS Debug Binary (rio-v2)
    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    runs-on: sm-standard-4
    timeout-minutes: 30
    env:
@@ -504,19 +392,17 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-feat-rio
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-rustfs-debug-binary-rio-v2
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Build debug binary with rio-v2
-        run: cargo build -p rustfs --bins --features rio-v2,e2e-test-hooks
+        run: cargo build -p rustfs --bins --features rio-v2

      - name: Upload debug binary
        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
@@ -528,14 +414,6 @@ jobs:

  uring-integration:
    name: io_uring Integration (real)
-    # The pull_request trigger includes `closed` purely so the concurrency
-    # group cancels in-flight runs of a closed PR; every other job opts out of
-    # that run with this guard (or is skipped through its `needs` chain). This
-    # job had neither, so each closed/merged PR really ran the whole io_uring
-    # suite (measured 4m17s / 7m19s / 7m31s on runs 30678272341 / 30678117601 /
-    # 30662728539) and kept the cancellation run in progress for minutes.
-    if: github.event_name != 'pull_request' || github.event.action != 'closed'
-    needs: [ quick-checks ]
    # GitHub-hosted ubuntu-latest runs a recent kernel with io_uring and, unlike
    # a container, applies no seccomp filter that would block io_uring_setup — so
    # the probe succeeds and the tests exercise the real UringBackend/FdCache/
@@ -546,24 +424,17 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          # Keeps its own key rather than joining ci-dev. rust-cache's key is
-          # built from runner.os/arch plus rustc and lockfile fingerprints — it
-          # does NOT include the runner label or image. ubuntu-latest and
-          # sm-standard-4 are therefore indistinguishable to it, so sharing a key
-          # would let two different system images overwrite each other's
-          # artifacts, and would make a 2-core hosted runner unpack ci-dev's ~3GB
-          # instead of this lane's ~1.3GB. cache-warm.yml warms this key on
-          # ubuntu-latest for the same reason.
          cache-shared-key: ci-uring
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
+
+      - name: Install build dependencies
+        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler

      # ext4 supports O_DIRECT; the runner's default TMPDIR may sit on tmpfs or
      # overlayfs, where open(O_DIRECT) returns EINVAL/EOPNOTSUPP and the native
@@ -590,17 +461,7 @@ jobs:
          RUSTFS_IO_URING_READ_ENABLE: "true"
          RUSTFS_URING_TESTS_MUST_RUN: "1"
          TMPDIR: /mnt/rustfs-odirect
-        # --lib narrows what gets compiled, not what gets run: every selected
-        # test lives in the lib target. The 7 integration binaries under
-        # crates/ecstore/tests/ each reported "running 0 tests" here, so they
-        # were compiled and linked for nothing.
-        #
-        # The `uring_` filter must stay exactly as it is. libtest matches on
-        # substring, so it also selects names containing `during_` — 6 of the 18
-        # selected tests are such incidental matches. Narrowing the filter to
-        # `io_uring` would silently drop them, which is a coverage change.
-        # scripts/check_uring_lane_lib_only.sh guards the --lib precondition.
-        run: cargo test -p rustfs-ecstore --lib uring_ -- --test-threads=1 --nocapture
+        run: cargo test -p rustfs-ecstore uring_ -- --test-threads=1 --nocapture

  e2e-tests:
    name: End-to-End Tests
@@ -610,8 +471,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      # Full setup with dependency caching: the smoke-suite step below
      # compiles the e2e_test crate, which pulls in most of the workspace.
@@ -620,9 +479,9 @@ jobs:
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-dev
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-e2e
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      # Download after the cache restore so the freshly built binary from the
      # build job always wins over anything restored into target/debug.
@@ -696,16 +555,14 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
-          cache-shared-key: ci-dev
-          cache-save-if: 'false'
-          install-build-packaging-tools: 'false'
+          cache-shared-key: ci-e2e
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      # Download after the cache restore so the freshly built binary from the
      # build job always wins over anything restored into target/debug.
@@ -741,8 +598,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Clean up previous test run
        run: |
@@ -797,8 +652,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Download debug binary
        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
@@ -859,20 +712,12 @@ jobs:
  # evaluates ILM within ~2s of the due time, well inside the poll window.
  s3-lifecycle-behavior-tests:
    name: S3 Lifecycle Behavior Tests
-    # Also gated on e2e-tests, matching s3-implemented-tests: when the e2e smoke
-    # suite is already red this lane cannot tell us anything new, and it holds a
-    # sm-standard-4 for up to 30 minutes doing so. Both lanes only download the
-    # prebuilt debug binary (no cargo build), and s3-implemented-tests — which
-    # already waits on e2e-tests — finishes later anyway, so a green PR's total
-    # wall clock is unchanged.
-    needs: [ build-rustfs-debug-binary, e2e-tests ]
+    needs: [ build-rustfs-debug-binary ]
    runs-on: sm-standard-4
    timeout-minutes: 30
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Download debug binary
        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
@@ -22,18 +22,11 @@ on:
  issue_comment:
    types: [created, edited]

-# Least privilege at the top, widened per job below. This workflow runs on
-# pull_request_target and issue_comment, so it holds full secrets on every fork
-# PR and on any comment anyone writes — the one place in this repository where a
-# compromised action would be handed a repo-write token. It does not check out
-# or execute PR code, so there is no pwn-request path today, but the blast
-# radius should not depend on that staying true.
-#
-# contents: write in particular was never used: the signature records are
-# written to rustfs/cla through the scoped app token created below, and nothing
-# here writes to this repository's contents.
 permissions:
-  contents: read
+  contents: write
+  pull-requests: write
+  issues: write
+  checks: write

 concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.event.issue.number || github.ref }}
@@ -43,26 +36,14 @@ jobs:
  cancel-closed-pr-runs:
    name: Cancel Closed PR Runs
    if: github.event_name == 'pull_request_target' && github.event.action == 'closed'
-    # Echoes one line; the run exists only so the concurrency group cancels the
-    # in-flight run of a closed PR.
-    permissions: {}
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Explain cancellation run
        run: echo "PR closed; this run only cancels older runs in the same concurrency group."

  cla:
    if: ${{ (github.event_name != 'issue_comment' || github.event.issue.pull_request) && (github.event_name != 'pull_request_target' || github.event.action != 'closed') }}
-    # checks: write reports the merge-queue check run; pull-requests and issues
-    # let cla-bot comment and label. contents stays read — see the note above.
-    permissions:
-      contents: read
-      checks: write
-      issues: write
-      pull-requests: write
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    steps:
      - name: Report CLA result for merge queue
        if: github.event_name == 'merge_group'
@@ -62,16 +62,14 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
          cache-shared-key: ci-coverage
+          github-token: ${{ secrets.GITHUB_TOKEN }}
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
-          install-build-packaging-tools: 'false'

      - name: Install cargo-llvm-cov
        uses: taiki-e/install-action@bffeee26d4db9be238a4ea78d8826604ebcb594d # v2
@@ -118,8 +116,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -82,10 +82,8 @@ jobs:
      github.event_name == 'workflow_dispatch' ||
      (github.event.workflow_run.conclusion == 'success' &&
       github.event.workflow_run.event == 'push' &&
-       github.event.workflow_run.head_branch != 'main' &&
-       !contains(github.event.workflow_run.head_branch, '-preview'))
+       github.event.workflow_run.head_branch != 'main')
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    outputs:
      should_build: ${{ steps.check.outputs.should_build }}
      should_push: ${{ steps.check.outputs.should_push }}
@@ -98,18 +96,11 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          persist-credentials: false
          # For workflow_run events, checkout the specific commit that triggered the workflow
          ref: ${{ github.event.workflow_run.head_sha || github.sha }}

      - name: Check build conditions
        id: check
-        env:
-          # dispatch inputs via env, not `${{ }}` interpolation: they are
-          # free-form strings and would otherwise be evaluated by bash.
-          INPUT_VERSION: ${{ github.event.inputs.version }}
-          INPUT_PUSH_IMAGES: ${{ github.event.inputs.push_images }}
-          INPUT_FORCE_REBUILD: ${{ github.event.inputs.force_rebuild }}
        run: |
          should_build=false
          should_push=false
@@ -210,9 +201,9 @@ jobs:

          elif [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
            # Manual trigger
-            input_version="$INPUT_VERSION"
+            input_version="${{ github.event.inputs.version }}"
            version="${input_version}"
-            should_push="$INPUT_PUSH_IMAGES"
+            should_push="${{ github.event.inputs.push_images }}"
            should_build=true

            # Get short SHA
@@ -220,7 +211,7 @@ jobs:

            echo "🎯 Manual Docker build triggered:"
            echo "   📋 Requested version: $input_version"
-            echo "   🔧 Force rebuild: $INPUT_FORCE_REBUILD"
+            echo "   🔧 Force rebuild: ${{ github.event.inputs.force_rebuild }}"
            echo "   🚀 Push images: $should_push"

            case "$input_version" in
@@ -229,13 +220,6 @@ jobs:
                create_latest=true
                echo "🚀 Building with latest stable release version"
                ;;
-              *-preview*)
-                build_type="preview"
-                is_prerelease=true
-                should_build=false
-                should_push=false
-                echo "⏭️  Preview tags do not publish Docker images"
-                ;;
              # Prerelease versions (must match first, more specific)
              v*alpha*|v*beta*|v*rc*|*alpha*|*beta*|*rc*)
                build_type="prerelease"
@@ -306,8 +290,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Login to Docker Hub
        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3
@@ -343,28 +325,32 @@ jobs:
          CREATE_LATEST="${{ needs.build-check.outputs.create_latest }}"
          VARIANT_SUFFIX="${{ matrix.suffix }}"

-          # Convert version format for Dockerfile compatibility. The former
-          # DOCKER_CHANNEL was "release" down every branch and was passed as a
-          # build-arg no Dockerfile declares, so it is gone.
+          # Convert version format for Dockerfile compatibility
          case "$VERSION" in
            "latest")
+              # For stable latest, use RELEASE=latest + release CHANNEL
              DOCKER_RELEASE="latest"
+              DOCKER_CHANNEL="release"
              ;;
            v*)
              # For versioned releases (v1.0.0), remove 'v' prefix for Dockerfile
              DOCKER_RELEASE="${VERSION#v}"
+              DOCKER_CHANNEL="release"
              ;;
            *)
              # For other versions, pass as-is
              DOCKER_RELEASE="${VERSION}"
+              DOCKER_CHANNEL="release"
              ;;
          esac

          echo "docker_release=$DOCKER_RELEASE" >> "$GITHUB_OUTPUT"
+          echo "docker_channel=$DOCKER_CHANNEL" >> "$GITHUB_OUTPUT"

          echo "🐳 Docker build parameters:"
          echo "  - Original version: $VERSION"
          echo "  - Docker RELEASE: $DOCKER_RELEASE"
+          echo "  - Docker CHANNEL: $DOCKER_CHANNEL"

          # Generate tags based on build type
          # Only support release and prerelease builds (no development builds)
@@ -418,24 +404,18 @@ jobs:
          push: ${{ needs.build-check.outputs.should_push == 'true' }}
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
-          # No layer cache. This build compiles nothing — it downloads a
-          # release zip and runs apk/apt — so the cache could only save the
-          # minute or two those take, while creating a correctness problem: with
-          # RELEASE=latest the binary URL is resolved by curl *inside* a RUN
-          # layer, and the layer key does not include what that resolved to. A
-          # rebuild at the same RELEASE value (dispatch with version=latest, or
-          # a re-run of the same version) would hit the old layer and ship the
-          # previous release's binary. mode=max also consumed the same 10GB
-          # Actions cache quota the Rust lanes are fighting over.
-          #
-          # Only RELEASE is passed: it is the sole build-arg the Dockerfiles
-          # declare besides TARGETARCH. BUILDTIME, VERSION, BUILD_TYPE, REVISION
-          # and CHANNEL were never read by any stage (and BUILDTIME's $(date ...)
-          # was a literal here, not a shell substitution). BUILD_DATE and VCS_REF
-          # are declared by the Dockerfiles but deliberately left unset —
-          # supplying them would change the published image labels.
+          cache-from: |
+            type=gha,scope=docker-${{ matrix.variant }}
+          cache-to: |
+            type=gha,mode=max,scope=docker-${{ matrix.variant }}
          build-args: |
+            BUILDTIME=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+            VERSION=${{ needs.build-check.outputs.version }}
+            BUILD_TYPE=${{ needs.build-check.outputs.build_type }}
+            REVISION=${{ github.sha }}
            RELEASE=${{ steps.meta.outputs.docker_release }}
+            CHANNEL=${{ steps.meta.outputs.docker_channel }}
+            BUILDKIT_INLINE_CACHE=1
          provenance: true
          sbom: true
          # Add retry mechanism by splitting the build process
@@ -451,7 +431,6 @@ jobs:
    needs: [ build-check, build-docker ]
    if: needs.build-check.outputs.should_build == 'true' && needs.build-check.outputs.should_push == 'true'
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    permissions:
      contents: read
      security-events: write
@@ -506,7 +485,6 @@ jobs:
    needs: [ build-check, build-docker ]
    if: always() && needs.build-check.outputs.should_build == 'true'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Docker build completion summary
        run: |
@@ -64,16 +64,14 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
          cache-shared-key: ci-e2e-repl
+          github-token: ${{ secrets.GITHUB_TOKEN }}
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
-          install-build-packaging-tools: 'false'

      # awscurl lets the STS dual-node test actually exercise its path. Without
      # it the test skips gracefully with a visible log line
@@ -126,8 +124,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -45,13 +45,6 @@
 # The PR gate (ci.yml s3-implemented-tests) is unaffected: it avoids Docker
 # via DEPLOY_MODE=binary and defers all pip setup to run.sh's self-bootstrap.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: e2e-s3tests

 on:
@@ -142,8 +135,6 @@ jobs:
      TEST_MODE: ${{ matrix.test-mode }}
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      # Provision Python explicitly rather than trusting the runner image to
      # ship a working pip (ci-1: a bare python3 without pip is what broke the
@@ -363,8 +354,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -12,13 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: Fuzz

 on:
@@ -66,7 +59,6 @@ jobs:
    name: Cancel Closed PR Runs
    if: github.event_name == 'pull_request' && github.event.action == 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Explain cancellation run
        run: echo "PR closed; this run only cancels older runs in the same concurrency group."
@@ -87,14 +79,13 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: nightly
          cache-shared-key: fuzz-${{ hashFiles('fuzz/Cargo.lock') }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
          cache-save-if: ${{ github.ref == 'refs/heads/main' || github.event_name == 'schedule' }}

      - name: Install cargo-fuzz
@@ -154,8 +145,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Download prebuilt fuzz binaries
        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
@@ -211,8 +200,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Download prebuilt fuzz binaries
        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
@@ -260,8 +247,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -32,14 +32,12 @@ permissions:
 jobs:
  build-helm-package:
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    if: |
-      (github.event_name == 'workflow_dispatch' && !contains(github.event.inputs.version, '-preview')) ||
+      github.event_name == 'workflow_dispatch' ||
      (
        github.event.workflow_run.conclusion == 'success' &&
        github.event.workflow_run.event == 'push' &&
-        contains(github.event.workflow_run.head_branch, '.') &&
-        !contains(github.event.workflow_run.head_branch, '-preview')
+        contains(github.event.workflow_run.head_branch, '.')
      )

    outputs:
@@ -50,26 +48,16 @@ jobs:
    steps:
      - name: Checkout helm chart repo
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

-      # Both inputs reach the shell through env rather than `${{ }}`
-      # interpolation. A git ref name may contain `$(...)` — anything without a
-      # space is a legal tag — and interpolation pastes it into the script
-      # verbatim, where bash would run it. Reading "$RAW_INPUT" instead makes it
-      # data.
      - name: Normalize release version
        id: version
-        env:
-          RAW_INPUT: ${{ github.event.inputs.version }}
-          RAW_BRANCH: ${{ github.event.workflow_run.head_branch }}
        run: |
          set -eux

          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            RAW="$RAW_INPUT"
+            RAW="${{ github.event.inputs.version }}"
          else
-            RAW="$RAW_BRANCH"
+            RAW="${{ github.event.workflow_run.head_branch }}"
          fi

          case "$RAW" in
@@ -84,13 +72,10 @@ jobs:
          ./scripts/helm_chart_version.sh "$RAW_TAG"

      - name: Replace chart version and app version
-        env:
-          CHART_VERSION: ${{ steps.version.outputs.chart_version }}
-          APP_VERSION: ${{ steps.version.outputs.app_version }}
        run: |
          set -eux
-          sed -i -E "s/^version:.*/version: \"${CHART_VERSION}\"/" helm/rustfs/Chart.yaml
-          sed -i -E "s/^appVersion:.*/appVersion: \"${APP_VERSION}\"/" helm/rustfs/Chart.yaml
+          sed -i -E 's/^version:.*/version: "${{ steps.version.outputs.chart_version }}"/' helm/rustfs/Chart.yaml
+          sed -i -E 's/^appVersion:.*/appVersion: "${{ steps.version.outputs.app_version }}"/' helm/rustfs/Chart.yaml

      - name: Set up Helm
        uses: azure/setup-helm@b9e51907a09c216f16ebe8536097933489208112 # v4.3.0
@@ -115,7 +100,6 @@ jobs:

  publish-helm-package:
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    needs: [ build-helm-package ]
    if: needs.build-helm-package.result == 'success'

@@ -123,8 +107,6 @@ jobs:
      - name: Checkout helm package repo
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          # persist-credentials-exempt: this checkout's token IS the push credential —
-          # the job git-pushes to rustfs/helm below. Clearing it breaks chart publishing.
          repository: rustfs/helm
          token: ${{ secrets.RUSTFS_HELM_PACKAGE }}

@@ -140,19 +122,11 @@ jobs:
      - name: Generate index
        run: helm repo index . --url https://charts.rustfs.com

-      # app_version is derived from the triggering tag name, and this job holds
-      # the cross-repository push token with rustfs/helm already checked out —
-      # the worst place in the repo to paste an attacker-influenced string into
-      # a shell line. Passed through env so bash treats it as data.
      - name: Push helm package and index file
-        env:
-          GIT_USERNAME: ${{ secrets.USERNAME }}
-          GIT_EMAIL: ${{ secrets.EMAIL_ADDRESS }}
-          APP_VERSION: ${{ needs.build-helm-package.outputs.app_version }}
        run: |
          set -eux
-          git config --global user.name "${GIT_USERNAME}"
-          git config --global user.email "${GIT_EMAIL}"
+          git config --global user.name "${{ secrets.USERNAME }}"
+          git config --global user.email "${{ secrets.EMAIL_ADDRESS }}"
          git add .
-          git commit -m "Update rustfs helm package with ${APP_VERSION}." || echo "No changes to commit"
+          git commit -m "Update rustfs helm package with ${{ needs.build-helm-package.outputs.app_version }}." || echo "No changes to commit"
          git push origin main
@@ -12,13 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: "issue-translator"
 on:
  issue_comment:
@@ -33,7 +26,6 @@ permissions:
 jobs:
  build:
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - uses: usthe/issues-translate-action@b41f55ddc81d7d54bd542a4f289fe28ec081898e # v2.7
        with:
@@ -23,13 +23,6 @@
 # Runner: GitHub-hosted `ubuntu-latest`. It reliably ships Docker + Python,
 # unlike the self-hosted fleet, whose pods drift in Docker/pip availability
 # (see the infra note in e2e-s3tests.yml). Nightly + manual only.
-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: minio-interop

 on:
@@ -58,14 +51,13 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
        with:
          rust-version: stable
          cache-shared-key: ci-minio-interop
+          github-token: ${{ secrets.GITHUB_TOKEN }}
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}

      - name: Generate real MinIO fixtures via Docker
@@ -45,13 +45,6 @@
 # docker-capable self-hosted `dind-sm-standard-2` label was the alternative but
 # has fewer cores and reintroduces fleet-state risk for no reliability gain.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: mint

 on:
@@ -125,8 +118,6 @@ jobs:
    timeout-minutes: 120
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Enable buildx
        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
@@ -272,8 +263,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -19,12 +19,9 @@ on:
  schedule:
    - cron: '0 5 * * 0' # Weekly on Sunday 05:00 UTC (staggered after the midnight ci/build crons)

-# GITHUB_TOKEN only needs to read the repository here: the branch push and the
-# pull request are both created by update-flake-lock using the
-# FLAKE_UPDATE_TOKEN PAT below, not by this token. Leaving write on it hands a
-# repo-write credential to an unattended weekly job that does not use it.
 permissions:
-  contents: read
+  contents: write
+  pull-requests: write

 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
@@ -40,10 +37,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        # persist-credentials-exempt: update-flake-lock pushes the branch and opens
-        # the PR. It passes FLAKE_UPDATE_TOKEN to create-pull-request itself rather
-        # than reusing .git/config, but that is unverified — exempt until a
-        # workflow_dispatch run confirms it (rustfs/backlog#1602).

      - name: Install Nix
        uses: DeterminateSystems/determinate-nix-action@629b284231c2a82554b724e357e47fc6020833c8 # v3
@@ -12,13 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: Nix CI

 on:
@@ -53,7 +46,6 @@ jobs:
    name: Cancel Closed PR Runs
    if: github.event_name == 'pull_request' && github.event.action == 'closed'
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - name: Explain cancellation run
        run: echo "PR closed; this run only cancels older runs in the same concurrency group."
@@ -71,8 +63,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Install Nix
        uses: DeterminateSystems/determinate-nix-action@4eea0b33e3d1f02ecfe37cf16e7204c424009606 # v3.21.0
@@ -22,13 +22,6 @@
 # a deliberate correctness cost (e.g. the #4221 fsync durability fix) is
 # recorded but does not block (rustfs/backlog#935 correction 1).

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: Performance A/B

 on:
@@ -99,8 +92,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Setup Rust environment
        uses: ./.github/actions/setup
@@ -108,6 +99,7 @@ jobs:
          rust-version: stable
          cache-shared-key: warp-ab-${{ hashFiles('**/Cargo.lock') }}
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Build release rustfs
        run: cargo build --release --bin rustfs
@@ -150,7 +142,6 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          persist-credentials: false
          fetch-depth: 0 # baseline is built from origin/main

      - name: Setup Rust environment
@@ -159,6 +150,7 @@ jobs:
          rust-version: stable
          cache-shared-key: warp-ab-${{ hashFiles('**/Cargo.lock') }}
          cache-save-if: ${{ github.ref == 'refs/heads/main' }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Install warp
        run: |
@@ -170,15 +162,13 @@ jobs:

      - name: Decide exemption
        id: exempt
-        env:
-          INPUT_ALLOW_REGRESSION: ${{ github.event.inputs.allow_regression }}
        run: |
          allow="false"
          if [[ "${{ github.event_name }}" == "pull_request" ]] \
            && ${{ contains(github.event.pull_request.labels.*.name, 'perf-deliberate-tradeoff') }}; then
            allow="true"
          fi
-          if [[ "$INPUT_ALLOW_REGRESSION" == "true" ]]; then
+          if [[ "${{ github.event.inputs.allow_regression }}" == "true" ]]; then
            allow="true"
          fi
          echo "allow_regression=$allow" >> "$GITHUB_OUTPUT"
@@ -234,8 +224,6 @@ jobs:

      - name: Run warp A/B and gate
        id: ab
-        env:
-          INPUT_DURATION: ${{ github.event.inputs.duration }}
        run: |
          set -euo pipefail
          # Budget note: with perf-3's cached baseline the nightly does no source
@@ -246,7 +234,7 @@ jobs:
          # budget, which the rig's previous 60s health poll undershot (the first
          # two nightly failures). perf-6 recalibrates these once the noise study
          # lands.
-          duration="${INPUT_DURATION:-12s}"
+          duration="${{ github.event.inputs.duration || '12s' }}"
          baseline_sha="${{ steps.commits.outputs.baseline_sha }}"
          candidate_sha="${{ steps.commits.outputs.candidate_sha }}"
          baseline_hit="${{ steps.baseline_cache.outputs.cache-hit }}"
@@ -397,8 +385,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -1,81 +0,0 @@
-# Copyright 2026 RustFS Team
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Asserts that the self-hosted runners are still ephemeral — one job per pod.
-#
-# This repository is public and its pull_request jobs run on those runners,
-# executing the PR's own build.rs, proc-macros and tests. The only thing keeping
-# that code from reaching a later job is that each ARC pod handles exactly one
-# job and is then destroyed. That guarantee lives in the ARC scale-set
-# configuration, outside this repository, where it can be changed without any PR
-# — so it is asserted here from the outside, against real run data, instead of
-# being assumed.
-#
-# Monthly rather than per-PR: the property changes only when someone
-# reconfigures the scale set, and the check costs a few dozen API calls.
-# See docs/ci/runners.md and rustfs/backlog#1602.
-
-name: Runner Hygiene
-
-on:
-  schedule:
-    - cron: "0 6 1 * *" # Monthly, 1st at 06:00 UTC (after the daily audit cron)
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: runner-hygiene
-  cancel-in-progress: false
-
-jobs:
-  check-ephemerality:
-    name: Check runner ephemerality
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-
-      # Exit 2 (inconclusive / broken) is deliberately not a pass: a window
-      # where every sm-* job was still queued would otherwise look identical to
-      # a clean bill of health.
-      - name: Assert one job per self-hosted runner
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ./scripts/ci/check_runner_ephemerality.sh 40
-
-  alert-on-failure:
-    name: Alert on scheduled failure
-    needs: [check-ephemerality]
-    # Same ci-8 mechanism as coverage.yml, audit.yml and the nightly lanes:
-    # scheduled runs file a tracking issue, manual dispatch stays quiet so
-    # debugging never produces a spurious alert.
-    if: always() && github.event_name == 'schedule' && contains(needs.*.result, 'failure')
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
-      - name: Open or update failure-tracking issue
-        uses: ./.github/actions/schedule-failure-issue
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -24,13 +24,6 @@
 # The run itself is expected to end red (the forced failure); only the
 # alert-on-failure job result matters.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: Schedule Failure Alert Drill

 on:
@@ -63,8 +56,6 @@ jobs:
      issues: write
    steps:
      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false
      - name: Open or update failure-tracking issue
        uses: ./.github/actions/schedule-failure-issue
        with:
@@ -12,13 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-# DISABLED. This workflow is switched off in the repository's Actions settings
-# (state: disabled_manually) and does not run on any trigger, including its cron
-# and workflow_dispatch. That state lives in GitHub's UI and is invisible when
-# reading this file, which has already misled at least one audit — hence this
-# banner. Re-enabling is a UI action; anyone doing so should first check that the
-# workflow still matches the current CI layout. See rustfs/backlog#1603.
-#
 name: "Mark stale issues"
 on:
  schedule:
@@ -27,7 +20,6 @@ on:
 jobs:
  stale:
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    steps:
      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9
        with:
@@ -15,7 +15,6 @@ concurrency:
 jobs:
  update:
    runs-on: ubuntu-latest
-    timeout-minutes: 10
    steps:
      - uses: overtrue/repo-visuals-action@72f34d24769ff5d341956da2f23952594ef2f1e2 # v1.3.0
        with:
@@ -105,78 +105,33 @@ CI) fails the build if anything is committed under `docs/superpowers/`, even via

 ## Verification Before PR

-Convert changes into independently verifiable outcomes. This section controls
-agent-run local validation; preparing a commit or PR does not by itself require
-the broadest gate. Inspect only the final task-owned diff, classify it by
-behavioral impact rather than line count or path alone, and run the smallest
-set of checks that provides meaningful coverage. Do not let unrelated
-worktree changes or a generic contributor checklist expand the scope.
-Non-exempt changes must also pass Adversarial Validation (next section) before
-the checks below count as completion.
+Convert changes into independently verifiable outcomes. Prefer focused tests for behavior changes and run the relevant checks before declaring completion.
+Non-exempt changes must also pass Adversarial Validation (next section) before the checks below count as completion.

-### Validation floor
+For code changes, run and pass the following before opening a PR:

- Every change that is not documentation-only must finish with
-  `cargo fmt --all --check` passing. An umbrella gate that runs this exact
-  check satisfies the requirement; do not run it twice. Use `cargo fmt --all`
-  only when formatting needs to be fixed. Run the configured formatter or
-  validator for other changed languages when one exists.
- Documentation-only or instruction-only means all task-owned changes are
-  prose or documentation assets and cannot affect runtime, builds, CI,
-  dependencies, generated code, or tests. Run `git diff --check` and any
-  relevant documentation guard, but skip Cargo formatting, compilation,
-  Clippy, tests, `make pre-commit`, and `make pre-pr`.
- Behavior changes require relevant existing or new tests. Prefer the most
-  focused test or affected package. A passing targeted test can also provide
-  sufficient compilation coverage when it builds every changed target and
-  feature involved; do not add a redundant `cargo check` in that case.
- `cargo check` supplements compilation coverage; it never substitutes for a
-  behavioral test. If a relevant test cannot reasonably be added or run, use
-  the narrowest compilation check and report the reason and remaining risk.
+```bash
+make pre-pr
+```

-### Validation tiers
+Before committing code changes, prefer focused verification for the touched
+surface and use the faster local gate when a broad smoke check is needed:

-1. **Documentation/instruction-only:** Apply the exemption above. Run a guard
-   such as `make doc-paths-check` only when it is relevant to the edited text.
-2. **Non-behavioral source change:** For comments, formatting, or another
-   demonstrably non-executable change, run the formatting floor. Compilation,
-   Clippy, and tests may be skipped only when the edit cannot affect
-   compilation or runtime behavior; run targeted doctests if executable
-   documentation examples changed.
-3. **Localized or bounded behavior change:** Run the formatting floor and the
-   narrowest relevant tests. Add package-scoped `cargo check` or Clippy only
-   for changed targets, features, APIs, error handling, async behavior, or
-   control flow not already covered. When several crates are affected but the
-   dependency set is identifiable, validate those packages and known
-   dependents instead of the whole workspace. Use `make pre-commit` only when
-   a repository-wide fast gate adds useful confidence beyond those checks.
-4. **Broad or high-risk change:** Run `make pre-pr` only when targeted coverage
-   cannot bound the impact, including:
-   - dependency, feature, build-script, procedural-macro, code-generation,
-     toolchain, or CI changes that alter compilation or the test matrix;
-   - cross-crate public APIs, shared foundational code, or broad refactors with
-     an unbounded dependent set;
-   - locking, storage durability or formats, erasure coding, replication,
-     RPC/protocol compatibility, IAM/KMS/auth, cryptography, or other
-     security-sensitive behavior;
-   - a targeted check that reveals wider impact, an explicit user request, or
-     a release policy that requires the full gate.
+```bash
+make pre-commit
+```

-Documentation-only and non-behavioral classifications take precedence over
-path-based triggers. A small diff can still be high-risk, while a CI comment,
-manifest comment, or release-note edit does not require full validation.
+For migration batches, do not run the full `make pre-pr` gate before every
+intermediate commit. Use focused tests and `make pre-commit` during
+development, then reserve `make pre-pr` for the final PR-ready branch.

-`make pre-pr` includes `make pre-commit` coverage. Never run both for the same
-unchanged diff, and do not repeat equivalent checks during PR preparation or
-because a local hook already ran them. Rerun only checks whose scope is affected
-by later edits. Full workspace checks do not replace a relevant integration or
-E2E test for changed behavior; run that focused test when required and
-available, or report why it was not run and the remaining risk.
+Before pushing code changes, make sure formatting is clean:

-If `make` is unavailable, run the equivalent checks defined under
-`.config/make/`. At handoff, list the checks actually run, checks intentionally
-skipped, and the reason for the selected tier.
+- Run `cargo fmt --all`.
+- Run `cargo fmt --all --check` and ensure no files are modified unexpectedly.

+If `make` is unavailable, run the equivalent checks defined under `.config/make/`.
+Documentation-only or instruction-only changes are exempt from the verification commands above (including the `.config/make/` equivalents), though any locally installed git pre-commit hooks may still run on commit unless explicitly skipped.
 After build-based verification completes, clean generated build artifacts before wrapping up to avoid unnecessary disk usage.
 Do not open a PR with code changes when the required checks fail.
 Make a failing check pass by fixing the cause, never by weakening the gate:
@@ -69,7 +69,7 @@ edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/rustfs/rustfs"
 rust-version = "1.97.1"
-version = "1.0.0-beta.12"
+version = "1.0.0-beta.11"
 homepage = "https://rustfs.com"
 description = "RustFS is a high-performance distributed object storage software built using Rust, one of the most popular languages worldwide. "
 keywords = ["RustFS", "Minio", "object-storage", "filesystem", "s3"]
@@ -86,58 +86,58 @@ redundant_clone = "warn"

 [workspace.dependencies]
 # RustFS Internal Crates
-rustfs = { path = "./rustfs", version = "1.0.0-beta.12" }
-rustfs-heal = { path = "crates/heal", version = "1.0.0-beta.12" }
-rustfs-audit = { path = "crates/audit", version = "1.0.0-beta.12" }
-rustfs-checksums = { path = "crates/checksums", version = "1.0.0-beta.12" }
-rustfs-common = { path = "crates/common", version = "1.0.0-beta.12" }
-rustfs-data-usage = { path = "crates/data-usage", version = "1.0.0-beta.12" }
-rustfs-config = { path = "./crates/config", version = "1.0.0-beta.12" }
-rustfs-concurrency = { path = "./crates/concurrency", version = "1.0.0-beta.12" }
-rustfs-credentials = { path = "crates/credentials", version = "1.0.0-beta.12" }
-rustfs-crypto = { path = "crates/crypto", version = "1.0.0-beta.12" }
-rustfs-ecstore = { path = "crates/ecstore", version = "1.0.0-beta.12" }
-rustfs-filemeta = { path = "crates/filemeta", version = "1.0.0-beta.12" }
-rustfs-iam = { path = "crates/iam", version = "1.0.0-beta.12" }
-rustfs-keystone = { path = "crates/keystone", version = "1.0.0-beta.12" }
-rustfs-lifecycle = { path = "crates/lifecycle", version = "1.0.0-beta.12" }
-rustfs-kms = { path = "crates/kms", version = "1.0.0-beta.12" }
-rustfs-lock = { path = "crates/lock", version = "1.0.0-beta.12" }
-rustfs-madmin = { path = "crates/madmin", version = "1.0.0-beta.12" }
-rustfs-notify = { path = "crates/notify", version = "1.0.0-beta.12" }
-rustfs-io-metrics = { path = "crates/io-metrics", version = "1.0.0-beta.12" }
-rustfs-io-core = { path = "crates/io-core", version = "1.0.0-beta.12" }
-rustfs-object-capacity = { path = "crates/object-capacity", version = "1.0.0-beta.12" }
-rustfs-object-data-cache = { path = "crates/object-data-cache", version = "1.0.0-beta.12" }
-rustfs-log-analyzer = { path = "crates/log-analyzer", version = "1.0.0-beta.12" }
-rustfs-obs = { path = "crates/obs", version = "1.0.0-beta.12" }
-rustfs-policy = { path = "crates/policy", version = "1.0.0-beta.12" }
-rustfs-protos = { path = "crates/protos", version = "1.0.0-beta.12" }
-rustfs-protocols = { path = "crates/protocols", version = "1.0.0-beta.12" }
-rustfs-replication = { path = "crates/replication", version = "1.0.0-beta.12" }
-rustfs-rio = { path = "crates/rio", version = "1.0.0-beta.12" }
-rustfs-rio-v2 = { path = "crates/rio-v2", version = "1.0.0-beta.12" }
-rustfs-s3-types = { path = "crates/s3-types", version = "1.0.0-beta.12" }
-rustfs-s3-ops = { path = "crates/s3-ops", version = "1.0.0-beta.12" }
-rustfs-s3select-api = { path = "crates/s3select-api", version = "1.0.0-beta.12" }
-rustfs-s3select-query = { path = "crates/s3select-query", version = "1.0.0-beta.12" }
-rustfs-scanner = { path = "crates/scanner", version = "1.0.0-beta.12" }
-rustfs-security-governance = { path = "crates/security-governance", version = "1.0.0-beta.12" }
-rustfs-extension-schema = { path = "crates/extension-schema", version = "1.0.0-beta.12" }
-rustfs-signer = { path = "crates/signer", version = "1.0.0-beta.12" }
-rustfs-storage-api = { path = "crates/storage-api", version = "1.0.0-beta.12" }
-rustfs-trusted-proxies = { path = "crates/trusted-proxies", version = "1.0.0-beta.12" }
-rustfs-targets = { path = "crates/targets", version = "1.0.0-beta.12" }
-rustfs-test-utils = { path = "crates/test-utils", version = "1.0.0-beta.12" }
-rustfs-tls-runtime = { path = "crates/tls-runtime", version = "1.0.0-beta.12" }
-rustfs-utils = { path = "crates/utils", version = "1.0.0-beta.12" }
-rustfs-zip = { path = "./crates/zip", version = "1.0.0-beta.12" }
+rustfs = { path = "./rustfs", version = "1.0.0-beta.11" }
+rustfs-heal = { path = "crates/heal", version = "1.0.0-beta.11" }
+rustfs-audit = { path = "crates/audit", version = "1.0.0-beta.11" }
+rustfs-checksums = { path = "crates/checksums", version = "1.0.0-beta.11" }
+rustfs-common = { path = "crates/common", version = "1.0.0-beta.11" }
+rustfs-data-usage = { path = "crates/data-usage", version = "1.0.0-beta.11" }
+rustfs-config = { path = "./crates/config", version = "1.0.0-beta.11" }
+rustfs-concurrency = { path = "./crates/concurrency", version = "1.0.0-beta.11" }
+rustfs-credentials = { path = "crates/credentials", version = "1.0.0-beta.11" }
+rustfs-crypto = { path = "crates/crypto", version = "1.0.0-beta.11" }
+rustfs-ecstore = { path = "crates/ecstore", version = "1.0.0-beta.11" }
+rustfs-filemeta = { path = "crates/filemeta", version = "1.0.0-beta.11" }
+rustfs-iam = { path = "crates/iam", version = "1.0.0-beta.11" }
+rustfs-keystone = { path = "crates/keystone", version = "1.0.0-beta.11" }
+rustfs-lifecycle = { path = "crates/lifecycle", version = "1.0.0-beta.11" }
+rustfs-kms = { path = "crates/kms", version = "1.0.0-beta.11" }
+rustfs-lock = { path = "crates/lock", version = "1.0.0-beta.11" }
+rustfs-madmin = { path = "crates/madmin", version = "1.0.0-beta.11" }
+rustfs-notify = { path = "crates/notify", version = "1.0.0-beta.11" }
+rustfs-io-metrics = { path = "crates/io-metrics", version = "1.0.0-beta.11" }
+rustfs-io-core = { path = "crates/io-core", version = "1.0.0-beta.11" }
+rustfs-object-capacity = { path = "crates/object-capacity", version = "1.0.0-beta.11" }
+rustfs-object-data-cache = { path = "crates/object-data-cache", version = "1.0.0-beta.11" }
+rustfs-log-analyzer = { path = "crates/log-analyzer", version = "1.0.0-beta.11" }
+rustfs-obs = { path = "crates/obs", version = "1.0.0-beta.11" }
+rustfs-policy = { path = "crates/policy", version = "1.0.0-beta.11" }
+rustfs-protos = { path = "crates/protos", version = "1.0.0-beta.11" }
+rustfs-protocols = { path = "crates/protocols", version = "1.0.0-beta.11" }
+rustfs-replication = { path = "crates/replication", version = "1.0.0-beta.11" }
+rustfs-rio = { path = "crates/rio", version = "1.0.0-beta.11" }
+rustfs-rio-v2 = { path = "crates/rio-v2", version = "1.0.0-beta.11" }
+rustfs-s3-types = { path = "crates/s3-types", version = "1.0.0-beta.11" }
+rustfs-s3-ops = { path = "crates/s3-ops", version = "1.0.0-beta.11" }
+rustfs-s3select-api = { path = "crates/s3select-api", version = "1.0.0-beta.11" }
+rustfs-s3select-query = { path = "crates/s3select-query", version = "1.0.0-beta.11" }
+rustfs-scanner = { path = "crates/scanner", version = "1.0.0-beta.11" }
+rustfs-security-governance = { path = "crates/security-governance", version = "1.0.0-beta.11" }
+rustfs-extension-schema = { path = "crates/extension-schema", version = "1.0.0-beta.11" }
+rustfs-signer = { path = "crates/signer", version = "1.0.0-beta.11" }
+rustfs-storage-api = { path = "crates/storage-api", version = "1.0.0-beta.11" }
+rustfs-trusted-proxies = { path = "crates/trusted-proxies", version = "1.0.0-beta.11" }
+rustfs-targets = { path = "crates/targets", version = "1.0.0-beta.11" }
+rustfs-test-utils = { path = "crates/test-utils", version = "1.0.0-beta.11" }
+rustfs-tls-runtime = { path = "crates/tls-runtime", version = "1.0.0-beta.11" }
+rustfs-utils = { path = "crates/utils", version = "1.0.0-beta.11" }
+rustfs-zip = { path = "./crates/zip", version = "1.0.0-beta.11" }

 # Async Runtime and Networking
 async-channel = "2.5.0"
 async_zip = { default-features = false, version = "0.0.18" }
 mysql_async = { default-features = false, version = "0.37" }
-async-compression = { version = "0.4.43" }
+async-compression = { version = "0.4.42" }
 async-recursion = "1.1.1"
 async-trait = "0.1.91"
 async-nats = { version = "0.50.0", default-features = false }
@@ -152,7 +152,7 @@ lapin = { default-features = false, version = "4.10.0" }
 hyper = { version = "1.11.0" }
 hyper-rustls = { default-features = false, version = "0.27.9" }
 hyper-util = { version = "0.1.20" }
-http = "1.5.0"
+http = "1.4.2"
 http-body = "1.1.0"
 http-body-util = "0.1.4"
 minlz = "1.2.3"
@@ -173,7 +173,7 @@ tower-http = { version = "0.7.0" }
 # Serialization and Data Formats
 apache-avro = "0.21.0"
 bytes = { version = "1.12.1" }
-bytesize = "2.6.0"
+bytesize = "2.4.2"
 byteorder = "1.5.0"
 flatbuffers = "25.12.19"
 form_urlencoded = "1.2.2"
@@ -200,7 +200,7 @@ jsonwebtoken = { version = "11.0.0" }
 openidconnect = { default-features = false, version = "4.0" }
 pbkdf2 = "0.13.0"
 rsa = { version = "=0.10.0-rc.18" }
-rustls = { default-features = false, version = "0.23.43" }
+rustls = { default-features = false, version = "0.23.42" }
 rustls-native-certs = "0.8"
 rustls-pki-types = "1.15.1"
 sha1 = "0.11.0"
@@ -227,7 +227,6 @@ atoi = "3.1.0"
 atomic_enum = "0.3.0"
 aws-config = { version = "1.10.1" }
 aws-credential-types = { version = "1.3.0" }
-aws-sdk-kms = { default-features = false, version = "1.114.0" }
 aws-sdk-s3 = { default-features = false, version = "1.140.0" }
 aws-sdk-sts = { default-features = false, version = "1.110.0" }
 aws-smithy-http-client = { default-features = false, version = "1.2.0" }
@@ -236,7 +235,7 @@ aws-smithy-types = { version = "1.6.1" }
 base64 = "0.23.0"
 base64-simd = "0.8.0"
 brotli = "8.0.4"
-clap = { version = "4.6.5" }
+clap = { version = "4.6.4" }
 const-str = { version = "1.1.0" }
 convert_case = "0.11.0"
 criterion = { version = "0.8" }
@@ -251,13 +250,12 @@ enumset = "1.1.14"
 faster-hex = "0.10.0"
 flate2 = "1.1.9"
 glob = "0.3.4"
-google-cloud-storage = "1.17.0"
-google-cloud-auth = "1.15.0"
+google-cloud-storage = "1.16.0"
+google-cloud-auth = "1.14.0"
 hashbrown = { version = "0.17.1" }
 hex = "0.4.3"
 hex-simd = "0.8.0"
 highway = { version = "1.3.0" }
-hostname = "0.4.2"
 ipnetwork = { version = "0.21.1" }
 lazy_static = "1.5.0"
 libc = "0.2.189"
@@ -267,6 +265,7 @@ memmap2 = "0.9.11"
 lz4 = "1.28.1"
 matchit = "0.9.2"
 md-5 = "0.11.0"
+md5 = "0.8.1"
 mime_guess = "2.0.5"
 moka = { version = "0.12.15" }
 netif = "0.1.6"
@@ -285,8 +284,7 @@ reed-solomon-erasure = { package = "rustfs-erasure-codec", version = "8.0.2" }
 reed-solomon-simd = "3.1.0"
 regex = { version = "1.13.1" }
 rumqttc = { package = "rumqttc-next", version = "0.33.3" }
-redis = { version = "1.5.0" }
-rustify = { version = "0.7", default-features = false }
+redis = { version = "1.4.1" }
 rustix = { version = "1.1.4" }
 rust-embed = { version = "8.12.0" }
 rustc-hash = { version = "2.1.3" }
@@ -306,7 +304,6 @@ test-case = "3.3.1"
 thiserror = "2.0.19"
 tracing = { version = "0.1.44" }
 tracing-appender = "0.2.5"
-tracing-core = "0.1.36"
 tracing-error = "0.2.1"
 tracing-opentelemetry = { version = "0.33" }
 tracing-subscriber = { version = "0.3.23" }
@@ -317,9 +314,7 @@ uuid = { version = "1.24.0" }
 vaultrs = { version = "0.8.0" }
 tar = "0.4.46"
 walkdir = "2.5.0"
-winapi-util = "0.1.11"
 windows = { version = "0.62.2" }
-windows-sys = "0.61.2"
 xxhash-rust = { version = "0.8.18" }
 zip = "8.6.0"
 zstd = "0.13.3"
@@ -341,16 +336,15 @@ libunftp = { version = "0.23.0" }
 unftp-core = "0.1.0"
 suppaftp = { version = "10.0.1" }
 rcgen = { version = "0.14.8", default-features = false, features = ["aws_lc_rs", "crypto", "pem"] }
-russh = { version = "0.62.5" }
+russh = { version = "0.62.4" }
 russh-sftp = "2.3.0"

 # WebDAV
 dav-server = "0.11.0"

 # Performance Analysis and Memory Profiling
-mimalloc = { version = "0.1.52", git = "https://github.com/xonatius/mimalloc_rust.git", rev = "1cdadea43e9c5a0f054b65be21200ce580e4eb13" }
-libmimalloc-sys = { version = "0.1.49", git = "https://github.com/xonatius/mimalloc_rust.git", rev = "1cdadea43e9c5a0f054b65be21200ce580e4eb13", features = ["extended"] }
-hotpath = { version = "0.22.0", default-features = false }
+mimalloc = "0.1.52"
+hotpath = "0.22.0"
 # Snapshot testing for output format regression detection
 insta = { version = "1.48" }

@@ -116,7 +116,7 @@ chown -R 10001:10001 data logs
 docker run -d -p 9000:9000 -p 9001:9001 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:latest

 # Using specific version
-docker run -d -p 9000:9000 -p 9001:9001 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:1.0.0-beta.12
+docker run -d -p 9000:9000 -p 9001:9001 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:1.0.0-beta.11
 ```

 If you use [podman](https://github.com/containers/podman) instead of docker, you can install the RustFS with the below command
@@ -113,7 +113,7 @@ chown -R 10001:10001 data logs
 docker run -d -p 9000:9000 -p 9001:9001 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:latest

 # 使用指定版本运行
-docker run -d -p 9000:9000 -p 9001:9001 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:1.0.0-beta.12
+docker run -d -p 9000:9000 -p 9001:9001 -v $(pwd)/data:/data -v $(pwd)/logs:/logs rustfs/rustfs:1.0.0-beta.11
 ```

 如果您通过绑定挂载启用 TLS 证书目录，也请用同样方式准备该目录：
@@ -25,33 +25,7 @@ documentation = "https://docs.rs/rustfs-audit/latest/rustfs_audit/"
 keywords = ["audit", "target", "management", "fan-out", "RustFS"]
 categories = ["web-programming", "development-tools", "asynchronous", "api-bindings"]

-[features]
-default = []
-hotpath = [
-    "hotpath/hotpath",
-    "hotpath/tokio",
-    "hotpath/futures",
-    "rustfs-config/hotpath",
-    "rustfs-s3-types/hotpath",
-    "rustfs-targets/hotpath",
-]
-hotpath-alloc = [
-    "hotpath",
-    "hotpath/hotpath-alloc",
-    "rustfs-config/hotpath-alloc",
-    "rustfs-s3-types/hotpath-alloc",
-    "rustfs-targets/hotpath-alloc",
-]
-hotpath-cpu = [
-    "hotpath",
-    "hotpath/hotpath-cpu",
-    "rustfs-config/hotpath-cpu",
-    "rustfs-s3-types/hotpath-cpu",
-    "rustfs-targets/hotpath-cpu",
-]
-
 [dependencies]
-hotpath.workspace = true
 rustfs-targets = { workspace = true }
 rustfs-config = { workspace = true, features = ["audit", "server-config-model"] }
 rustfs-s3-types = { workspace = true }
@@ -28,14 +28,7 @@ documentation = "https://docs.rs/rustfs-checksums/latest/rustfs_checksum/"
 [lints]
 workspace = true

-[features]
-default = []
-hotpath = ["hotpath/hotpath"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
-
 [dependencies]
-hotpath.workspace = true
 bytes = { workspace = true, features = ["serde"] }
 crc-fast = { workspace = true }
 http = { workspace = true }
@@ -27,14 +27,7 @@ categories = ["web-programming", "development-tools", "data-structures"]
 [lints]
 workspace = true

-[features]
-default = []
-hotpath = ["hotpath/hotpath", "hotpath/tokio"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
-
 [dependencies]
-hotpath.workspace = true
 tokio = { workspace = true, features = ["fs", "rt-multi-thread"] }
 tonic = { workspace = true, features = ["gzip", "deflate"] }
 uuid = { workspace = true, features = ["v4", "fast-rng", "macro-diagnostics"] }
@@ -1114,8 +1114,6 @@ pub struct ScannerLastMinute {
 pub struct ScannerMetricsReport {
    pub collected_at: DateTime<Utc>,
    pub current_cycle: u64,
-    #[serde(default)]
-    pub current_cycle_active: bool,
    pub current_started: DateTime<Utc>,
    pub cycles_completed_at: Vec<DateTime<Utc>>,
    pub ongoing_buckets: usize,
@@ -2053,7 +2051,7 @@ impl Metrics {
    pub fn record_scanner_transition_failed(&self, count: u64) {
        self.scanner_transition_failed.fetch_add(count, Ordering::Relaxed);
        self.record_scanner_source_failed(ScannerWorkSource::Lifecycle, count);
-        if !self.current_scan_cycle_work_active.load(Ordering::Acquire) {
+        if !self.current_scan_cycle_work_active.load(Ordering::Relaxed) {
            self.record_last_cycle_scanner_source_work(ScannerWorkSource::Lifecycle, ScannerSourceWorkUpdate::failed(count));
        }
    }
@@ -2338,21 +2336,6 @@ impl Metrics {
        *self.cycle_info.write().await = cycle;
    }

-    /// Publish a scanner cycle and its work-accounting baseline as one state transition.
-    pub async fn start_scan_cycle_work_with_cycle(&self, cycle: CurrentCycle) -> ScanCycleWorkSnapshot {
-        let mut current_cycle = self.cycle_info.write().await;
-        let snapshot = self.start_scan_cycle_work();
-        *current_cycle = Some(cycle);
-        snapshot
-    }
-
-    /// Publish the completed work snapshot and idle cycle state as one state transition.
-    pub async fn finish_scan_cycle_work_with_cycle(&self, start: ScanCycleWorkSnapshot, cycle: CurrentCycle) {
-        let mut current_cycle = self.cycle_info.write().await;
-        self.finish_scan_cycle_work(start);
-        *current_cycle = Some(cycle);
-    }
-
    /// Read the current cycle record.
    pub async fn get_cycle(&self) -> Option<CurrentCycle> {
        self.cycle_info.read().await.clone()
@@ -2481,7 +2464,7 @@ impl Metrics {
            &self.current_scan_cycle_replication_repair_work_start,
            &replication_repair_snapshot,
        );
-        self.current_scan_cycle_work_active.store(true, Ordering::Release);
+        self.current_scan_cycle_work_active.store(true, Ordering::Relaxed);
        snapshot
    }

@@ -2493,11 +2476,11 @@ impl Metrics {
        self.record_scan_cycle_work(work);
        self.record_scan_cycle_source_work(&source_work);
        self.record_scan_cycle_replication_repair_work(&replication_repair_work);
-        self.current_scan_cycle_work_active.store(false, Ordering::Release);
+        self.current_scan_cycle_work_active.store(false, Ordering::Relaxed);
    }

    pub fn current_scan_cycle_has_unresolved_heal_work(&self) -> bool {
-        if !self.current_scan_cycle_work_active.load(Ordering::Acquire) {
+        if !self.current_scan_cycle_work_active.load(Ordering::Relaxed) {
            return false;
        }

@@ -2763,41 +2746,13 @@ impl Metrics {
    pub async fn report(&self) -> ScannerMetricsReport {
        let mut m = ScannerMetricsReport::default();

-        let has_cycle = {
-            let cycle = self.cycle_info.read().await;
-            let has_cycle = if let Some(cycle) = cycle.as_ref() {
-                m.current_cycle = cycle.current;
-                m.cycles_completed_at = cycle.cycle_completed.clone();
-                m.current_started = cycle.started;
-                true
-            } else {
-                false
-            };
-            m.current_cycle_active = self.current_scan_cycle_work_active.load(Ordering::Acquire);
-            if m.current_cycle_active {
-                let current_work = self.scan_cycle_work_since(self.current_scan_cycle_work_start());
-                let current_source_work = self.scanner_source_work_since(&self.current_scan_cycle_source_work_start_values());
-                let current_replication_repair_work =
-                    self.scanner_replication_repair_work_since(&self.current_scan_cycle_replication_repair_work_start_values());
-                m.current_cycle_objects_scanned = current_work.objects_scanned;
-                m.current_cycle_directories_scanned = current_work.directories_scanned;
-                m.current_cycle_bucket_drive_scans = current_work.bucket_drive_scans;
-                m.current_cycle_bucket_drive_failures = current_work.bucket_drive_failures;
-                m.current_cycle_yield_events = current_work.yield_events;
-                m.current_cycle_yield_duration_seconds = current_work.yield_duration_millis as f64 / 1000.0;
-                m.current_cycle_throttle_sleep_events = current_work.throttle_sleep_events;
-                m.current_cycle_throttle_sleep_duration_seconds = current_work.throttle_sleep_duration_millis as f64 / 1000.0;
-                m.current_cycle_ilm_actions = current_work.ilm_actions;
-                m.current_cycle_lifecycle_expiry_actions = current_work.lifecycle_expiry_actions;
-                m.current_cycle_lifecycle_transition_actions = current_work.lifecycle_transition_actions;
-                m.current_cycle_heal_objects = current_work.heal_objects;
-                m.current_cycle_replication_checks = current_work.replication_checks;
-                m.current_cycle_usage_saves = current_work.usage_saves;
-                m.current_cycle_source_work = self.scanner_source_work_snapshots(&current_source_work);
-                m.current_cycle_replication_repair =
-                    self.scanner_replication_repair_work_snapshots(&current_replication_repair_work);
-            }
-            has_cycle
+        let has_cycle = if let Some(cycle) = self.get_cycle().await {
+            m.current_cycle = cycle.current;
+            m.cycles_completed_at = cycle.cycle_completed;
+            m.current_started = cycle.started;
+            true
+        } else {
+            false
        };

        if !has_cycle && let Some(init_time) = crate::get_global_init_time().await {
@@ -2838,6 +2793,28 @@ impl Metrics {
        m.current_disk_scan_concurrency_limit = disk_scan_concurrency_limit;
        m.current_disk_bucket_scans_queued = disk_bucket_scans_queued;
        m.current_disk_bucket_scans_active = disk_bucket_scans_active;
+        if self.current_scan_cycle_work_active.load(Ordering::Relaxed) {
+            let current_work = self.scan_cycle_work_since(self.current_scan_cycle_work_start());
+            let current_source_work = self.scanner_source_work_since(&self.current_scan_cycle_source_work_start_values());
+            let current_replication_repair_work =
+                self.scanner_replication_repair_work_since(&self.current_scan_cycle_replication_repair_work_start_values());
+            m.current_cycle_objects_scanned = current_work.objects_scanned;
+            m.current_cycle_directories_scanned = current_work.directories_scanned;
+            m.current_cycle_bucket_drive_scans = current_work.bucket_drive_scans;
+            m.current_cycle_bucket_drive_failures = current_work.bucket_drive_failures;
+            m.current_cycle_yield_events = current_work.yield_events;
+            m.current_cycle_yield_duration_seconds = current_work.yield_duration_millis as f64 / 1000.0;
+            m.current_cycle_throttle_sleep_events = current_work.throttle_sleep_events;
+            m.current_cycle_throttle_sleep_duration_seconds = current_work.throttle_sleep_duration_millis as f64 / 1000.0;
+            m.current_cycle_ilm_actions = current_work.ilm_actions;
+            m.current_cycle_lifecycle_expiry_actions = current_work.lifecycle_expiry_actions;
+            m.current_cycle_lifecycle_transition_actions = current_work.lifecycle_transition_actions;
+            m.current_cycle_heal_objects = current_work.heal_objects;
+            m.current_cycle_replication_checks = current_work.replication_checks;
+            m.current_cycle_usage_saves = current_work.usage_saves;
+            m.current_cycle_source_work = self.scanner_source_work_snapshots(&current_source_work);
+            m.current_cycle_replication_repair = self.scanner_replication_repair_work_snapshots(&current_replication_repair_work);
+        }
        let last_cycle_result = self.last_scan_cycle_result.load(Ordering::Relaxed);
        m.last_cycle_result = scan_cycle_result_label(last_cycle_result).to_string();
        m.last_cycle_result_code = last_cycle_result as u64;
@@ -4165,8 +4142,6 @@ mod tests {

        let report = metrics.report().await;

-        assert!(report.current_cycle_active);
-        assert_eq!(report.current_cycle, 0);
        assert_eq!(report.current_cycle_objects_scanned, 7);
        assert_eq!(report.current_cycle_directories_scanned, 3);
        assert_eq!(report.current_cycle_bucket_drive_scans, 2);
@@ -4183,8 +4158,6 @@ mod tests {
        metrics.finish_scan_cycle_work(start);
        let report = metrics.report().await;

-        assert!(!report.current_cycle_active);
-        assert_eq!(report.current_cycle, 0);
        assert_eq!(report.current_cycle_objects_scanned, 0);
        assert_eq!(report.current_cycle_directories_scanned, 0);
        assert_eq!(report.current_cycle_bucket_drive_scans, 0);
@@ -4211,91 +4184,6 @@ mod tests {
        assert_eq!(report.last_cycle_usage_saves, 2);
    }

-    #[tokio::test]
-    async fn scan_cycle_activity_and_cycle_state_publish_together() {
-        let metrics = Metrics::new();
-        let cycle_started = Utc::now() - chrono::Duration::seconds(5);
-        let active_cycle = CurrentCycle {
-            current: 12,
-            next: 13,
-            started: cycle_started,
-            ..Default::default()
-        };
-
-        let cycle_state = metrics.cycle_info.read().await;
-        let mut start_transition = Box::pin(metrics.start_scan_cycle_work_with_cycle(active_cycle));
-        let waker = std::task::Waker::noop();
-        let mut context = std::task::Context::from_waker(waker);
-        assert!(start_transition.as_mut().poll(&mut context).is_pending());
-        assert!(!metrics.current_scan_cycle_work_active.load(Ordering::Acquire));
-        drop(cycle_state);
-
-        let start = start_transition.await;
-        let active = metrics.report().await;
-        assert!(active.current_cycle_active);
-        assert_eq!(active.current_cycle, 12);
-        assert_eq!(active.current_started, cycle_started);
-
-        let idle_cycle = CurrentCycle {
-            current: 0,
-            next: 13,
-            started: cycle_started,
-            ..Default::default()
-        };
-        let cycle_state = metrics.cycle_info.read().await;
-        let mut finish_transition = Box::pin(metrics.finish_scan_cycle_work_with_cycle(start, idle_cycle));
-        assert!(finish_transition.as_mut().poll(&mut context).is_pending());
-        assert!(metrics.current_scan_cycle_work_active.load(Ordering::Acquire));
-        drop(cycle_state);
-
-        finish_transition.await;
-        let idle = metrics.report().await;
-        assert!(!idle.current_cycle_active);
-        assert_eq!(idle.current_cycle, 0);
-    }
-
-    #[tokio::test]
-    async fn report_keeps_cycle_identity_and_work_in_one_snapshot() {
-        let metrics = Metrics::new();
-        let cycle_ten = CurrentCycle {
-            current: 10,
-            next: 11,
-            started: Utc::now() - chrono::Duration::seconds(10),
-            ..Default::default()
-        };
-        let cycle_ten_start = metrics.start_scan_cycle_work_with_cycle(cycle_ten.clone()).await;
-        metrics.operations[Metric::ScanObject as usize].store(1, Ordering::Relaxed);
-
-        let paths = metrics.current_paths.write().await;
-        let mut report = Box::pin(metrics.report());
-        let waker = std::task::Waker::noop();
-        let mut context = std::task::Context::from_waker(waker);
-        assert!(report.as_mut().poll(&mut context).is_pending());
-
-        metrics
-            .finish_scan_cycle_work_with_cycle(cycle_ten_start, CurrentCycle { current: 0, ..cycle_ten })
-            .await;
-        let cycle_eleven_start = metrics
-            .start_scan_cycle_work_with_cycle(CurrentCycle {
-                current: 11,
-                next: 12,
-                started: Utc::now(),
-                ..Default::default()
-            })
-            .await;
-        metrics.operations[Metric::ScanObject as usize].store(101, Ordering::Relaxed);
-
-        drop(paths);
-        let snapshot = report.await;
-
-        assert_eq!(snapshot.current_cycle, 10);
-        assert_eq!(snapshot.current_cycle_objects_scanned, 1);
-
-        metrics
-            .finish_scan_cycle_work_with_cycle(cycle_eleven_start, CurrentCycle::default())
-            .await;
-    }
-
    #[tokio::test]
    async fn scanner_cycle_ilm_actions_ignore_global_ilm_work() {
        let metrics = Metrics::new();
@@ -10,17 +10,7 @@ description = "Shared concurrency contract types for RustFS - workload admission
 keywords = ["rustfs", "concurrency", "admission", "backpressure", "workers"]
 categories = ["concurrency", "filesystem"]

-[lints]
-workspace = true
-
-[features]
-default = []
-hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-io-core/hotpath"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-io-core/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-io-core/hotpath-cpu"]
-
 [dependencies]
-hotpath.workspace = true
 # Internal crates
 rustfs-io-core = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -25,7 +25,6 @@ keywords = ["configuration", "settings", "management", "rustfs", "Minio"]
 categories = ["web-programming", "development-tools", "config"]

 [dependencies]
-hotpath.workspace = true
 const-str = { workspace = true, optional = true, features = ["std", "proc"] }
 serde = { workspace = true, optional = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true, features = ["raw_value"] }
@@ -35,9 +34,6 @@ workspace = true

 [features]
 default = ["constants"]
-hotpath = ["hotpath/hotpath"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
 audit = ["dep:const-str", "constants"]
 constants = ["dep:const-str"]
 notify = ["dep:const-str", "constants"]
@@ -66,10 +66,6 @@ Current guidance:

 - `RUSTFS_BROWSER_REDIRECT_URL` sets the externally reachable browser origin used for OIDC callback, console success redirect, and logout fallback URLs. Configure it to the public scheme and authority without a path, for example `https://console.example.com`. In load-balancer deployments, keep OIDC authorize and callback requests on the same backend node because the in-flight OIDC `state` is local to the RustFS node.

-## Distributed endpoint locality
-
- `RUSTFS_LOCAL_ENDPOINT_HOST` identifies this server's host in a distributed `RUSTFS_VOLUMES` topology without resolving every peer during startup. Set it to exactly one host, without a scheme, port, or path. It is accepted only for orchestrated URL topologies and must match at least one endpoint on the RustFS server port; invalid or unmatched values fail startup. Leave it unset to retain DNS-based locality discovery.
-
 ## Scanner environment aliases

 - `RUSTFS_SCANNER_SPEED` (canonical, also accepts `MINIO_SCANNER_SPEED`)
@@ -131,10 +131,6 @@ pub const ENV_RUSTFS_ADDRESS: &str = "RUSTFS_ADDRESS";
 /// Environment variable for server volumes.
 pub const ENV_RUSTFS_VOLUMES: &str = "RUSTFS_VOLUMES";

-/// Environment variable identifying this server's host in distributed endpoint
-/// lists without relying on DNS locality discovery.
-pub const ENV_LOCAL_ENDPOINT_HOST: &str = "RUSTFS_LOCAL_ENDPOINT_HOST";
-
 /// Environment variable to explicitly bypass local physical disk independence checks.
 pub const ENV_UNSAFE_BYPASS_DISK_CHECK: &str = "RUSTFS_UNSAFE_BYPASS_DISK_CHECK";

@@ -230,19 +226,6 @@ pub const ENV_RUSTFS_KMS_ENABLE: &str = "RUSTFS_KMS_ENABLE";
 /// Default value: false
 pub const DEFAULT_KMS_ENABLE: bool = false;

-/// Environment variable enabling per-key KMS authorization on the SSE-KMS data path.
-///
-/// When enabled, an SSE-KMS write additionally requires `kms:GenerateDataKey` and an
-/// SSE-KMS read additionally requires `kms:Decrypt` on the resolved key, evaluated as
-/// the requesting identity. SSE-S3 and SSE-C are unaffected.
-pub const ENV_RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY: &str = "RUSTFS_KMS_ENFORCE_SSE_KEY_POLICY";
-
-/// Default per-key KMS authorization mode for the SSE-KMS data path.
-///
-/// Off for now so deployments whose identity policies only grant s3 actions keep
-/// working; the default flips to on in a later release.
-pub const DEFAULT_KMS_ENFORCE_SSE_KEY_POLICY: bool = false;
-
 /// Environment variable for server KMS backend.
 pub const ENV_RUSTFS_KMS_BACKEND: &str = "RUSTFS_KMS_BACKEND";

@@ -158,33 +158,17 @@ pub const DEFAULT_INTERNODE_RPC_BODY_DIGEST_STRICT: bool = false;
 // rolling upgrades until the fleet-wide body-digest fallback counter reads zero.
 const _: () = assert!(!DEFAULT_INTERNODE_RPC_BODY_DIGEST_STRICT);

-/// Require the replay-scoped internode RPC signature after the fleet has converged on it.
-///
-/// The default keeps v1/v2 peers available during a rolling upgrade. Operators may set this only
-/// after `rustfs_system_network_internode_replay_scope_fallback_total` remains zero for a full
-/// release window. The node still accepts a v2-authenticated `Ping` carrying an epoch challenge:
-/// that narrowly scoped bootstrap lets an upgraded client learn the receiving process epoch and
-/// immediately retry with the replay-scoped signature after a peer restart.
-pub const ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT: &str = "RUSTFS_INTERNODE_RPC_REPLAY_SCOPE_STRICT";
-pub const DEFAULT_INTERNODE_RPC_REPLAY_SCOPE_STRICT: bool = false;
-
-// Compile-time invariant: mixed-version clusters must remain available until operators make the
-// observed fallback counter an explicit strictness decision.
-const _: () = assert!(!DEFAULT_INTERNODE_RPC_REPLAY_SCOPE_STRICT);
-
 /// Capacity (distinct nonces) of the process-local internode RPC replay cache that enforces
-/// one-time consumption of authenticated RPC signatures.
+/// one-time consumption of body-bound v2 signatures.
 ///
-/// The cache retains each nonce for the ~10-minute signature freshness envelope. Once peers use
-/// replay-scoped v3 authentication, every authenticated RPC consumes one entry, so the steady
-/// state holds roughly `authenticated RPC RPS x 601s` entries. The default sustains about 1,700
-/// authenticated RPCs per second (about 120 MiB worst case, allocated only under sustained load);
-/// operators must size it for the node's aggregate peak RPC rate before enabling strict replay
-/// scope. Overflow fails closed — legitimate signed traffic is the only thing that can fill the
-/// cache (replays are rejected before insertion, and an attacker cannot mint valid nonces without
-/// the shared secret) — and increments
+/// The cache retains each nonce for the ~10-minute signature freshness envelope, so the steady
+/// state holds roughly `mutating RPS x 601s` entries; the default sustains ~1,700 body-bound
+/// mutating RPCs per second (about 120 MiB worst case, allocated only under sustained load).
+/// Overflow fails closed — legitimate signed traffic is the only thing that can fill the cache
+/// (replays are rejected before insertion, and an attacker cannot mint valid nonces without the
+/// shared secret) — and increments
 /// `rustfs_system_network_internode_replay_cache_overflow_total`, so a sustained non-zero overflow
-/// counter means this capacity is undersized for the node's peak authenticated RPC rate.
+/// counter means this capacity is undersized for the node's peak mutation rate.
 pub const ENV_INTERNODE_RPC_REPLAY_CACHE_CAPACITY: &str = "RUSTFS_INTERNODE_RPC_REPLAY_CACHE_CAPACITY";
 pub const DEFAULT_INTERNODE_RPC_REPLAY_CACHE_CAPACITY: usize = 1_048_576;

@@ -370,12 +354,6 @@ mod tests {
        assert_eq!(ENV_INTERNODE_RPC_BODY_DIGEST_STRICT, "RUSTFS_INTERNODE_RPC_BODY_DIGEST_STRICT");
    }

-    #[test]
-    fn internode_replay_scope_strict_env_name_is_stable() {
-        // The fail-open default invariant is asserted at compile time next to the definition.
-        assert_eq!(ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT, "RUSTFS_INTERNODE_RPC_REPLAY_SCOPE_STRICT");
-    }
-
    #[test]
    fn internode_replay_cache_capacity_defaults_and_env_name() {
        assert_eq!(ENV_INTERNODE_RPC_REPLAY_CACHE_CAPACITY, "RUSTFS_INTERNODE_RPC_REPLAY_CACHE_CAPACITY");
@@ -116,27 +116,6 @@ pub const ENV_OBJECT_GET_SKIP_BITROT_VERIFY: &str = "RUSTFS_OBJECT_GET_SKIP_BITR
 /// Default: bitrot verification is enabled on GetObject reads (do not skip).
 pub const DEFAULT_OBJECT_GET_SKIP_BITROT_VERIFY: bool = false;

-/// Request writing the complete remote-tier version state into object metadata.
-///
-/// This remains ineffective until
-/// [`ENV_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED`] is also enabled.
-pub const ENV_TIER_REMOTE_VERSION_STATE_WRITE: &str = "RUSTFS_TIER_REMOTE_VERSION_STATE_WRITE";
-pub const DEFAULT_TIER_REMOTE_VERSION_STATE_WRITE: bool = false;
-
-/// Operator-attested fleet-wide confirmation for
-/// [`ENV_TIER_REMOTE_VERSION_STATE_WRITE`].
-///
-/// This flag is an operational contract, not automatic capability discovery.
-/// Operators may enable it only after every node that can write or read
-/// transitioned object metadata supports the remote version-state schema and
-/// semantics. Keeping the confirmation separate makes a single-node request or
-/// a writer whose local opt-in is removed fail closed.
-pub const ENV_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED: &str = "RUSTFS_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED";
-pub const DEFAULT_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED: bool = false;
-
-const _: () = assert!(!DEFAULT_TIER_REMOTE_VERSION_STATE_WRITE);
-const _: () = assert!(!DEFAULT_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED);
-
 // =============================================================================
 // Concurrent Request Fix - Timeout and Backpressure Configuration
 // =============================================================================
@@ -638,15 +617,3 @@ pub const ENV_OBJECT_IO_RANDOM_READAHEAD_DISABLE_CONCURRENCY: &str = "RUSTFS_OBJ

 /// Default read-ahead disable concurrency threshold: 4.
 pub const DEFAULT_OBJECT_IO_RANDOM_READAHEAD_DISABLE_CONCURRENCY: usize = 4;
-
-#[cfg(test)]
-mod remote_version_state_tests {
-    #[test]
-    fn remote_version_state_gate_uses_stable_environment_names() {
-        assert_eq!(super::ENV_TIER_REMOTE_VERSION_STATE_WRITE, "RUSTFS_TIER_REMOTE_VERSION_STATE_WRITE");
-        assert_eq!(
-            super::ENV_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED,
-            "RUSTFS_TIER_REMOTE_VERSION_STATE_FLEET_CONFIRMED"
-        );
-    }
-}
@@ -24,14 +24,7 @@ description = "Credentials management utilities for RustFS, enabling secure hand
 keywords = ["rustfs", "Minio", "credentials", "authentication", "authorization"]
 categories = ["web-programming", "development-tools", "data-structures", "security"]

-[features]
-default = []
-hotpath = ["hotpath/hotpath"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
-
 [dependencies]
-hotpath.workspace = true
 base64-simd = { workspace = true }
 hmac = { workspace = true }
 rand = { workspace = true, features = ["serde"] }
@@ -29,7 +29,6 @@ documentation = "https://docs.rs/rustfs-crypto/latest/rustfs_crypto/"
 workspace = true

 [dependencies]
-hotpath.workspace = true
 aes-gcm = { workspace = true, optional = true, features = ["rand_core"] }
 argon2 = { workspace = true, optional = true }
 chacha20poly1305 = { workspace = true, optional = true }
@@ -50,9 +49,6 @@ time = { workspace = true, features = ["parsing", "formatting", "macros", "serde

 [features]
 default = ["crypto", "fips"]
-hotpath = ["hotpath/hotpath"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
 fips = []
 crypto = [
    "dep:aes-gcm",
@@ -27,15 +27,9 @@ categories = ["data-structures", "filesystem"]
 [lints]
 workspace = true

-[features]
-default = []
-hotpath = ["hotpath/hotpath", "rustfs-filemeta/hotpath"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-filemeta/hotpath-alloc"]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-filemeta/hotpath-cpu"]
-
 [dependencies]
-hotpath.workspace = true
 serde = { workspace = true, features = ["derive"] }
+path-clean = { workspace = true }
 rmp-serde = { workspace = true }
 async-trait = { workspace = true }
 rustfs-filemeta = { workspace = true }
@@ -12,10 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+use path_clean::PathClean;
 use serde::{Deserialize, Serialize};
 use std::{
    collections::{HashMap, HashSet},
    hash::{DefaultHasher, Hash, Hasher},
+    path::Path,
    time::{Duration, SystemTime},
 };

@@ -332,7 +334,7 @@ impl<'de> Deserialize<'de> for SizeHistogram {
 impl SizeHistogram {
    pub fn add(&mut self, size: u64) {
        let intervals = [
-            (0, 1024 - 1),                              // LESS_THAN_1024_B
+            (0, 1024),                                  // LESS_THAN_1024_B
            (1024, 64 * 1024 - 1),                      // BETWEEN_1024_B_AND_64_KB
            (64 * 1024, 256 * 1024 - 1),                // BETWEEN_64_KB_AND_256_KB
            (256 * 1024, 512 * 1024 - 1),               // BETWEEN_256_KB_AND_512_KB
@@ -360,7 +362,7 @@ impl SizeHistogram {
        // the sub-ranges in [1 KiB, 512 KiB).
        const ONE_MIB: u64 = 1024 * 1024;
        let intervals = [
-            (0, 1024 - 1),                      // LESS_THAN_1024_B
+            (0, 1024),                          // LESS_THAN_1024_B
            (1024, 64 * 1024 - 1),              // BETWEEN_1024_B_AND_64_KB
            (64 * 1024, 256 * 1024 - 1),        // BETWEEN_64_KB_AND_256_KB
            (256 * 1024, 512 * 1024 - 1),       // BETWEEN_256_KB_AND_512_KB
@@ -1108,39 +1110,9 @@ fn mark(duc: &DataUsageCache, entry: &DataUsageEntry, found: &mut HashSet<String
    }
 }

-fn clean_data_usage_path(data: &str) -> String {
-    let rooted = data.starts_with('/');
-    let mut parts = Vec::new();
-
-    for part in data.split('/') {
-        match part {
-            "" | "." => {}
-            ".." => {
-                if parts.last().is_some_and(|last| *last != "..") {
-                    parts.pop();
-                } else if !rooted {
-                    parts.push(part);
-                }
-            }
-            _ => parts.push(part),
-        }
-    }
-
-    let clean = parts.join("/");
-    match (rooted, clean.is_empty()) {
-        (true, true) => "/".to_string(),
-        (true, false) => format!("/{clean}"),
-        (false, true) => ".".to_string(),
-        (false, false) => clean,
-    }
-}
-
-/// Hash a slash-separated path for data usage caching.
-///
-/// Cache identifiers are persisted and exchanged across nodes, so their
-/// normalization must not depend on the host operating system.
+/// Hash a path for data usage caching
 pub fn hash_path(data: &str) -> DataUsageHash {
-    DataUsageHash(clean_data_usage_path(data))
+    DataUsageHash(Path::new(&data).clean().to_string_lossy().to_string())
 }

 impl DataUsageInfo {
@@ -1525,23 +1497,6 @@ mod tests {
        buckets_count: u64,
    }

-    #[test]
-    fn hash_path_uses_portable_slash_semantics() {
-        for (input, expected) in [
-            ("", "."),
-            (".", "."),
-            ("/", "/"),
-            ("//bucket///prefix/", "/bucket/prefix"),
-            ("bucket/./prefix//object", "bucket/prefix/object"),
-            ("bucket/a/../b", "bucket/b"),
-            ("../bucket/..", ".."),
-            ("/../../bucket", "/bucket"),
-            ("bucket\\prefix/object", "bucket\\prefix/object"),
-        ] {
-            assert_eq!(hash_path(input).key(), expected, "unexpected portable cache key for {input:?}");
-        }
-    }
-
    #[test]
    fn completeness_marker_is_additive_for_legacy_named_readers() {
        let current = DataUsageInfo {
@@ -1646,49 +1601,6 @@ mod tests {
        assert_eq!(map["BETWEEN_512_KB_AND_1_MB"], 1);
    }

-    #[test]
-    fn test_size_histogram_classifies_adjacent_boundaries_once() {
-        let cases = [
-            (1023, 0),
-            (1024, 1),
-            (64 * 1024 - 1, 1),
-            (64 * 1024, 2),
-            (256 * 1024 - 1, 2),
-            (256 * 1024, 3),
-            (512 * 1024 - 1, 3),
-            (512 * 1024, 4),
-            (1024 * 1024 - 1, 4),
-            (1024 * 1024, 6),
-            (10 * 1024 * 1024 - 1, 6),
-            (10 * 1024 * 1024, 7),
-            (64 * 1024 * 1024 - 1, 7),
-            (64 * 1024 * 1024, 8),
-            (128 * 1024 * 1024 - 1, 8),
-            (128 * 1024 * 1024, 9),
-            (512 * 1024 * 1024 - 1, 9),
-            (512 * 1024 * 1024, 10),
-        ];
-
-        for (size, expected_bucket) in cases {
-            let mut hist = SizeHistogram::default();
-            hist.add(size);
-
-            assert_eq!(hist.0.iter().sum::<u64>(), 1, "size {size} must have exactly one physical bucket");
-            assert_eq!(hist.0[expected_bucket], 1, "size {size} must select the expected bucket");
-        }
-    }
-
-    #[test]
-    fn test_size_histogram_1024_bytes_contributes_to_compat_rollup() {
-        let mut hist = SizeHistogram::default();
-        hist.add(1024);
-
-        let map = hist.to_map();
-        assert_eq!(map["LESS_THAN_1024_B"], 0);
-        assert_eq!(map["BETWEEN_1024_B_AND_64_KB"], 1);
-        assert_eq!(map["BETWEEN_1024B_AND_1_MB"], 1);
-    }
-
    #[test]
    fn test_size_histogram_compat_rollup_saturates_on_corrupt_counts() {
        let mut hist = SizeHistogram::default();
@@ -25,58 +25,10 @@ workspace = true

 [features]
 default = []
-hotpath = [
-    "hotpath/hotpath",
-    "hotpath/tokio",
-    "hotpath/futures",
-    "hotpath/reqwest-0-13",
-    "rustfs-config/hotpath",
-    "rustfs-credentials/hotpath",
-    "rustfs-data-usage/hotpath",
-    "rustfs-ecstore/hotpath",
-    "rustfs-filemeta/hotpath",
-    "rustfs-lock/hotpath",
-    "rustfs-madmin/hotpath",
-    "rustfs-protos/hotpath",
-    "rustfs-rio/hotpath",
-    "rustfs-signer/hotpath",
-    "rustfs-utils/hotpath",
-]
-hotpath-alloc = [
-    "hotpath",
-    "hotpath/hotpath-alloc",
-    "rustfs-config/hotpath-alloc",
-    "rustfs-credentials/hotpath-alloc",
-    "rustfs-data-usage/hotpath-alloc",
-    "rustfs-ecstore/hotpath-alloc",
-    "rustfs-filemeta/hotpath-alloc",
-    "rustfs-lock/hotpath-alloc",
-    "rustfs-madmin/hotpath-alloc",
-    "rustfs-protos/hotpath-alloc",
-    "rustfs-rio/hotpath-alloc",
-    "rustfs-signer/hotpath-alloc",
-    "rustfs-utils/hotpath-alloc",
-]
-hotpath-cpu = [
-    "hotpath",
-    "hotpath/hotpath-cpu",
-    "rustfs-config/hotpath-cpu",
-    "rustfs-credentials/hotpath-cpu",
-    "rustfs-data-usage/hotpath-cpu",
-    "rustfs-ecstore/hotpath-cpu",
-    "rustfs-filemeta/hotpath-cpu",
-    "rustfs-lock/hotpath-cpu",
-    "rustfs-madmin/hotpath-cpu",
-    "rustfs-protos/hotpath-cpu",
-    "rustfs-rio/hotpath-cpu",
-    "rustfs-signer/hotpath-cpu",
-    "rustfs-utils/hotpath-cpu",
-]
 ftps = []
 sftp = []

 [dependencies]
-hotpath.workspace = true
 rustfs-config = { workspace = true, features = ["constants"] }
 rustfs-credentials.workspace = true
 rustfs-ecstore.workspace = true
@@ -118,8 +70,7 @@ walkdir.workspace = true
 base64 = { workspace = true }
 rand = { workspace = true, features = ["serde"] }
 chrono = { workspace = true, features = ["serde"] }
-hex = { workspace = true }
-md-5 = { workspace = true }
+md5 = { workspace = true }
 opentelemetry-proto = { workspace = true }
 prost.workspace = true
 sha2 = { workspace = true }
@@ -26,16 +26,75 @@
 //! Later batches tracked on backlog#1154: config get/set, info, pools status,
 //! group lifecycle, import/export IAM.

-use crate::common::{RustFSTestEnvironment, admin_ok, admin_request, init_logging};
+use crate::common::{RustFSTestEnvironment, init_logging, local_http_client};
 use aws_sdk_s3::config::{Credentials, Region};
 use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::{Client, Config};
+use http::header::{CONTENT_TYPE, HOST};
 use reqwest::StatusCode;
+use rustfs_signer::constants::UNSIGNED_PAYLOAD;
+use rustfs_signer::sign_v4;
+use s3s::Body;
 use serial_test::serial;
 use std::error::Error;
 use tokio::time::{Duration, sleep};

 type TestResult = Result<(), Box<dyn Error + Send + Sync>>;
+type BoxError = Box<dyn Error + Send + Sync>;
+
+/// Signs and sends an admin HTTP request with the given credential, returning
+/// status and body. Native `/rustfs/admin/v3` requests and responses are plain
+/// JSON (the MinIO-compat encryption applies only to `/minio/admin/v3` paths).
+async fn admin_request(
+    base_url: &str,
+    method: http::Method,
+    path_and_query: &str,
+    body: Option<String>,
+    access_key: &str,
+    secret_key: &str,
+) -> Result<(StatusCode, String), BoxError> {
+    let url = format!("{base_url}{path_and_query}");
+    let uri = url.parse::<http::Uri>()?;
+    let authority = uri.authority().ok_or("admin URL missing authority")?.to_string();
+    let mut builder = http::Request::builder()
+        .method(method.clone())
+        .uri(uri)
+        .header(HOST, authority)
+        .header("x-amz-content-sha256", UNSIGNED_PAYLOAD);
+    if body.is_some() {
+        builder = builder.header(CONTENT_TYPE, "application/json");
+    }
+
+    let content_len = body.as_ref().map(|b| b.len() as i64).unwrap_or_default();
+    let signed = sign_v4(builder.body(Body::empty())?, content_len, access_key, secret_key, "", "us-east-1");
+
+    let reqwest_method = reqwest::Method::from_bytes(method.as_str().as_bytes())?;
+    let mut request = local_http_client().request(reqwest_method, &url);
+    for (name, value) in signed.headers() {
+        request = request.header(name, value);
+    }
+    if let Some(body) = body {
+        request = request.body(body);
+    }
+    let response = request.send().await?;
+    let status = response.status();
+    let text = response.text().await.unwrap_or_default();
+    Ok((status, text))
+}
+
+/// Root-credential admin request that must succeed; returns the response body.
+async fn admin_ok(
+    env: &RustFSTestEnvironment,
+    method: http::Method,
+    path_and_query: &str,
+    body: Option<String>,
+) -> Result<String, BoxError> {
+    let (status, text) = admin_request(&env.url, method.clone(), path_and_query, body, &env.access_key, &env.secret_key).await?;
+    if !status.is_success() {
+        return Err(format!("{method} {path_and_query} failed: {status} {text}").into());
+    }
+    Ok(text)
+}

 fn build_s3_client(url: &str, access_key: &str, secret_key: &str) -> Client {
    let config = Config::builder()
@@ -24,10 +24,9 @@ mod tests {
    use aws_sdk_s3::types::{ChecksumAlgorithm, ChecksumMode, CompletedMultipartUpload, CompletedPart};
    use aws_smithy_http_client::Builder as SmithyHttpClientBuilder;
    use base64::Engine;
-    use md5::{Digest as Md5Digest, Md5};
    use rustfs_rio::{Checksum, ChecksumType as RioChecksumType};
    use serial_test::serial;
-    use sha2::Sha256;
+    use sha2::{Digest, Sha256};
    use tracing::info;

    fn create_s3_client(env: &RustFSTestEnvironment) -> Client {
@@ -71,9 +70,7 @@ mod tests {
    }

    fn content_md5_base64(body: &[u8]) -> String {
-        let mut hasher = Md5::new();
-        hasher.update(body);
-        let digest = hasher.finalize();
+        let digest = md5::compute(body);
        base64::engine::general_purpose::STANDARD.encode(digest.as_slice())
    }

@@ -24,12 +24,7 @@
 use aws_sdk_s3::config::{Credentials, Region};
 use aws_sdk_s3::{Client, Config};
 use aws_smithy_http_client::Builder as SmithyHttpClientBuilder;
-use http::header::{CONTENT_TYPE, HOST};
 use reqwest::Client as HttpClient;
-use reqwest::StatusCode;
-use rustfs_signer::constants::UNSIGNED_PAYLOAD;
-use rustfs_signer::sign_v4;
-use s3s::Body;
 use std::ffi::OsStr;
 use std::fs as stdfs;
 use std::path::{Path, PathBuf};
@@ -80,58 +75,6 @@ pub fn local_http_client() -> HttpClient {
        .expect("failed to build local reqwest client")
 }

-/// Signs and sends an admin HTTP request with the given credentials.
-pub(crate) async fn admin_request(
-    base_url: &str,
-    method: http::Method,
-    path_and_query: &str,
-    body: Option<String>,
-    access_key: &str,
-    secret_key: &str,
-) -> Result<(StatusCode, String), Box<dyn std::error::Error + Send + Sync>> {
-    let url = format!("{base_url}{path_and_query}");
-    let uri = url.parse::<http::Uri>()?;
-    let authority = uri.authority().ok_or("admin URL missing authority")?.to_string();
-    let mut request = http::Request::builder()
-        .method(method.clone())
-        .uri(uri)
-        .header(HOST, authority)
-        .header("x-amz-content-sha256", UNSIGNED_PAYLOAD);
-    if body.is_some() {
-        request = request.header(CONTENT_TYPE, "application/json");
-    }
-
-    let content_length = i64::try_from(body.as_ref().map_or(0, String::len)).map_err(|_| "admin request body is too large")?;
-    let signed = sign_v4(request.body(Body::empty())?, content_length, access_key, secret_key, "", "us-east-1");
-
-    let mut request = local_http_client().request(method, &url);
-    for (name, value) in signed.headers() {
-        request = request.header(name, value);
-    }
-    if let Some(body) = body {
-        request = request.body(body);
-    }
-    let response = request.send().await?;
-    let status = response.status();
-    let body = response.text().await?;
-    Ok((status, body))
-}
-
-/// Sends a root-credential admin request and returns its successful response body.
-pub(crate) async fn admin_ok(
-    env: &RustFSTestEnvironment,
-    method: http::Method,
-    path_and_query: &str,
-    body: Option<String>,
-) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
-    let (status, response_body) =
-        admin_request(&env.url, method.clone(), path_and_query, body, &env.access_key, &env.secret_key).await?;
-    if !status.is_success() {
-        return Err(format!("{method} {path_and_query} failed: {status} {response_body}").into());
-    }
-    Ok(response_body)
-}
-
 /// Resolve the RustFS binary relative to the workspace.
 pub fn rustfs_binary_path() -> PathBuf {
    rustfs_binary_path_with_features(requested_rustfs_build_features().as_deref())
@@ -117,14 +117,9 @@ mod tests {
            .key("assets/explicit-copy.js")
            .copy_source(format!("{bucket}/{key}"))
            .metadata_directive(MetadataDirective::Copy)
-            .customize()
-            .mutate_request(|request| {
-                request.headers_mut().insert("content-type", "application/octet-stream");
-                request.headers_mut().insert("x-amz-meta-request-only", "ignored");
-            })
            .send()
            .await
-            .expect("explicit COPY directive with request metadata failed");
+            .expect("explicit COPY directive failed");
        let explicit_copy_head = client
            .head_object()
            .bucket(bucket)
@@ -133,18 +128,6 @@ mod tests {
            .await
            .expect("HEAD failed after explicit COPY");
        assert_eq!(explicit_copy_head.cache_control(), Some("max-age=60"));
-        assert_eq!(explicit_copy_head.content_type(), Some("text/javascript; charset=utf-8"));
-        assert_eq!(
-            explicit_copy_head.metadata().and_then(|metadata| metadata.get("mtime")),
-            Some(&"1777992333".to_string())
-        );
-        assert_eq!(
-            explicit_copy_head
-                .metadata()
-                .and_then(|metadata| metadata.get("request-only")),
-            None,
-            "COPY must ignore request metadata"
-        );
        assert_eq!(
            explicit_copy_head.website_redirect_location(),
            None,
@@ -588,6 +571,20 @@ mod tests {
            Some("InvalidArgument")
        );

+        let ignored_replacement = client
+            .copy_object()
+            .bucket(bucket)
+            .key(key)
+            .copy_source(format!("{bucket}/{key}"))
+            .content_type("application/ignored")
+            .send()
+            .await
+            .expect_err("Replacement fields without REPLACE should be rejected");
+        assert_eq!(
+            ignored_replacement.as_service_error().and_then(|error| error.code()),
+            Some("InvalidRequest")
+        );
+
        let unchanged = client
            .get_object()
            .bucket(bucket)
@@ -56,21 +56,6 @@ mod tests {
        );
    }

-    async fn assert_current_list_hides_delete_marker(client: &Client, bucket: &str, key: &str) {
-        let listed = client
-            .list_objects_v2()
-            .bucket(bucket)
-            .prefix(key)
-            .send()
-            .await
-            .expect("list current objects after delete marker");
-
-        assert!(
-            listed.contents().iter().all(|object| object.key() != Some(key)),
-            "ListObjectsV2 must hide an object whose latest version is a delete marker"
-        );
-    }
-
    #[tokio::test]
    #[serial]
    async fn test_versioning_only_delete_marker_has_minio_compatible_visibility_for_migration_proof() {
@@ -109,7 +94,6 @@ mod tests {
        assert_eq!(markers[0].version_id(), Some(delete_marker_version_id));
        assert_eq!(markers[0].is_latest(), Some(true));
        assert_current_get_is_delete_marker_not_found(&client, bucket, key).await;
-        assert_current_list_hides_delete_marker(&client, bucket, key).await;
    }

    #[tokio::test]
@@ -134,17 +118,6 @@ mod tests {
            .await
            .expect("put historical version");
        let data_version_id = put.version_id().expect("put should return data version id");
-        let listed_before_delete = client
-            .list_objects_v2()
-            .bucket(bucket)
-            .prefix(key)
-            .send()
-            .await
-            .expect("list current object before creating delete marker");
-        assert!(
-            listed_before_delete.contents().iter().any(|object| object.key() == Some(key)),
-            "ListObjectsV2 must include the current object before it is deleted"
-        );

        let delete_marker = client
            .delete_object()
@@ -172,7 +145,6 @@ mod tests {
        assert_eq!(markers[0].version_id(), Some(delete_marker_version_id));
        assert_eq!(markers[0].is_latest(), Some(true));
        assert_current_get_is_delete_marker_not_found(&client, bucket, key).await;
-        assert_current_list_hides_delete_marker(&client, bucket, key).await;

        let historical = client
            .get_object()
@@ -25,7 +25,6 @@ use hyper::body::Incoming;
 use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper_util::rt::{TokioIo, TokioTimer};
-use md5::{Digest as Md5Digest, Md5};
 use s3s::access::{S3Access, S3AccessContext};
 use s3s::auth::SimpleAuth;
 use s3s::dto::{
@@ -828,25 +827,13 @@ fn ensure_body_growth(current: usize, added: usize) -> S3Result {

 async fn md5_digest(body: Bytes, permit: OwnedSemaphorePermit) -> S3Result<([u8; 16], OwnedSemaphorePermit)> {
    if body.len() < 1024 * 1024 {
-        return Ok((md5_bytes(body), permit));
+        return Ok((md5::compute(body).0, permit));
    }
-    tokio::task::spawn_blocking(move || (md5_bytes(body), permit))
+    tokio::task::spawn_blocking(move || (md5::compute(body).0, permit))
        .await
        .map_err(|error| s3s::s3_error!(InternalError, "MD5 worker failed: {error}"))
 }

-fn md5_bytes(input: impl AsRef<[u8]>) -> [u8; 16] {
-    let mut hasher = Md5::new();
-    hasher.update(input.as_ref());
-    hasher.finalize().into()
-}
-
-fn md5_hex(input: impl AsRef<[u8]>) -> String {
-    let mut hasher = Md5::new();
-    hasher.update(input.as_ref());
-    hex::encode(hasher.finalize())
-}
-
 fn ensure_store_budget(state: &StoreState, removed_bytes: usize, added_bytes: usize, adds_version: bool) -> S3Result {
    let total_bytes = state
        .total_bytes
@@ -1018,7 +1005,7 @@ impl S3 for FakeBackend {
            Some(value) => value,
            None => {
                let (digest, _body_permit) = md5_digest(body.clone(), _body_permit).await?;
-                hex::encode(digest)
+                format!("{:x}", md5::Digest(digest))
            }
        };
        let version = ObjectVersion {
@@ -1221,7 +1208,7 @@ impl S3 for FakeBackend {
        }
        let body = collect_stream(input.body, input.content_length, fault.as_ref(), &self.control).await?;
        let (digest, _body_permit) = md5_digest(body.clone(), _body_permit).await?;
-        let e_tag = hex::encode(digest);
+        let e_tag = format!("{:x}", md5::Digest(digest));
        let mut state = lock(&self.store);
        let existing_bytes = state
            .uploads
@@ -1349,7 +1336,7 @@ impl S3 for FakeBackend {
            .collect();
        let (body, digests, _body_permits) = assemble_multipart(assembly_parts, total_len, _body_permits).await?;
        let part_count = requested.len();
-        let e_tag = source_etag(&headers)?.unwrap_or_else(|| format!("{}-{part_count}", md5_hex(digests)));
+        let e_tag = source_etag(&headers)?.unwrap_or_else(|| format!("{:x}-{part_count}", md5::compute(digests)));
        let version = ObjectVersion {
            version_id: upload.version_id.clone(),
            body,
@@ -2136,20 +2136,11 @@ async fn four_node_manual_transition_distributed_admission_conflict_reports_stat
    assert_eq!(terminal["bucket"].as_str(), Some(bucket.as_str()));
    assert_eq!(terminal["prefix"].as_str(), Some(prefix));
    assert_eq!(terminal["dry_run"].as_bool(), Some(false));
-    let terminal_status = terminal["status"].as_str();
-    assert!(
-        matches!(terminal_status, Some("partial" | "unknown")),
+    assert_eq!(
+        terminal["status"].as_str(),
+        Some("partial"),
        "small transition queue should surface terminal backpressure: {terminal}"
    );
-    if terminal_status == Some("unknown") {
-        let failure_reason = terminal["failure_reason"]
-            .as_str()
-            .ok_or_else(|| format!("unknown terminal status omitted failure_reason: {terminal}"))?;
-        assert!(
-            failure_reason.contains("worker result was not persisted before the transition queue drained"),
-            "unknown terminal status should identify lost worker-result persistence: {terminal}"
-        );
-    }
    let skipped_queue_full = terminal["report"]["skipped_queue_full"]
        .as_u64()
        .ok_or_else(|| format!("terminal status omitted report.skipped_queue_full: {terminal}"))?;
@@ -13,9 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-//! Cross-process replay / tamper acceptance for internode NodeService RPC
-//! signatures (<https://github.com/rustfs/backlog/issues/1327>,
-//! <https://github.com/rustfs/backlog/issues/1542>).
+//! Cross-process replay / tamper acceptance for the internode NodeService v2 RPC
+//! signature (<https://github.com/rustfs/backlog/issues/1327>).
 //!
 //! # Why this exists on top of the in-process tests
 //!
@@ -79,8 +78,6 @@
 //! | mixed version: legacy-only still served, not blocked | [`legacy_only_signature_is_accepted_in_default_posture`] |
 //! | strict flip closes the signature downgrade | [`signature_strict_rejects_legacy_only_downgrade`] |
 //! | strict flip closes the body-digest downgrade, incl. v1 | [`body_digest_strict_rejects_digestless_mutation`] |
-//! | replay scope binds every RPC and rejects restart replay | [`replay_scope_rejects_replay_path_transplant_and_stale_epoch_e2e`] |
-//! | strict replay scope allows only Ping bootstrap before v3 | [`replay_scope_strict_requires_v3_after_ping_bootstrap_e2e`] |
 //!
 //! Two acceptance items are deliberately left to the in-process tests. A stale
 //! timestamp cannot be forged from outside — it is inside the HMAC — so
@@ -91,20 +88,18 @@

 use crate::common::{RustFSTestEnvironment, init_logging};
 use crate::storage_api::internode_rpc_signature::{
-    TONIC_RPC_PREFIX, gen_signature_headers, gen_tonic_replay_scope_headers, gen_tonic_signature_headers,
-    node_service_time_out_client_no_auth, verify_tonic_boot_epoch_response,
+    TONIC_RPC_PREFIX, gen_signature_headers, gen_tonic_signature_headers, node_service_time_out_client_no_auth,
 };
 use http::{HeaderMap, Method};
 use rustfs_config::{
-    ENV_INTERNODE_RPC_BODY_DIGEST_STRICT, ENV_INTERNODE_RPC_REPLAY_CACHE_CAPACITY, ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT,
-    ENV_INTERNODE_RPC_SIGNATURE_STRICT,
+    ENV_INTERNODE_RPC_BODY_DIGEST_STRICT, ENV_INTERNODE_RPC_REPLAY_CACHE_CAPACITY, ENV_INTERNODE_RPC_SIGNATURE_STRICT,
 };
 use rustfs_protos::canonical_make_volume_request_body;
-use rustfs_protos::proto_gen::node_service::{MakeVolumeRequest, MakeVolumeResponse, PingRequest, PingResponse};
+use rustfs_protos::proto_gen::node_service::{MakeVolumeRequest, MakeVolumeResponse};
 use serial_test::serial;
 use sha2::{Digest, Sha256};
 use std::error::Error;
-use tonic::{Code, Request, Response, Status};
+use tonic::{Code, Request, Status};
 use uuid::Uuid;

 type TestResult = Result<(), Box<dyn Error + Send + Sync>>;
@@ -120,14 +115,12 @@ const TEST_RPC_SECRET: &str = "rustfs-internode-signature-e2e-secret";
 /// clears authentication stops harmlessly at `find_disk`.
 const ABSENT_DISK: &str = "/nonexistent/rustfs-signature-e2e-disk";

-/// Wire names of the v2 and replay-scope headers these black-box tests edit. They are
-/// `pub(crate)` in ecstore, so they are repeated here rather than imported.
-/// [`overwrite_header`] asserts the header it replaces was actually present, which turns a
-/// rename into a loud failure instead of silently reducing an attack to a no-op.
+/// Wire names of the two v2 headers these tests edit. They are `pub(crate)` in
+/// ecstore, so they are repeated here rather than imported — [`overwrite_header`]
+/// asserts the header it replaces was actually present, which turns a rename
+/// into a loud failure instead of silently reducing an attack to a no-op.
 const CONTENT_SHA256_HEADER: &str = "x-rustfs-content-sha256";
 const NONCE_HEADER: &str = "x-rustfs-rpc-nonce";
-const TIMESTAMP_HEADER: &str = "x-rustfs-timestamp";
-const BOOT_EPOCH_CHALLENGE_HEADER: &str = "x-rustfs-rpc-boot-epoch-challenge";

 /// gRPC service name carried in the signed scope, i.e. `TONIC_RPC_PREFIX`
 /// without its leading `/`.
@@ -162,28 +155,19 @@ fn align_rpc_secret_with_server() {
 ///
 /// Uses the no-cleanup spawn so a `pkill` pattern cannot reap servers belonging
 /// to other tests running in the same binary.
-fn server_env(extra_env: &[(&'static str, &'static str)]) -> Vec<(&'static str, &'static str)> {
+async fn start_server(extra_env: &[(&str, &str)]) -> Result<RustFSTestEnvironment, Box<dyn Error + Send + Sync>> {
+    let mut env = RustFSTestEnvironment::new().await?;
    let mut child_env = vec![
        ("RUSTFS_RPC_SECRET", TEST_RPC_SECRET),
        (ENV_INTERNODE_RPC_SIGNATURE_STRICT, "false"),
        (ENV_INTERNODE_RPC_BODY_DIGEST_STRICT, "false"),
-        (ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT, "false"),
        (ENV_INTERNODE_RPC_REPLAY_CACHE_CAPACITY, "1048576"),
    ];
    child_env.extend_from_slice(extra_env);
-    child_env
-}
-
-async fn start_server_with_env(child_env: &[(&str, &str)]) -> Result<RustFSTestEnvironment, Box<dyn Error + Send + Sync>> {
-    let mut env = RustFSTestEnvironment::new().await?;
-    env.start_rustfs_server_without_cleanup_with_env(child_env).await?;
+    env.start_rustfs_server_without_cleanup_with_env(&child_env).await?;
    Ok(env)
 }

-async fn start_server(extra_env: &[(&'static str, &'static str)]) -> Result<RustFSTestEnvironment, Box<dyn Error + Send + Sync>> {
-    start_server_with_env(&server_env(extra_env)).await
-}
-
 /// Stop the child and drop the cached gRPC channel for its address.
 ///
 /// `node_service_time_out_client_no_auth` memoises channels in a process-global
@@ -254,83 +238,12 @@ fn overwrite_header(headers: &mut HeaderMap, name: &'static str, value: &str) {
 /// and nothing else — no interceptor adds or rewrites auth metadata, so the
 /// bytes on the wire are the ones the test chose.
 async fn call_make_volume(url: &str, request: MakeVolumeRequest, headers: HeaderMap) -> Result<MakeVolumeResponse, Status> {
-    call_make_volume_response(url, request, headers)
-        .await
-        .map(Response::into_inner)
-}
-
-async fn call_make_volume_response(
-    url: &str,
-    request: MakeVolumeRequest,
-    headers: HeaderMap,
-) -> Result<Response<MakeVolumeResponse>, Status> {
    let mut client = node_service_time_out_client_no_auth(&url.to_string())
        .await
        .map_err(|err| Status::unavailable(format!("cannot reach the node service: {err}")))?;
    let mut rpc_request = Request::new(request);
    rpc_request.metadata_mut().as_mut().extend(headers);
-    client.make_volume(rpc_request).await
-}
-
-async fn call_ping_response(url: &str, headers: HeaderMap) -> Result<Response<PingResponse>, Status> {
-    let mut client = node_service_time_out_client_no_auth(&url.to_string())
-        .await
-        .map_err(|err| Status::unavailable(format!("cannot reach the node service: {err}")))?;
-    let mut rpc_request = Request::new(PingRequest {
-        version: 1,
-        body: bytes::Bytes::new(),
-    });
-    rpc_request.metadata_mut().as_mut().extend(headers);
-    client.ping(rpc_request).await
-}
-
-fn attach_boot_epoch_challenge(headers: &mut HeaderMap) -> Uuid {
-    let challenge = Uuid::new_v4();
-    headers.insert(
-        BOOT_EPOCH_CHALLENGE_HEADER,
-        challenge.to_string().parse().expect("UUID must be a valid header value"),
-    );
-    challenge
-}
-
-fn mint_replay_scope_headers(audience: &str, path: &str, content_sha256: &str, boot_epoch: Uuid) -> HeaderMap {
-    let mut headers = mint_v2_headers(audience, "MakeVolume", Some(content_sha256));
-    let timestamp = headers
-        .get(TIMESTAMP_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .expect("v2 headers must carry a timestamp")
-        .to_string();
-    headers.extend(
-        gen_tonic_replay_scope_headers(audience, path, &timestamp, content_sha256, boot_epoch)
-            .expect("replay-scope headers must mint with the aligned RPC secret"),
-    );
-    headers
-}
-
-async fn learn_boot_epoch_from_make_volume(url: &str, audience: &str) -> Uuid {
-    let request = make_volume_request("signature-e2e-epoch-bootstrap");
-    let mut headers = mint_v2_headers(audience, "MakeVolume", Some(&canonical_digest(&request)));
-    let challenge = attach_boot_epoch_challenge(&mut headers);
-    let response = call_make_volume_response(url, request, headers)
-        .await
-        .expect("v2 request with epoch challenge must clear default authentication");
-    let boot_epoch = verify_tonic_boot_epoch_response(audience, challenge, response.metadata().as_ref())
-        .expect("server must HMAC-authenticate the advertised boot epoch");
-    assert_authenticated(
-        Ok(response.into_inner()),
-        "a v2 epoch-challenge request in the default replay-scope posture",
-    );
-    boot_epoch
-}
-
-async fn learn_boot_epoch_from_ping(url: &str, audience: &str) -> Uuid {
-    let mut headers = mint_v2_headers(audience, "Ping", None);
-    let challenge = attach_boot_epoch_challenge(&mut headers);
-    let response = call_ping_response(url, headers)
-        .await
-        .expect("v2 Ping with an epoch challenge must bootstrap strict replay scope");
-    verify_tonic_boot_epoch_response(audience, challenge, response.metadata().as_ref())
-        .expect("strict replay-scope Ping must return a valid boot epoch proof")
+    client.make_volume(rpc_request).await.map(|response| response.into_inner())
 }

 /// Assert a call cleared authentication.
@@ -419,122 +332,6 @@ async fn internode_rpc_signature_default_posture_e2e() -> TestResult {
    Ok(())
 }

-/// A replay-scoped signature is usable exactly once against the exact gRPC path and the server
-/// process epoch that minted it. This crosses the child-process boundary twice: the HMAC-protected
-/// epoch is learned from a real response, then the same server is restarted in place to prove its
-/// replacement epoch rejects the captured request even though the nonce cache is necessarily new.
-#[tokio::test]
-#[serial]
-async fn replay_scope_rejects_replay_path_transplant_and_stale_epoch_e2e() -> TestResult {
-    init_logging();
-    align_rpc_secret_with_server();
-    let child_env = server_env(&[]);
-    let mut env = start_server_with_env(&child_env).await?;
-    let url = env.url.clone();
-    let audience = audience_of(&env);
-    let boot_epoch = learn_boot_epoch_from_make_volume(&url, &audience).await;
-
-    let request = make_volume_request("replay-scope-e2e-once");
-    let captured = mint_replay_scope_headers(
-        &audience,
-        &format!("{TONIC_RPC_PREFIX}/MakeVolume"),
-        &canonical_digest(&request),
-        boot_epoch,
-    );
-    assert_authenticated(
-        call_make_volume(&url, request.clone(), captured.clone()).await,
-        "the first replay-scoped mutation delivery",
-    );
-    assert_rejected(
-        call_make_volume(&url, request.clone(), captured).await,
-        Code::Unauthenticated,
-        None,
-        "the same replay-scoped mutation delivered twice",
-    );
-
-    let transplanted =
-        mint_replay_scope_headers(&audience, &format!("{TONIC_RPC_PREFIX}/Ping"), &canonical_digest(&request), boot_epoch);
-    assert_rejected(
-        call_make_volume(&url, request.clone(), transplanted).await,
-        Code::Unauthenticated,
-        None,
-        "a replay-scoped Ping signature transplanted onto MakeVolume",
-    );
-
-    let stale_epoch = mint_replay_scope_headers(
-        &audience,
-        &format!("{TONIC_RPC_PREFIX}/MakeVolume"),
-        &canonical_digest(&request),
-        boot_epoch,
-    );
-    env.restart_server_preserving_data(Vec::new(), &child_env).await?;
-    rustfs_protos::evict_failed_connection(&url).await;
-    assert_rejected(
-        call_make_volume(&url, request.clone(), stale_epoch).await,
-        Code::Unauthenticated,
-        None,
-        "a replay-scoped signature captured before the receiving process restart",
-    );
-
-    let restarted_epoch = learn_boot_epoch_from_make_volume(&url, &audience).await;
-    assert_ne!(boot_epoch, restarted_epoch, "a restarted child process must advertise a new boot epoch");
-    let fresh_epoch = mint_replay_scope_headers(
-        &audience,
-        &format!("{TONIC_RPC_PREFIX}/MakeVolume"),
-        &canonical_digest(&request),
-        restarted_epoch,
-    );
-    assert_authenticated(
-        call_make_volume(&url, request, fresh_epoch).await,
-        "a replay-scoped mutation signed with the replacement process epoch",
-    );
-
-    stop_server(env, &url).await;
-    Ok(())
-}
-
-/// Strict replay scope leaves one authenticated v2 bootstrap: `Ping` carrying a fresh challenge.
-/// A mutating v2 request cannot use that lane; once the epoch proof is returned, the first v3
-/// mutation succeeds. This protects a server restart without reopening a general downgrade path.
-#[tokio::test]
-#[serial]
-async fn replay_scope_strict_requires_v3_after_ping_bootstrap_e2e() -> TestResult {
-    init_logging();
-    align_rpc_secret_with_server();
-    let env = start_server(&[(ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT, "true")]).await?;
-    let url = env.url.clone();
-    let audience = audience_of(&env);
-
-    let v2_request = make_volume_request("replay-scope-e2e-strict-v2");
-    assert_rejected(
-        call_make_volume(
-            &url,
-            v2_request.clone(),
-            mint_v2_headers(&audience, "MakeVolume", Some(&canonical_digest(&v2_request))),
-        )
-        .await,
-        Code::Unauthenticated,
-        None,
-        "a v2 mutation after replay-scope strictness is enabled",
-    );
-
-    let boot_epoch = learn_boot_epoch_from_ping(&url, &audience).await;
-    let request = make_volume_request("replay-scope-e2e-strict-v3");
-    let replay_scoped = mint_replay_scope_headers(
-        &audience,
-        &format!("{TONIC_RPC_PREFIX}/MakeVolume"),
-        &canonical_digest(&request),
-        boot_epoch,
-    );
-    assert_authenticated(
-        call_make_volume(&url, request, replay_scoped).await,
-        "a replay-scoped mutation after Ping bootstrap under strict replay scope",
-    );
-
-    stop_server(env, &url).await;
-    Ok(())
-}
-
 /// Baseline: correctly signed mutations are accepted, both with and without a
 /// body digest.
 ///
@@ -30,7 +30,6 @@ use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::types::ServerSideEncryption;
 use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
 use http::header::{CONTENT_TYPE, HOST};
-use md5::{Digest as Md5Digest, Md5};
 use rustfs_signer::constants::UNSIGNED_PAYLOAD;
 use rustfs_signer::sign_v4;
 use s3s::Body;
@@ -69,9 +68,7 @@ pub fn skip_if_kms_admin_tool_unavailable(test_name: &str) -> bool {
 }

 pub fn sse_customer_key_md5_base64(key: &str) -> String {
-    let mut hasher = Md5::new();
-    hasher.update(key.as_bytes());
-    BASE64.encode(hasher.finalize())
+    BASE64.encode(md5::compute(key).0)
 }

 pub async fn kms_admin_request(
@@ -25,18 +25,12 @@ use super::common::{LocalKMSTestEnvironment, sse_customer_key_md5_base64};
 use crate::common::{TEST_BUCKET, init_logging};
 use aws_sdk_s3::types::ServerSideEncryption;
 use base64::Engine;
-use md5::{Digest as Md5Digest, Md5};
+use md5::compute;
 use serial_test::serial;
 use std::sync::Arc;
 use tokio::sync::Semaphore;
 use tracing::{info, warn};

-fn md5_hex(input: impl AsRef<[u8]>) -> String {
-    let mut hasher = Md5::new();
-    hasher.update(input.as_ref());
-    hex::encode(hasher.finalize())
-}
-
 /// Test encryption of zero-byte files (empty files)
 #[tokio::test]
 #[serial]
@@ -300,7 +294,7 @@ async fn test_kms_invalid_key_scenarios() -> Result<(), Box<dyn std::error::Erro
    info!("🔍 Testing invalid SSE-C key length");
    let invalid_short_key = "short"; // Too short
    let invalid_key_b64 = base64::engine::general_purpose::STANDARD.encode(invalid_short_key);
-    let invalid_key_md5 = md5_hex(invalid_short_key);
+    let invalid_key_md5 = format!("{:x}", compute(invalid_short_key));

    let invalid_key_result = s3_client
        .put_object()
@@ -26,7 +26,6 @@ use chrono::{Duration as ChronoDuration, Utc};
 use flate2::{Compression, write::GzEncoder};
 use http::HeaderValue;
 use http::header::{CONTENT_TYPE, HOST};
-use md5::{Digest as Md5Digest, Md5};
 use rustfs_signer::constants::UNSIGNED_PAYLOAD;
 use rustfs_signer::sign_v4;
 use s3s::Body;
@@ -51,15 +50,7 @@ fn encode_post_policy(conditions: Vec<serde_json::Value>) -> String {
 }

 fn sse_customer_key_md5_base64(key: &str) -> String {
-    let mut hasher = Md5::new();
-    hasher.update(key.as_bytes());
-    base64::engine::general_purpose::STANDARD.encode(hasher.finalize())
-}
-
-fn md5_hex(input: impl AsRef<[u8]>) -> String {
-    let mut hasher = Md5::new();
-    hasher.update(input.as_ref());
-    hex::encode(hasher.finalize())
+    base64::engine::general_purpose::STANDARD.encode(md5::compute(key).0)
 }

 /// Env var consumed by the local SSE-S3 DEK provider when KMS is not configured.
@@ -5673,7 +5664,7 @@ async fn test_signed_put_object_extract_returns_archive_etag() -> Result<(), Box
    client.create_bucket().bucket(bucket).send().await?;

    let archive = make_tar(&[("alpha.txt", b"alpha-body")], &[]).await;
-    let expected_etag = format!("\"{}\"", md5_hex(&archive));
+    let expected_etag = format!("\"{:x}\"", md5::compute(&archive));

    let response = client
        .put_object()
@@ -21,22 +21,18 @@
 //! function, never as an S3 event sink.
 //!
 //! Coverage:
-//!   * PUT / multipart-complete / DeleteObject / DeleteObjects each deliver one event with the correct
+//!   * PUT / multipart-complete / DELETE each deliver one event with the correct
 //!     eventName, bucket, key, versionId and eTag.
 //!   * prefix/suffix filters drop non-matching keys (rule-engine gate).
 //!   * an event queued while the target endpoint is unreachable is redelivered
 //!     from the on-disk store once the endpoint recovers (store-and-forward).
-//!   * responseElements and the S3 response use the canonical request ID while
-//!     requestParameters preserve a conflicting client-supplied value.

 use crate::common::{RustFSTestEnvironment, init_logging};
 use aws_sdk_s3::Client;
-use aws_sdk_s3::operation::RequestId;
 use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::types::{
-    BucketVersioningStatus, CompletedMultipartUpload, CompletedPart, Delete, Event, FilterRule, FilterRuleName,
-    NotificationConfiguration, NotificationConfigurationFilter, ObjectIdentifier, QueueConfiguration, S3KeyFilter,
-    VersioningConfiguration,
+    BucketVersioningStatus, CompletedMultipartUpload, CompletedPart, Event, FilterRule, FilterRuleName,
+    NotificationConfiguration, NotificationConfigurationFilter, QueueConfiguration, S3KeyFilter, VersioningConfiguration,
 };
 use http::header::{CONTENT_TYPE, HOST};
 use local_ip_address::local_ip;
@@ -44,12 +40,10 @@ use reqwest::StatusCode;
 use rustfs_signer::constants::UNSIGNED_PAYLOAD;
 use rustfs_signer::sign_v4;
 use rustfs_utils::egress::ENV_OUTBOUND_ALLOW_ORIGINS;
-use rustfs_utils::http::headers::{AMZ_REQUEST_ID, REQUEST_ID_HEADER};
 use s3s::Body;
 use serde_json::Value;
 use serial_test::serial;
 use std::error::Error;
-use std::io::Cursor;
 use std::path::Path;
 use std::sync::{
    Arc, Once,
@@ -69,8 +63,6 @@ type BoxError = Box<dyn Error + Send + Sync>;
 /// for target lookup (see `process_queue_configurations`), so the region is
 /// nominal, but it must be present for `ARN::parse` to succeed.
 const NOTIFY_REGION: &str = "us-east-1";
-const CLIENT_REQUEST_ID: &str = "client-supplied-request-id";
-const CLIENT_AMZ_REQUEST_ID: &str = "client-supplied-amz-request-id";

 /// Webhook targets are registered as `TargetID { id: <name>, name: "webhook" }`,
 /// so the ARN a notification rule references is
@@ -587,36 +579,6 @@ fn trimmed_etag(value: Option<&str>) -> Option<String> {
    value.map(|e| e.trim_matches('"').to_string())
 }

-fn assert_conflicting_request_id_correlation(record: &Value, server_request_id: &str) {
-    assert_eq!(
-        record["requestParameters"][REQUEST_ID_HEADER].as_str(),
-        Some(CLIENT_REQUEST_ID),
-        "notification request parameters should retain the actual client header: {record}"
-    );
-    assert_eq!(
-        record["requestParameters"][AMZ_REQUEST_ID].as_str(),
-        Some(CLIENT_AMZ_REQUEST_ID),
-        "notification request parameters should retain the actual client header: {record}"
-    );
-    assert_eq!(
-        record["responseElements"][AMZ_REQUEST_ID].as_str(),
-        Some(server_request_id),
-        "notification response elements should use the canonical request ID: {record}"
-    );
-}
-
-fn assert_generated_request_id_correlation(record: &Value, request_id: &str) {
-    assert!(
-        record["requestParameters"][AMZ_REQUEST_ID].is_null(),
-        "notification request parameters must not invent a client request header: {record}"
-    );
-    assert_eq!(
-        record["responseElements"][AMZ_REQUEST_ID].as_str(),
-        Some(request_id),
-        "notification response elements should match the S3 response request ID: {record}"
-    );
-}
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -709,17 +671,8 @@ async fn test_webhook_event_delivery_and_filtering() -> TestResult {
        .bucket(bucket)
        .key(put_key)
        .body(ByteStream::from_static(b"peri-1 put body"))
-        .customize()
-        .mutate_request(|request| {
-            request.headers_mut().insert(REQUEST_ID_HEADER, CLIENT_REQUEST_ID);
-            request.headers_mut().insert(AMZ_REQUEST_ID, CLIENT_AMZ_REQUEST_ID);
-        })
        .send()
        .await?;
-    let put_request_id = put.request_id().ok_or("PUT response missing request ID")?.to_owned();
-    assert!(uuid::Uuid::parse_str(&put_request_id).is_ok());
-    assert_ne!(put_request_id, CLIENT_REQUEST_ID);
-    assert_ne!(put_request_id, CLIENT_AMZ_REQUEST_ID);
    let put_version = put
        .version_id()
        .ok_or("PUT response missing versionId (versioning not enabled?)")?;
@@ -739,7 +692,6 @@ async fn test_webhook_event_delivery_and_filtering() -> TestResult {
        "record eventName: {record}"
    );
    assert_eq!(record["s3"]["bucket"]["name"].as_str(), Some(bucket), "bucket in event: {record}");
-    assert_conflicting_request_id_correlation(record, &put_request_id);
    assert_eq!(object["versionId"].as_str(), Some(put_version), "versionId in event: {object}");
    assert_eq!(
        trimmed_etag(object["eTag"].as_str()),
@@ -792,35 +744,6 @@ async fn test_webhook_event_delivery_and_filtering() -> TestResult {
        "multipart eTag in event: {mp_record}"
    );

-    // --- Snowball extract: direct notification path keeps response correlation
-    let snowball_key = "uploads/snowball.dat";
-    let snowball_body = b"snowball notification body";
-    let mut archive_builder = tokio_tar::Builder::new(Cursor::new(Vec::new()));
-    let mut archive_header = tokio_tar::Header::new_gnu();
-    archive_header.set_size(u64::try_from(snowball_body.len()).expect("snowball fixture length should fit in u64"));
-    archive_header.set_mode(0o644);
-    archive_header.set_cksum();
-    archive_builder
-        .append_data(&mut archive_header, snowball_key, Cursor::new(snowball_body))
-        .await?;
-    let archive = archive_builder.into_inner().await?.into_inner();
-    let snowball = client
-        .put_object()
-        .bucket(bucket)
-        .key("snowball-fixture.tar")
-        .body(ByteStream::from(archive))
-        .customize()
-        .mutate_request(|request| {
-            request.headers_mut().insert("x-amz-meta-snowball-auto-extract", "true");
-        })
-        .send()
-        .await?;
-    let snowball_request_id = snowball.request_id().ok_or("Snowball response missing request ID")?;
-
-    let snowball_event = wait_for_event(&mut rx, snowball_key, "s3:ObjectCreated:", Duration::from_secs(20)).await?;
-    let snowball_record = &snowball_event["Records"][0];
-    assert_generated_request_id_correlation(snowball_record, snowball_request_id);
-
    // --- Filter: non-matching prefix and suffix must never be delivered ------
    let wrong_prefix = "logs/report.dat"; // right suffix, wrong prefix
    let wrong_suffix = "uploads/report.txt"; // right prefix, wrong suffix
@@ -849,32 +772,7 @@ async fn test_webhook_event_delivery_and_filtering() -> TestResult {
        "wrong-suffix key {wrong_suffix} bypassed the filter; saw {seen:?}"
    );

-    // --- DeleteObjects: direct notification path keeps response correlation --
-    let delete_many_key = "uploads/delete-many.dat";
-    client
-        .put_object()
-        .bucket(bucket)
-        .key(delete_many_key)
-        .body(ByteStream::from_static(b"delete objects notification body"))
-        .send()
-        .await?;
-    wait_for_event(&mut rx, delete_many_key, "s3:ObjectCreated:", Duration::from_secs(20)).await?;
-
-    let delete_many = client
-        .delete_objects()
-        .bucket(bucket)
-        .delete(
-            Delete::builder()
-                .objects(ObjectIdentifier::builder().key(delete_many_key).build()?)
-                .build()?,
-        )
-        .send()
-        .await?;
-    let delete_many_request_id = delete_many.request_id().ok_or("DeleteObjects response missing request ID")?;
-    let delete_many_event = wait_for_event(&mut rx, delete_many_key, "s3:ObjectRemoved:", Duration::from_secs(20)).await?;
-    assert_generated_request_id_correlation(&delete_many_event["Records"][0], delete_many_request_id);
-
-    // --- DeleteObject on a versioned bucket: delete-marker version ----------
+    // --- DELETE on a versioned bucket: ObjectRemoved:* with delete-marker version
    let delete = client.delete_object().bucket(bucket).key(put_key).send().await?;
    let removed = wait_for_event(&mut rx, put_key, "s3:ObjectRemoved:", Duration::from_secs(20)).await?;
    let removed_record = &removed["Records"][0];
@@ -26,7 +26,6 @@

 use super::common::*;
 use aws_sdk_s3::Client;
-use aws_sdk_s3::error::ProvideErrorMetadata;
 use aws_sdk_s3::primitives::{ByteStream, DateTimeFormat};
 use aws_sdk_s3::types::{
    CompletedMultipartUpload, CompletedPart, Delete, MetadataDirective, ObjectIdentifier, ObjectLockLegalHoldStatus,
@@ -2121,127 +2120,6 @@ async fn test_multipart_default_retention_fixed_at_create() {
 // Versioning Auto-Enable Tests
 // ============================================================================

-#[tokio::test]
-#[serial]
-async fn test_unretained_object_lock_object_delete_and_bucket_cleanup() {
-    init_logging();
-    info!("🧪 Test: Unretained Object Lock object delete and bucket cleanup (Issue #5339)");
-
-    let mut env = ObjectLockTestEnvironment::new()
-        .await
-        .expect("failed to create Object Lock test environment");
-    env.start_rustfs().await.expect("failed to start RustFS");
-
-    let bucket = "test-object-lock-delete-cleanup";
-    let key = "unretained-object";
-
-    env.create_object_lock_bucket(bucket)
-        .await
-        .expect("failed to create Object Lock bucket");
-    let client = env.s3_client();
-
-    let put_response = client
-        .put_object()
-        .bucket(bucket)
-        .key(key)
-        .body(ByteStream::from_static(b"unretained data"))
-        .send()
-        .await
-        .expect("failed to upload unretained object");
-    let object_version_id = put_response
-        .version_id()
-        .expect("Object Lock buckets must create versioned objects")
-        .to_string();
-
-    let delete_response = client
-        .delete_object()
-        .bucket(bucket)
-        .key(key)
-        .send()
-        .await
-        .expect("failed to create delete marker");
-    assert_eq!(delete_response.delete_marker(), Some(true));
-    let delete_marker_version_id = delete_response
-        .version_id()
-        .expect("Deleting without a version ID must create a delete marker")
-        .to_string();
-
-    let get_error = client
-        .get_object()
-        .bucket(bucket)
-        .key(key)
-        .send()
-        .await
-        .expect_err("GET must not return an object hidden by a delete marker");
-    assert_eq!(get_error.raw_response().map(|response| response.status().as_u16()), Some(404));
-    assert_eq!(get_error.as_service_error().and_then(|error| error.code()), Some("NoSuchKey"));
-
-    let listed_objects = client
-        .list_objects_v2()
-        .bucket(bucket)
-        .send()
-        .await
-        .expect("failed to list current objects");
-    assert!(
-        listed_objects.contents().iter().all(|object| object.key() != Some(key)),
-        "ListObjectsV2 must hide objects whose latest version is a delete marker"
-    );
-
-    let listed_versions = client
-        .list_object_versions()
-        .bucket(bucket)
-        .send()
-        .await
-        .expect("failed to list object versions");
-    assert!(
-        listed_versions
-            .versions()
-            .iter()
-            .any(|version| version.key() == Some(key) && version.version_id() == Some(object_version_id.as_str())),
-        "The data version must remain until it is explicitly deleted"
-    );
-    assert!(
-        listed_versions
-            .delete_markers()
-            .iter()
-            .any(|marker| marker.key() == Some(key) && marker.version_id() == Some(delete_marker_version_id.as_str())),
-        "ListObjectVersions must expose the delete marker"
-    );
-
-    client
-        .delete_object()
-        .bucket(bucket)
-        .key(key)
-        .version_id(object_version_id)
-        .send()
-        .await
-        .expect("failed to delete the data version");
-    client
-        .delete_object()
-        .bucket(bucket)
-        .key(key)
-        .version_id(delete_marker_version_id)
-        .send()
-        .await
-        .expect("failed to delete the delete marker");
-
-    let remaining_versions = client
-        .list_object_versions()
-        .bucket(bucket)
-        .send()
-        .await
-        .expect("failed to list versions after cleanup");
-    assert!(remaining_versions.versions().is_empty());
-    assert!(remaining_versions.delete_markers().is_empty());
-
-    client
-        .delete_bucket()
-        .bucket(bucket)
-        .send()
-        .await
-        .expect("Deleting every version must remove xl.meta so the bucket can be deleted normally");
-}
-
 #[tokio::test]
 #[serial]
 async fn test_versioning_auto_enabled_with_object_lock() {
@@ -24,7 +24,7 @@ use rustfs_protos::proto_gen::node_service::{BatchGenerallyLockRequest, Generall
 use tonic::Request;
 use tracing::{info, warn};

-use crate::storage_api::grpc_lock::{AuthenticatedChannel, TonicInterceptor, node_service_time_out_client_no_auth};
+use crate::storage_api::grpc_lock::{TonicInterceptor, node_service_time_out_client_no_auth};

 /// gRPC lock client without authentication for testing
 /// Similar to RemoteClient but uses no_auth client
@@ -42,7 +42,7 @@ impl GrpcLockClient {
        &self,
    ) -> Result<
        rustfs_protos::proto_gen::node_service::node_service_client::NodeServiceClient<
-            tonic::service::interceptor::InterceptedService<AuthenticatedChannel, TonicInterceptor>,
+            tonic::service::interceptor::InterceptedService<tonic::transport::Channel, TonicInterceptor>,
        >,
    > {
        node_service_time_out_client_no_auth(&self.addr)
@@ -23,8 +23,7 @@ use rustfs_protos::{
    proto_gen::node_service::{
        BatchGenerallyLockRequest, BatchGenerallyLockResponse, BatchReadVersionRequest, BatchReadVersionResponse,
        GenerallyLockRequest, GenerallyLockResponse, GenerallyLockResult, PingRequest, PingResponse,
-        SnapshotLeaseMutationResponse, SnapshotLeaseReleaseRequest, SnapshotLeaseRenewRequest, SnapshotLeaseRequest,
-        SnapshotLeaseResponse, node_service_server::NodeService,
+        node_service_server::NodeService,
    },
 };
 use std::pin::Pin;
@@ -105,27 +104,6 @@ impl NodeService for MinimalLockNodeService {
        Err(Status::unimplemented("MinimalLockNodeService only supports lock RPCs"))
    }

-    async fn acquire_snapshot_lease(
-        &self,
-        _request: Request<SnapshotLeaseRequest>,
-    ) -> Result<Response<SnapshotLeaseResponse>, Status> {
-        Err(Status::unimplemented("MinimalLockNodeService only supports lock RPCs"))
-    }
-
-    async fn renew_snapshot_lease(
-        &self,
-        _request: Request<SnapshotLeaseRenewRequest>,
-    ) -> Result<Response<SnapshotLeaseResponse>, Status> {
-        Err(Status::unimplemented("MinimalLockNodeService only supports lock RPCs"))
-    }
-
-    async fn release_snapshot_lease(
-        &self,
-        _request: Request<SnapshotLeaseReleaseRequest>,
-    ) -> Result<Response<SnapshotLeaseMutationResponse>, Status> {
-        Err(Status::unimplemented("MinimalLockNodeService only supports lock RPCs"))
-    }
-
    async fn lock(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
        let request = request.into_inner();
        let args: LockRequest = match serde_json::from_str(&request.args) {
@@ -15,7 +15,9 @@

 use super::{grpc_lock_client::GrpcLockClient, grpc_lock_server::spawn_lock_server};
 use rustfs_lock::client::{LockClient, local::LocalClient};
-use rustfs_lock::{GlobalLockManager, LockInfo, LockRequest, LockResponse, LockStats, LockType, NamespaceLock, ObjectKey};
+use rustfs_lock::{
+    GlobalLockManager, LockError, LockInfo, LockRequest, LockResponse, LockStats, LockType, NamespaceLock, ObjectKey,
+};
 use std::sync::Arc;
 use std::time::Duration;

@@ -33,11 +35,7 @@ struct FailingClient;
 #[async_trait::async_trait]
 impl rustfs_lock::LockClient for FailingClient {
    async fn acquire_lock(&self, _request: &rustfs_lock::LockRequest) -> rustfs_lock::Result<LockResponse> {
-        // Match RemoteClient's transport-failure response so the coordinator can count this node toward quorum loss.
-        Ok(LockResponse::failure(
-            "Remote lock RPC failed: simulated gRPC node failure",
-            Duration::ZERO,
-        ))
+        Err(LockError::internal("simulated gRPC node failure"))
    }

    async fn release(&self, _lock_id: &rustfs_lock::LockId) -> rustfs_lock::Result<bool> {
@@ -95,7 +95,6 @@ const MANUAL_ASYNC_PARALLEL_OBJECTS: usize = 64;
 const MANUAL_ACTIVE_CANCEL_OBJECTS: usize = 512;
 const MANUAL_RESTART_CANCEL_OBJECTS: usize = 512;
 const MANUAL_ACTIVE_CANCEL_RUNNING_TIMEOUT: StdDuration = StdDuration::from_secs(15);
-const MANUAL_TRANSITION_CANCEL_BARRIER_ENV: &str = "RUSTFS_E2E_MANUAL_TRANSITION_CANCEL_BARRIER";
 const MANUAL_ASYNC_CONFLICT_TERMINAL_TIMEOUT: StdDuration = StdDuration::from_secs(90);
 const MANUAL_RESTART_RECOVERY_TIMEOUT: StdDuration = StdDuration::from_secs(80);
 const OBJECT_KEY: &str = "tier/鲁A12345/report.bin";
@@ -382,6 +381,7 @@ struct ManualTransitionRunReport {
    skipped_delete_marker: u64,
    skipped_directory: u64,
    skipped_replication: u64,
+    skipped_already_transitioned: u64,
    skipped_already_in_flight: u64,
    skipped_queue_full: u64,
    skipped_queue_closed: u64,
@@ -407,6 +407,41 @@ fn assert_completed_or_in_flight_partial(state: &str, report: &ManualTransitionR
    }
 }

+fn assert_conflict_winner_report(state: &str, report: &ManualTransitionRunReport, expected_objects: u64, context: &str) {
+    assert_completed_or_in_flight_partial(state, report, context);
+    if report.skipped_already_in_flight > 0 {
+        assert!(
+            report.scanned <= expected_objects,
+            "{context}: scanned more objects than the conflict scope contains: {report:#?}"
+        );
+        assert!(
+            report.eligible <= expected_objects,
+            "{context}: marked more objects eligible than the conflict scope contains: {report:#?}"
+        );
+        assert_eq!(
+            report.enqueued + report.skipped_already_in_flight,
+            report.eligible,
+            "{context}: partial in-flight accounting must cover every eligible object: {report:#?}"
+        );
+    } else {
+        assert_eq!(report.scanned, expected_objects, "{context}: {report:#?}");
+        assert_eq!(
+            report.eligible + report.skipped_already_transitioned,
+            expected_objects,
+            "{context}: {report:#?}"
+        );
+        assert_eq!(
+            report.enqueued + report.skipped_already_in_flight,
+            expected_objects,
+            "{context}: {report:#?}"
+        );
+    }
+    assert_eq!(
+        report.transition_completed, report.enqueued,
+        "{context}: winner must wait for all queued transitions: {report:#?}"
+    );
+}
+
 #[derive(Debug, Deserialize)]
 struct ManualTransitionQueueSnapshot {
    queue_capacity: u64,
@@ -1240,15 +1275,8 @@ async fn test_manual_transition_async_scope_conflicts_report_active_job() -> Tes
    cold_client.create_bucket().bucket(TIER_BUCKET).send().await?;

    let mut hot = RustFSTestEnvironment::new().await?;
-    hot.start_rustfs_server_with_env(
-        vec![],
-        &[
-            ("RUSTFS_SCANNER_ENABLED", "false"),
-            ("RUSTFS_SCANNER_CYCLE", "3600"),
-            (MANUAL_TRANSITION_CANCEL_BARRIER_ENV, "1"),
-        ],
-    )
-    .await?;
+    hot.start_rustfs_server_with_env(vec![], &[("RUSTFS_SCANNER_ENABLED", "false"), ("RUSTFS_SCANNER_CYCLE", "3600")])
+        .await?;
    let hot_client = hot.create_s3_client();
    add_rustfs_tier(&hot, &cold).await?;

@@ -1318,21 +1346,20 @@ async fn test_manual_transition_async_scope_conflicts_report_active_job() -> Tes
    assert_eq!(conflict.cancel_endpoint, status_endpoint);
    assert!(!conflict.scope_key.is_empty());

-    manual_transition_job_cancel(&hot, cancel_endpoint).await?;
-
    let terminal = wait_for_manual_transition_job_terminal(&hot, status_endpoint, MANUAL_ASYNC_CONFLICT_TERMINAL_TIMEOUT).await?;
    assert_eq!(terminal.job_id, job_id);
-    assert_eq!(terminal.status, "cancelled", "terminal conflict winner response: {terminal:#?}");
    assert!(!terminal.report.dry_run);
    assert_eq!(terminal.report.bucket, MANUAL_ASYNC_CONFLICT_BUCKET);
    assert_eq!(terminal.report.prefix, accepted.report.prefix);
-    assert!(terminal.report.cancelled, "terminal conflict winner response: {terminal:#?}");
-    assert_eq!(terminal.report.scanned, 0, "terminal conflict winner response: {terminal:#?}");
-    assert_eq!(terminal.report.enqueued, 0, "terminal conflict winner response: {terminal:#?}");
-    assert_eq!(
-        terminal.report.transition_completed, 0,
-        "terminal conflict winner response: {terminal:#?}"
+    assert_conflict_winner_report(
+        &terminal.status,
+        &terminal.report,
+        MANUAL_ASYNC_CONFLICT_OBJECTS as u64,
+        "terminal conflict winner response",
    );
+    assert_eq!(terminal.report.dry_run_eligible, 0, "terminal conflict winner response: {terminal:#?}");
+    assert_eq!(terminal.report.transition_failed, 0, "terminal conflict winner response: {terminal:#?}");
+    assert_eq!(terminal.report.tier_failure, 0, "terminal conflict winner response: {terminal:#?}");
    let after_remote_count = cold_tier_object_count(&cold_client).await?;
    assert!(after_remote_count >= before_remote_count);
    assert!(after_remote_count <= before_remote_count + MANUAL_ASYNC_CONFLICT_OBJECTS);
@@ -1657,15 +1684,8 @@ async fn test_manual_transition_async_active_cancel_reports_terminal_cancelled()
    cold_client.create_bucket().bucket(TIER_BUCKET).send().await?;

    let mut hot = RustFSTestEnvironment::new().await?;
-    hot.start_rustfs_server_with_env(
-        vec![],
-        &[
-            ("RUSTFS_SCANNER_ENABLED", "false"),
-            ("RUSTFS_SCANNER_CYCLE", "3600"),
-            (MANUAL_TRANSITION_CANCEL_BARRIER_ENV, "1"),
-        ],
-    )
-    .await?;
+    hot.start_rustfs_server_with_env(vec![], &[("RUSTFS_SCANNER_ENABLED", "false"), ("RUSTFS_SCANNER_CYCLE", "3600")])
+        .await?;
    let hot_client = hot.create_s3_client();
    add_rustfs_tier(&hot, &cold).await?;

@@ -22,7 +22,6 @@ use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::types::{BucketVersioningStatus, CompletedMultipartUpload, CompletedPart, VersioningConfiguration};
 use aws_smithy_http_client::Builder as SmithyHttpClientBuilder;
 use base64::Engine;
-use md5::{Digest as Md5Digest, Md5};
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
@@ -103,12 +102,10 @@ impl Intercept for ResponseHeaderCapture {

 fn customer_key(byte: u8) -> CustomerKey {
    let raw = [byte; 32];
-    let mut hasher = Md5::new();
-    hasher.update(raw);
    CustomerKey {
        raw: String::from_utf8_lossy(&raw).into_owned(),
        encoded: base64::engine::general_purpose::STANDARD.encode(raw),
-        md5: base64::engine::general_purpose::STANDARD.encode(hasher.finalize()),
+        md5: base64::engine::general_purpose::STANDARD.encode(md5::compute(raw).0),
    }
 }

@@ -16,12 +16,9 @@
 pub(crate) use rustfs_ecstore::api::bucket::bucket_target_sys::BucketTargetSys;
 #[cfg(test)]
 pub(crate) use rustfs_ecstore::api::disk::{VolumeInfo, WalkDirOptions};
-pub(crate) use rustfs_ecstore::api::rpc::{AuthenticatedChannel, TonicInterceptor, node_service_time_out_client_no_auth};
 #[cfg(test)]
-pub(crate) use rustfs_ecstore::api::rpc::{
-    TONIC_RPC_PREFIX, gen_signature_headers, gen_tonic_replay_scope_headers, gen_tonic_signature_headers,
-    verify_tonic_boot_epoch_response,
-};
+pub(crate) use rustfs_ecstore::api::rpc::{TONIC_RPC_PREFIX, gen_signature_headers, gen_tonic_signature_headers};
+pub(crate) use rustfs_ecstore::api::rpc::{TonicInterceptor, node_service_time_out_client_no_auth};
 #[cfg(test)]
 pub(crate) use rustfs_ecstore::api::rpc::{gen_tonic_signature_interceptor, node_service_time_out_client};

@@ -33,7 +30,7 @@ pub(crate) mod node_interact {
 }

 pub(crate) mod grpc_lock {
-    pub(crate) use super::{AuthenticatedChannel, TonicInterceptor, node_service_time_out_client_no_auth};
+    pub(crate) use super::{TonicInterceptor, node_service_time_out_client_no_auth};
 }

 /// Signing/transport surface used by the cross-process internode RPC signature
@@ -43,8 +40,7 @@ pub(crate) mod grpc_lock {
 #[cfg(test)]
 pub(crate) mod internode_rpc_signature {
    pub(crate) use super::{
-        TONIC_RPC_PREFIX, gen_signature_headers, gen_tonic_replay_scope_headers, gen_tonic_signature_headers,
-        node_service_time_out_client_no_auth, verify_tonic_boot_epoch_response,
+        TONIC_RPC_PREFIX, gen_signature_headers, gen_tonic_signature_headers, node_service_time_out_client_no_auth,
    };
 }

@@ -12,35 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::common::{RustFSTestEnvironment, admin_ok, init_logging};
+use crate::common::{RustFSTestEnvironment, init_logging, local_http_client};
 use aws_sdk_sts::config::retry::RetryConfig;
 use aws_sdk_sts::config::{Credentials, Region};
 use aws_sdk_sts::error::ProvideErrorMetadata;
 use aws_sdk_sts::operation::RequestId;
 use aws_sdk_sts::{Client, Config};
 use aws_smithy_http_client::Builder as SmithyHttpClientBuilder;
-use bytes::Bytes;
-use http::header::{AUTHORIZATION, CONTENT_TYPE};
-use http::{Request, Response};
-use http_body_util::{BodyExt, Full};
-use hyper::body::Incoming;
-use hyper::server::conn::http1;
-use hyper::service::service_fn;
-use hyper_util::rt::TokioIo;
-use serde_json::Value;
+use http::header::{CONTENT_TYPE, HOST};
+use rustfs_signer::constants::UNSIGNED_PAYLOAD;
+use rustfs_signer::sign_v4;
+use s3s::Body;
 use serial_test::serial;
-use std::collections::BTreeSet;
-use std::convert::Infallible;
 use std::error::Error;
-use std::sync::Arc;
-use tokio::net::TcpListener;
-use tokio::sync::{Notify, mpsc};
-use tokio::task::{JoinHandle, JoinSet};
-use tokio::time::{Duration, timeout};

 type BoxError = Box<dyn Error + Send + Sync>;
 type TestResult = Result<(), BoxError>;
-const OPA_AUTH_TOKEN: &str = "sts-opa-token";

 fn sts_client(url: &str, access_key: &str, secret_key: &str, session_token: Option<&str>) -> Client {
    let mut config = Config::builder()
@@ -62,14 +49,32 @@ fn sts_client(url: &str, access_key: &str, secret_key: &str, session_token: Opti
 }

 async fn create_root_service_account(env: &RustFSTestEnvironment) -> Result<(String, String), BoxError> {
-    let body = admin_ok(
-        env,
-        http::Method::PUT,
-        "/rustfs/admin/v3/add-service-accounts",
-        Some(serde_json::json!({ "targetUser": env.access_key.clone() }).to_string()),
-    )
-    .await?;
-    let response: Value = serde_json::from_str(&body)?;
+    let path = "/rustfs/admin/v3/add-service-accounts";
+    let url = format!("{}{path}", env.url);
+    let uri = url.parse::<http::Uri>()?;
+    let authority = uri.authority().ok_or("admin URL missing authority")?.to_string();
+    let body = serde_json::json!({ "targetUser": env.access_key.clone() }).to_string();
+    let request = http::Request::builder()
+        .method(http::Method::PUT)
+        .uri(uri)
+        .header(HOST, authority)
+        .header(CONTENT_TYPE, "application/json")
+        .header("x-amz-content-sha256", UNSIGNED_PAYLOAD)
+        .body(Body::empty())?;
+    let content_length = i64::try_from(body.len()).map_err(|_| "service account request body is too large")?;
+    let signed = sign_v4(request, content_length, &env.access_key, &env.secret_key, "", "us-east-1");
+    let mut request = local_http_client().put(&url);
+    for (name, value) in signed.headers() {
+        request = request.header(name, value);
+    }
+    let response = request.body(body).send().await?;
+    let status = response.status();
+    let body = response.text().await?;
+    if !status.is_success() {
+        return Err(format!("create service account failed: {status} {body}").into());
+    }
+
+    let response: serde_json::Value = serde_json::from_str(&body)?;
    let access_key = response["credentials"]["accessKey"]
        .as_str()
        .ok_or("service account response should contain credentials.accessKey")?
@@ -81,237 +86,28 @@ async fn create_root_service_account(env: &RustFSTestEnvironment) -> Result<(Str
    Ok((access_key, secret_key))
 }

-async fn create_user_with_policy(
-    env: &RustFSTestEnvironment,
-    user: &str,
-    secret: &str,
-    policy_name: &str,
-    statements: Value,
-) -> TestResult {
-    create_user(env, user, secret).await?;
-    admin_ok(
-        env,
-        http::Method::PUT,
-        &format!("/rustfs/admin/v3/add-canned-policy?name={policy_name}"),
-        Some(
-            serde_json::json!({
-                "Version": "2012-10-17",
-                "Statement": statements,
-            })
-            .to_string(),
-        ),
-    )
-    .await?;
-    admin_ok(
-        env,
-        http::Method::POST,
-        "/rustfs/admin/v3/idp/builtin/policy/attach",
-        Some(serde_json::json!({ "policies": [policy_name], "user": user }).to_string()),
-    )
-    .await?;
-    Ok(())
-}
-
-async fn create_user(env: &RustFSTestEnvironment, user: &str, secret: &str) -> TestResult {
-    admin_ok(
-        env,
-        http::Method::PUT,
-        &format!("/rustfs/admin/v3/add-user?accessKey={user}"),
-        Some(serde_json::json!({ "secretKey": secret, "status": "enabled" }).to_string()),
-    )
-    .await?;
-    Ok(())
-}
-
-async fn assert_access_denied(client: &Client, context: &str) -> TestResult {
+async fn assert_chaining_denied(client: &Client, credential_kind: &str) -> TestResult {
    let error = client
        .assume_role()
        .role_arn("arn:aws:iam::123456789012:role/test")
        .role_session_name("sts-query-compat-e2e")
        .send()
        .await
-        .expect_err("AssumeRole must be denied");
+        .expect_err("credential chaining must be denied");
    let service_error = error
        .as_service_error()
-        .ok_or_else(|| format!("{context} should deserialize as an STS service error: {error:?}"))?;
+        .ok_or_else(|| format!("{credential_kind} denial should deserialize as an STS service error: {error:?}"))?;

    assert_eq!(error.raw_response().map(|response| response.status().as_u16()), Some(403));
    assert_eq!(service_error.code(), Some("AccessDenied"));
    assert_eq!(service_error.message(), Some("Access Denied"));
    assert!(
        error.request_id().is_some_and(|request_id| !request_id.is_empty()),
-        "{context} should include a request ID"
+        "{credential_kind} denial should include a request ID"
    );
    Ok(())
 }

-async fn handle_opa_request(
-    request: Request<Incoming>,
-    requests: mpsc::UnboundedSender<Value>,
-    validation_started: mpsc::UnboundedSender<()>,
-    validation_mode: OpaValidationMode,
-    expected_authorization: Option<String>,
-) -> Result<Response<Full<Bytes>>, Infallible> {
-    if let Some(expected_authorization) = expected_authorization
-        && request.headers().get(AUTHORIZATION).and_then(|value| value.to_str().ok()) != Some(expected_authorization.as_str())
-    {
-        return Ok(Response::builder()
-            .status(401)
-            .body(Full::new(Bytes::new()))
-            .expect("static OPA unauthorized response must be valid"));
-    }
-
-    let body = match request.into_body().collect().await {
-        Ok(body) => body.to_bytes(),
-        Err(error) => {
-            return Ok(Response::builder()
-                .status(400)
-                .body(Full::new(Bytes::from(error.to_string())))
-                .expect("static OPA error response must be valid"));
-        }
-    };
-
-    let payload = if body.is_empty() {
-        None
-    } else {
-        match serde_json::from_slice::<Value>(&body) {
-            Ok(payload) => Some(payload),
-            Err(error) => {
-                return Ok(Response::builder()
-                    .status(400)
-                    .body(Full::new(Bytes::from(error.to_string())))
-                    .expect("static OPA error response must be valid"));
-            }
-        }
-    };
-    if payload.is_none() {
-        let _ = validation_started.send(());
-        if let OpaValidationMode::DelayedUnavailable(release) = validation_mode {
-            release.notified().await;
-            return Ok(Response::builder()
-                .status(503)
-                .body(Full::new(Bytes::new()))
-                .expect("static OPA unavailable response must be valid"));
-        }
-    }
-    let allow = match payload.as_ref().and_then(|value| value.pointer("/input/identity/account")) {
-        Some(Value::String(account)) if account == "opaallow" => payload
-            .as_ref()
-            .and_then(|value| value.pointer("/input/context/deny_only"))
-            .and_then(Value::as_bool)
-            .unwrap_or(false),
-        Some(Value::String(account)) if account == "opadeny" => false,
-        None => true,
-        _ => false,
-    };
-    if let Some(payload) = payload {
-        let _ = requests.send(payload);
-    }
-    let body =
-        serde_json::to_vec(&serde_json::json!({ "result": { "allow": allow } })).expect("static OPA response must serialize");
-    Ok(Response::builder()
-        .header(CONTENT_TYPE, "application/json")
-        .body(Full::new(Bytes::from(body)))
-        .expect("static OPA response must be valid"))
-}
-
-#[derive(Clone)]
-enum OpaValidationMode {
-    Ready,
-    DelayedUnavailable(Arc<Notify>),
-}
-
-struct OpaMock {
-    url: String,
-    requests: mpsc::UnboundedReceiver<Value>,
-    validation_started: mpsc::UnboundedReceiver<()>,
-    validation_release: Option<Arc<Notify>>,
-    task: JoinHandle<()>,
-}
-
-impl OpaMock {
-    async fn start() -> Result<Self, BoxError> {
-        Self::start_with_mode(OpaValidationMode::Ready, Some(OPA_AUTH_TOKEN)).await
-    }
-
-    async fn start_delayed_unavailable() -> Result<Self, BoxError> {
-        let release = Arc::new(Notify::new());
-        Self::start_with_mode(OpaValidationMode::DelayedUnavailable(release), None).await
-    }
-
-    async fn start_with_mode(validation_mode: OpaValidationMode, auth_token: Option<&str>) -> Result<Self, BoxError> {
-        let listener = TcpListener::bind("127.0.0.1:0").await?;
-        let url = format!("http://{}/v1/data/rustfs/authz/allow", listener.local_addr()?);
-        let (requests_tx, requests) = mpsc::unbounded_channel();
-        let (validation_started_tx, validation_started) = mpsc::unbounded_channel();
-        let expected_authorization = auth_token.map(|token| format!("Bearer {token}"));
-        let validation_release = match &validation_mode {
-            OpaValidationMode::Ready => None,
-            OpaValidationMode::DelayedUnavailable(release) => Some(Arc::clone(release)),
-        };
-        let task = tokio::spawn(async move {
-            let mut connections = JoinSet::new();
-            loop {
-                tokio::select! {
-                    accepted = listener.accept() => {
-                        let Ok((stream, _)) = accepted else { break };
-                        let requests = requests_tx.clone();
-                        let validation_started = validation_started_tx.clone();
-                        let validation_mode = validation_mode.clone();
-                        let expected_authorization = expected_authorization.clone();
-                        connections.spawn(async move {
-                            let handler = service_fn(move |request| {
-                                handle_opa_request(
-                                    request,
-                                    requests.clone(),
-                                    validation_started.clone(),
-                                    validation_mode.clone(),
-                                    expected_authorization.clone(),
-                                )
-                            });
-                            let _ = http1::Builder::new()
-                                .serve_connection(TokioIo::new(stream), handler)
-                                .await;
-                        });
-                    }
-                    _ = connections.join_next(), if !connections.is_empty() => {}
-                }
-            }
-        });
-        Ok(Self {
-            url,
-            requests,
-            validation_started,
-            validation_release,
-            task,
-        })
-    }
-
-    async fn next_request(&mut self) -> Result<Value, BoxError> {
-        timeout(Duration::from_secs(5), self.requests.recv())
-            .await?
-            .ok_or_else(|| "OPA request channel closed".into())
-    }
-
-    async fn wait_for_validation(&mut self) -> TestResult {
-        timeout(Duration::from_secs(5), self.validation_started.recv())
-            .await?
-            .ok_or_else(|| "OPA validation channel closed".into())
-    }
-
-    fn release_validation(&self) {
-        if let Some(release) = &self.validation_release {
-            release.notify_one();
-        }
-    }
-}
-
-impl Drop for OpaMock {
-    fn drop(&mut self) {
-        self.task.abort();
-    }
-}
-
 #[tokio::test]
 #[serial]
 async fn test_sts_query_responses_are_aws_sdk_compatible() -> TestResult {
@@ -359,7 +155,7 @@ async fn test_sts_query_responses_are_aws_sdk_compatible() -> TestResult {
        "signature rejection should include a request ID"
    );

-    assert_access_denied(
+    assert_chaining_denied(
        &sts_client(
            &env.url,
            temporary.access_key_id(),
@@ -371,187 +167,7 @@ async fn test_sts_query_responses_are_aws_sdk_compatible() -> TestResult {
    .await?;

    let (service_access_key, service_secret_key) = create_root_service_account(&env).await?;
-    assert_access_denied(
-        &sts_client(&env.url, &service_access_key, &service_secret_key, None),
-        "service-account denial",
-    )
-    .await?;
-
-    let implicit_user = "stsimplicit";
-    let explicit_allow_user = "stsallow";
-    let explicit_deny_user = "stsdeny";
-    let policyless_user = "stspolicyless";
-    let secret = "stsAuthzSecret123";
-    create_user(&env, policyless_user, secret).await?;
-    assert_access_denied(&sts_client(&env.url, policyless_user, secret, None), "policyless user").await?;
-    create_user_with_policy(
-        &env,
-        implicit_user,
-        secret,
-        "sts-implicit-policy",
-        serde_json::json!([{
-            "Effect": "Allow",
-            "Action": ["s3:ListAllMyBuckets"],
-            "Resource": ["arn:aws:s3:::*"],
-        }]),
-    )
-    .await?;
-    create_user_with_policy(
-        &env,
-        explicit_allow_user,
-        secret,
-        "sts-allow-policy",
-        serde_json::json!([{
-            "Effect": "Allow",
-            "Action": ["sts:AssumeRole"],
-            "Resource": ["arn:aws:s3:::*"],
-        }]),
-    )
-    .await?;
-    create_user_with_policy(
-        &env,
-        explicit_deny_user,
-        secret,
-        "sts-deny-policy",
-        serde_json::json!([
-            {
-                "Effect": "Allow",
-                "Action": ["sts:AssumeRole"],
-                "Resource": ["arn:aws:s3:::*"],
-            },
-            {
-                "Effect": "Deny",
-                "Action": ["sts:AssumeRole"],
-                "Resource": ["arn:aws:s3:::*"],
-            }
-        ]),
-    )
-    .await?;
-
-    for user in [implicit_user, explicit_allow_user] {
-        let output = sts_client(&env.url, user, secret, None)
-            .assume_role()
-            .role_arn("arn:aws:iam::123456789012:role/test")
-            .role_session_name("sts-authz-e2e")
-            .send()
-            .await
-            .map_err(|error| format!("{user} should be allowed to call AssumeRole: {error:?}"))?;
-        let credentials = output
-            .credentials()
-            .ok_or_else(|| format!("{user} AssumeRole response should contain credentials"))?;
-        assert!(!credentials.access_key_id().is_empty());
-        assert!(!credentials.secret_access_key().is_empty());
-        assert!(!credentials.session_token().is_empty());
-    }
-    assert_access_denied(&sts_client(&env.url, explicit_deny_user, secret, None), "explicit sts:AssumeRole Deny").await?;
-
-    env.stop_server();
-    Ok(())
-}
-
-#[tokio::test]
-#[serial]
-async fn test_sts_assume_role_opa_contract() -> TestResult {
-    init_logging();
-
-    let mut opa = OpaMock::start().await?;
-    let mut env = RustFSTestEnvironment::new().await?;
-    env.start_rustfs_server_with_env(
-        vec![],
-        &[
-            ("RUSTFS_POLICY_PLUGIN_URL", opa.url.as_str()),
-            ("RUSTFS_POLICY_PLUGIN_AUTH_TOKEN", OPA_AUTH_TOKEN),
-        ],
-    )
-    .await?;
-
-    let secret = "stsOpaSecret123";
-    create_user_with_policy(
-        &env,
-        "opaallow",
-        secret,
-        "sts-opa-local-deny-policy",
-        serde_json::json!([{
-            "Effect": "Deny",
-            "Action": ["sts:AssumeRole"],
-            "Resource": ["arn:aws:s3:::*"],
-        }]),
-    )
-    .await?;
-    create_user_with_policy(
-        &env,
-        "opadeny",
-        secret,
-        "sts-opa-local-allow-policy",
-        serde_json::json!([{
-            "Effect": "Allow",
-            "Action": ["sts:AssumeRole"],
-            "Resource": ["arn:aws:s3:::*"],
-        }]),
-    )
-    .await?;
-
-    sts_client(&env.url, "opaallow", secret, None)
-        .assume_role()
-        .role_arn("arn:aws:iam::123456789012:role/test")
-        .role_session_name("sts-opa-contract")
-        .send()
-        .await
-        .map_err(|error| format!("OPA allow should override the local explicit Deny: {error:?}"))?;
-    assert_access_denied(
-        &sts_client(&env.url, "opadeny", secret, None),
-        "OPA denial despite local sts:AssumeRole Allow",
-    )
-    .await?;
-
-    let mut accounts = BTreeSet::new();
-    for _ in 0..2 {
-        let request = opa.next_request().await?;
-        assert_eq!(request.pointer("/input/action").and_then(Value::as_str), Some("sts:AssumeRole"));
-        assert_eq!(request.pointer("/input/context/deny_only").and_then(Value::as_bool), Some(true));
-        let account = request
-            .pointer("/input/identity/account")
-            .and_then(Value::as_str)
-            .ok_or("OPA input should include identity.account")?;
-        accounts.insert(account.to_owned());
-    }
-    assert_eq!(accounts, BTreeSet::from(["opaallow".to_owned(), "opadeny".to_owned()]));
-
-    env.stop_server();
-    Ok(())
-}
-
-#[tokio::test]
-#[serial]
-async fn test_sts_assume_role_fails_closed_while_opa_is_unavailable() -> TestResult {
-    init_logging();
-
-    let mut opa = OpaMock::start_delayed_unavailable().await?;
-    let mut env = RustFSTestEnvironment::new().await?;
-    env.start_rustfs_server_with_env(vec![], &[("RUSTFS_POLICY_PLUGIN_URL", opa.url.as_str())])
-        .await?;
-    opa.wait_for_validation().await?;
-
-    let user = "opaunavailable";
-    let secret = "stsOpaUnavailableSecret123";
-    create_user_with_policy(
-        &env,
-        user,
-        secret,
-        "sts-opa-unavailable-local-policy",
-        serde_json::json!([{
-            "Effect": "Allow",
-            "Action": ["s3:ListAllMyBuckets"],
-            "Resource": ["arn:aws:s3:::*"],
-        }]),
-    )
-    .await?;
-
-    assert_access_denied(&sts_client(&env.url, user, secret, None), "configured OPA initialization").await?;
-
-    opa.release_validation();
-    tokio::time::sleep(Duration::from_millis(200)).await;
-    assert_access_denied(&sts_client(&env.url, user, secret, None), "configured OPA validation failure").await?;
+    assert_chaining_denied(&sts_client(&env.url, &service_access_key, &service_secret_key, None), "service account").await?;

    env.stop_server();
    Ok(())
@@ -33,98 +33,14 @@ workspace = true
 [features]
 default = []
 rio-v2 = ["dep:rustfs-rio-v2"]
-hotpath = [
-    "hotpath/hotpath",
-    "hotpath/tokio",
-    "hotpath/futures",
-    "hotpath/async-channel",
-    "hotpath/parking_lot",
-    "hotpath/reqwest-0-13",
-    "rustfs-checksums/hotpath",
-    "rustfs-common/hotpath",
-    "rustfs-concurrency/hotpath",
-    "rustfs-config/hotpath",
-    "rustfs-credentials/hotpath",
-    "rustfs-data-usage/hotpath",
-    "rustfs-filemeta/hotpath",
-    "rustfs-io-metrics/hotpath",
-    "rustfs-lifecycle/hotpath",
-    "rustfs-lock/hotpath",
-    "rustfs-madmin/hotpath",
-    "rustfs-object-capacity/hotpath",
-    "rustfs-policy/hotpath",
-    "rustfs-protos/hotpath",
-    "rustfs-replication/hotpath",
-    "rustfs-rio/hotpath",
-    "rustfs-rio-v2?/hotpath",
-    "rustfs-s3-types/hotpath",
-    "rustfs-signer/hotpath",
-    "rustfs-storage-api/hotpath",
-    "rustfs-tls-runtime/hotpath",
-    "rustfs-utils/hotpath",
-    "rustfs-crypto/hotpath",
-]
-hotpath-alloc = [
-    "hotpath",
-    "hotpath/hotpath-alloc",
-    "rustfs-checksums/hotpath-alloc",
-    "rustfs-common/hotpath-alloc",
-    "rustfs-concurrency/hotpath-alloc",
-    "rustfs-config/hotpath-alloc",
-    "rustfs-credentials/hotpath-alloc",
-    "rustfs-data-usage/hotpath-alloc",
-    "rustfs-filemeta/hotpath-alloc",
-    "rustfs-io-metrics/hotpath-alloc",
-    "rustfs-lifecycle/hotpath-alloc",
-    "rustfs-lock/hotpath-alloc",
-    "rustfs-madmin/hotpath-alloc",
-    "rustfs-object-capacity/hotpath-alloc",
-    "rustfs-policy/hotpath-alloc",
-    "rustfs-protos/hotpath-alloc",
-    "rustfs-replication/hotpath-alloc",
-    "rustfs-rio/hotpath-alloc",
-    "rustfs-rio-v2?/hotpath-alloc",
-    "rustfs-s3-types/hotpath-alloc",
-    "rustfs-signer/hotpath-alloc",
-    "rustfs-storage-api/hotpath-alloc",
-    "rustfs-tls-runtime/hotpath-alloc",
-    "rustfs-utils/hotpath-alloc",
-    "rustfs-crypto/hotpath-alloc",
-]
-hotpath-cpu = [
-    "hotpath",
-    "hotpath/hotpath-cpu",
-    "rustfs-checksums/hotpath-cpu",
-    "rustfs-common/hotpath-cpu",
-    "rustfs-concurrency/hotpath-cpu",
-    "rustfs-config/hotpath-cpu",
-    "rustfs-credentials/hotpath-cpu",
-    "rustfs-data-usage/hotpath-cpu",
-    "rustfs-filemeta/hotpath-cpu",
-    "rustfs-io-metrics/hotpath-cpu",
-    "rustfs-lifecycle/hotpath-cpu",
-    "rustfs-lock/hotpath-cpu",
-    "rustfs-madmin/hotpath-cpu",
-    "rustfs-object-capacity/hotpath-cpu",
-    "rustfs-policy/hotpath-cpu",
-    "rustfs-protos/hotpath-cpu",
-    "rustfs-replication/hotpath-cpu",
-    "rustfs-rio/hotpath-cpu",
-    "rustfs-rio-v2?/hotpath-cpu",
-    "rustfs-s3-types/hotpath-cpu",
-    "rustfs-signer/hotpath-cpu",
-    "rustfs-storage-api/hotpath-cpu",
-    "rustfs-tls-runtime/hotpath-cpu",
-    "rustfs-utils/hotpath-cpu",
-    "rustfs-crypto/hotpath-cpu",
-]
+hotpath = ["dep:hotpath", "hotpath/hotpath", "rustfs-filemeta/hotpath", "rustfs-rio/hotpath"]
 # Exposes shared lifecycle/tier test utilities (MockWarmBackend, fault
 # injection, xl.meta transition assertions) via `api::tier::test_util`.
 # Enable only from `[dev-dependencies]` (rustfs/backlog#1148 ilm-6).
 test-util = []

 [dependencies]
-hotpath.workspace = true
+hotpath = { workspace = true, optional = true }
 rustfs-filemeta.workspace = true
 rustfs-utils = { workspace = true, features = ["full"] }
 rustfs-rio.workspace = true
@@ -141,6 +57,7 @@ rustfs-policy.workspace = true
 rustfs-protos.workspace = true
 rustfs-replication.workspace = true
 rustfs-lifecycle.workspace = true
+rustfs-kms.workspace = true
 rustfs-s3-types = { workspace = true }
 rustfs-data-usage.workspace = true
 rustfs-object-capacity.workspace = true
@@ -188,7 +105,6 @@ tempfile.workspace = true
 hyper = { workspace = true, features = ["http2", "http1", "server"] }
 hyper-util = { workspace = true, features = ["tokio", "server-auto", "server-graceful", "tracing"] }
 hyper-rustls = { workspace = true, default-features = false, features = ["native-tokio", "http1", "tls12", "logging", "http2", "aws-lc-rs"] }
-hostname.workspace = true
 rustls = { workspace = true, default-features = false, features = ["aws-lc-rs", "logging", "tls12", "prefer-post-quantum", "std"] }
 rustls-pki-types.workspace = true
 tokio = { workspace = true, features = ["io-util", "sync", "signal", "fs", "rt-multi-thread"] }
@@ -208,6 +124,8 @@ libc.workspace = true
 rustix = { workspace = true, features = ["process", "fs"] }
 rustfs-madmin.workspace = true
 reqwest = { workspace = true }
+aes-gcm = { workspace = true, features = ["rand_core"] }
+chacha20poly1305.workspace = true
 aws-sdk-s3 = { workspace = true, default-features = false, features = ["sigv4a", "default-https-client", "rt-tokio"] }
 urlencoding = { workspace = true }
 smallvec = { workspace = true, features = ["serde"] }
@@ -235,18 +153,11 @@ metrics = { workspace = true }
 [target.'cfg(target_os = "linux")'.dependencies]
 rustfs-uring = "0.2.1"

-[target.'cfg(windows)'.dependencies]
-winapi-util.workspace = true
-windows-sys = { workspace = true, features = ["Win32_Foundation", "Win32_Storage_FileSystem"] }
-
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "test-util", "fs"] }
 criterion = { workspace = true, features = ["html_reports"] }
 temp-env = { workspace = true, features = ["async_closure"] }
 tracing-subscriber = { workspace = true, features = ["json", "env-filter", "time"] }
-# Only for `pin_callsite_interest_for_test`, which registers a `NoSubscriber`
-# dispatcher to keep tracing's process-global callsite-interest cache honest.
-tracing-core = { workspace = true }
 serial_test = { workspace = true }
 opentelemetry_sdk = { workspace = true, features = ["rt-tokio"] }
 proptest = "1"
@@ -67,14 +67,6 @@ pub mod bucket {
            };
        }

-        pub mod transition_transaction {
-            pub use crate::bucket::lifecycle::transition_transaction::{
-                TransitionOperatorDeleteResult, TransitionOperatorError, TransitionOperatorProbe, TransitionOperatorStatus,
-                delete_transition_candidate_for_operator, finalize_missing_transition_transaction_for_operator,
-                inspect_transition_transaction_for_operator,
-            };
-        }
-
        pub mod evaluator {
            pub use crate::bucket::lifecycle::evaluator::Evaluator;
        }
@@ -130,13 +122,13 @@ pub mod bucket {

    pub mod metadata_sys {
        pub use crate::bucket::metadata_sys::{
-            BucketMetadataSys, acquire_bucket_metadata_transaction_lock, delete, get, get_accelerate_config, get_bucket_policy,
+            BucketMetadataSys, acquire_bucket_targets_transaction_lock, delete, get, get_accelerate_config, get_bucket_policy,
            get_bucket_policy_raw, get_bucket_targets_config, get_config_from_disk, get_cors_config, get_durability_config,
            get_global_bucket_metadata_sys, get_lifecycle_config, get_logging_config, get_notification_config,
            get_object_lock_config, get_public_access_block_config, get_quota_config, get_replication_config,
            get_request_payment_config, get_sse_config, get_tagging_config, get_versioning_config, get_website_config,
-            init_bucket_metadata_sys, list_bucket_targets, reload_bucket_metadata, remove_bucket_metadata, set_bucket_metadata,
-            update, update_bucket_targets_under_transaction_lock, update_config_with, update_under_transaction_lock,
+            init_bucket_metadata_sys, list_bucket_targets, remove_bucket_metadata, set_bucket_metadata, update,
+            update_bucket_targets_under_transaction_lock, update_config_with,
        };
    }

@@ -172,9 +164,6 @@ pub mod bucket {
    }

    pub mod replication {
-        pub use crate::bucket::replication::replication_pool::{
-            DurableMrfBacklogSummary, DurableMrfBucketBacklog, durable_mrf_backlog_summary_snapshot,
-        };
        pub use crate::bucket::replication::{
            BucketReplicationResyncStatus, BucketStats, DeletedObjectReplicationInfo, DurableMrfBacklog, DynReplicationPool,
            MrfOpKind, MrfReplicateEntry, MustReplicateOptions, ObjectOpts, REPLICATE_INCOMING_DELETE, ReplicateDecision,
@@ -270,13 +259,12 @@ pub mod config {
    pub mod com {
        pub use crate::config::com::{
            COMMA_SEPARATED_LISTS, CONFIG_PREFIX, ENV_CONFIG_RECOVER_ON_CORRUPTION, STORAGE_CLASS_SUB_SYS,
-            ServerConfigCorruptError, ServerConfigSaveResult, ServerConfigSnapshot, delete_config,
-            is_server_config_corrupt_error, lookup_configs, read_config, read_config_no_lock, read_config_with_metadata,
-            read_config_without_migrate, read_config_without_migrate_no_lock, read_existing_server_config_no_lock,
-            read_server_config_snapshot, save_config, save_config_no_lock, save_config_with_opts, save_server_config,
-            save_server_config_no_lock, save_server_config_snapshot, save_server_config_snapshot_with_generation,
-            server_config_path, try_migrate_server_config, with_config_object_read_lock, with_config_object_write_lock,
-            with_server_config_read_lock, with_server_config_write_lock,
+            ServerConfigCorruptError, ServerConfigSnapshot, delete_config, is_server_config_corrupt_error, lookup_configs,
+            read_config, read_config_no_lock, read_config_with_metadata, read_config_without_migrate,
+            read_config_without_migrate_no_lock, read_existing_server_config_no_lock, read_server_config_snapshot, save_config,
+            save_config_no_lock, save_config_with_opts, save_server_config, save_server_config_no_lock,
+            save_server_config_snapshot, server_config_path, try_migrate_server_config, with_config_object_read_lock,
+            with_config_object_write_lock, with_server_config_read_lock, with_server_config_write_lock,
        };
    }

@@ -317,8 +305,7 @@ pub mod disk {
        CheckPartsResp, DeleteOptions, Disk, DiskAPI, DiskInfo, DiskInfoOptions, DiskLocation, DiskOption, DiskStore,
        FileInfoVersions, FileReader, FileWriter, HEALING_MARKER_PATH, NsScannerOpenRequest, OldCurrentSize,
        PartTransactionAction, RUSTFS_META_BUCKET, ReadMultipleReq, ReadMultipleResp, ReadOptions, RenameDataResp,
-        STORAGE_FORMAT_FILE, SnapshotLeaseToken, UpdateMetadataOpts, VolumeInfo, WalkDirOptions, new_disk,
-        validate_batch_read_version_item_count,
+        STORAGE_FORMAT_FILE, UpdateMetadataOpts, VolumeInfo, WalkDirOptions, new_disk, validate_batch_read_version_item_count,
    };
    pub use bytes::Bytes;
    pub use endpoint::Endpoint;
@@ -389,18 +376,15 @@ pub mod metrics {
 pub mod notification {
    pub use crate::services::notification_sys::{
        NotificationPeerErr, NotificationSys, get_global_notification_sys, new_global_notification_sys,
-        start_remote_version_state_fleet_probe,
    };
 }

 pub mod object {
    pub use crate::object_api::{
-        BLOCK_SIZE_V2, ERASURE_ALGORITHM, EncryptionResolutionError, EncryptionResolutionErrorKind, GetObjectBodyCacheHook,
-        GetObjectBodyCacheHookLookup, GetObjectBodySource, GetObjectReader, ObjectEncryptionResolver, ObjectInfo,
-        ObjectMutationHook, ObjectOptions, PutObjReader, RangedDecompressReader, ReadEncryptionMaterial, ReadEncryptionMode,
-        ReadEncryptionRequest, StreamConsumer, get_object_body_cache_plaintext_len, lookup_get_object_body_cache_hook,
-        register_get_object_body_cache_hook, register_object_mutation_hook, unregister_get_object_body_cache_hook,
-        unregister_object_mutation_hook,
+        BLOCK_SIZE_V2, ERASURE_ALGORITHM, GetObjectBodyCacheHook, GetObjectBodyCacheHookLookup, GetObjectBodySource,
+        GetObjectReader, ObjectInfo, ObjectMutationHook, ObjectOptions, PutObjReader, RangedDecompressReader, StreamConsumer,
+        get_object_body_cache_plaintext_len, lookup_get_object_body_cache_hook, register_get_object_body_cache_hook,
+        register_object_mutation_hook, unregister_get_object_body_cache_hook, unregister_object_mutation_hook,
    };
    pub use crate::store::PreparedGetObjectReader;
 }
@@ -422,15 +406,13 @@ pub mod rio {

 pub mod rpc {
    pub use crate::cluster::rpc::{
-        AuthenticatedChannel, KMS_SIGNAL_SUBSYSTEM, LocalPeerS3Client, PEER_RESTDRY_RUN, PEER_RESTSIGNAL, PEER_RESTSUB_SYS,
-        PeerRestClient, PeerS3Client, S3PeerSys, SERVICE_SIGNAL_REFRESH_CONFIG, SERVICE_SIGNAL_RELOAD_DYNAMIC,
-        ScannerBucketListing, ScannerPeerActivity, TONIC_RPC_PREFIX, TonicInterceptor, gen_signature_headers,
-        gen_tonic_replay_scope_headers, gen_tonic_signature_headers, gen_tonic_signature_interceptor,
+        LocalPeerS3Client, PEER_RESTDRY_RUN, PEER_RESTSIGNAL, PEER_RESTSUB_SYS, PeerRestClient, PeerS3Client, S3PeerSys,
+        SERVICE_SIGNAL_REFRESH_CONFIG, SERVICE_SIGNAL_RELOAD_DYNAMIC, ScannerBucketListing, ScannerPeerActivity,
+        TONIC_RPC_PREFIX, TonicInterceptor, gen_signature_headers, gen_tonic_signature_headers, gen_tonic_signature_interceptor,
        node_service_time_out_client, node_service_time_out_client_no_auth, normalize_tonic_rpc_audience,
-        set_tonic_canonical_body_digest, sign_ns_scanner_capability, sign_tonic_rpc_response_proof, tonic_boot_epoch_challenge,
-        tonic_boot_epoch_response_headers, verify_rpc_signature, verify_tonic_boot_epoch_response,
+        set_tonic_canonical_body_digest, sign_ns_scanner_capability, sign_tonic_rpc_response_proof, verify_rpc_signature,
        verify_tonic_canonical_body_digest, verify_tonic_mutation_body_digest, verify_tonic_rpc_response_proof,
-        verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
+        verify_tonic_rpc_signature,
    };
 }

@@ -8974,7 +8974,7 @@ mod tests {
        .await
        .expect("first worker result should persist");
        assert_eq!(first.state, ManualTransitionJobState::Running);
-        assert_eq!(first.report.transition_completed, 0);
+        assert_eq!(first.report.transition_completed, 1);
        assert_eq!(first.report.transition_failed, 0);

        let duplicate = record_manual_transition_worker_result(
@@ -8987,11 +8987,11 @@ mod tests {
        .await
        .expect("duplicate worker result should be idempotent");
        assert_eq!(duplicate.state, ManualTransitionJobState::Running);
-        assert_eq!(duplicate.report.transition_completed, 0);
+        assert_eq!(duplicate.report.transition_completed, 1);
        assert_eq!(duplicate.report.transition_failed, 0);

        let second_key = manual_transition_worker_result_task_key(&bucket, "logs/b", None);
-        let pending_record = record_manual_transition_worker_result(
+        let final_record = record_manual_transition_worker_result(
            ecstore.clone(),
            job_id,
            &second_key,
@@ -9000,14 +9000,7 @@ mod tests {
        )
        .await
        .expect("second distinct worker result should persist");
-        assert_eq!(pending_record.state, ManualTransitionJobState::Running);
-        assert_eq!(pending_record.report.transition_completed, 0);
-        assert_eq!(pending_record.report.transition_failed, 0);

-        let final_record =
-            reconcile_manual_transition_worker_results(ecstore.clone(), job_id, ManualTransitionQueueSnapshot::default())
-                .await
-                .expect("worker result journal should reconcile");
        assert_eq!(final_record.state, ManualTransitionJobState::Partial);
        assert_eq!(final_record.report.transition_completed, 1);
        assert_eq!(final_record.report.transition_failed, 1);
@@ -9042,7 +9035,7 @@ mod tests {
            .expect("worker result job record should save");

        let task_key = manual_transition_worker_result_task_key(&bucket, "logs/fail", None);
-        let pending_record = record_manual_transition_worker_result_with_reason(
+        let final_record = record_manual_transition_worker_result_with_reason(
            ecstore.clone(),
            job_id,
            &task_key,
@@ -9052,12 +9045,7 @@ mod tests {
        )
        .await
        .expect("worker result with failure reason should persist");
-        assert!(pending_record.report.tier_failure_by_reason.is_empty());
-        assert_eq!(pending_record.report.transition_failed, 0);

-        let final_record = reconcile_manual_transition_worker_results(ecstore, job_id, ManualTransitionQueueSnapshot::default())
-            .await
-            .expect("worker failure reason should reconcile");
        assert_eq!(
            final_record
                .report
@@ -11318,25 +11306,23 @@ mod tests {

        // Distinct payloads with distinct sizes: a mixed-generation reassembly
        // would produce bytes matching none of them (or fail the read outright).
-        let candidates: Vec<Vec<u8>> = (0..2)
+        let candidates: Vec<Vec<u8>> = (0..3)
            .map(|g| {
                let len = 4096 + g * 512;
                vec![b'a' + g as u8; len]
            })
            .collect();

-        let commit_barrier = MultipartCommitBarrier::install_for_arrivals(
-            &bucket,
-            object,
-            MultipartCommitPause::PutPartBeforeLockAcquire,
-            candidates.len(),
-        );
+        let commit_barrier = MultipartCommitBarrier::install(&bucket, object, MultipartCommitPause::PutPartBeforeLockLost);
+        let start = Arc::new(tokio::sync::Barrier::new(candidates.len() + 1));
        let mut tasks = tokio::task::JoinSet::new();
        for payload in candidates.iter().cloned() {
            let store = ecstore.clone();
            let bucket = bucket.clone();
            let upload_id = upload.upload_id.clone();
+            let start = Arc::clone(&start);
            tasks.spawn(async move {
+                start.wait().await;
                let mut data = PutObjReader::from_vec(payload.clone());
                store
                    .put_object_part(&bucket, object, &upload_id, 1, &mut data, &ObjectOptions::default())
@@ -11344,10 +11330,11 @@ mod tests {
                    .map(|info| (info, payload))
            });
        }
+        start.wait().await;

-        // Both writers finish streaming before racing for the uploadId commit
-        // lock. Two generations are sufficient to exercise the mixed-shard
-        // hazard, while each waiter sits behind at most one cross-disk rename.
+        // The first writer holds the uploadId commit lock while the other
+        // resends reach the same critical section. Releasing it proves the
+        // handoff without depending on saturated CI disk latency.
        commit_barrier.wait_until_paused().await;
        commit_barrier.release();

@@ -1646,14 +1646,40 @@ pub async fn record_manual_transition_worker_result_with_reason(
    job_id: Uuid,
    task_key: &str,
    result: ManualTransitionWorkerResult,
-    _queue_snapshot: ManualTransitionQueueSnapshot,
+    queue_snapshot: ManualTransitionQueueSnapshot,
    failure_reason: Option<ManualTransitionWorkerFailureReason>,
 ) -> EcstoreResult<ManualTransitionJobRecord> {
    let result_record = ManualTransitionWorkerResultRecord::new_with_reason(job_id, task_key, result, failure_reason);
    if !save_manual_transition_worker_result_if_absent(api.clone(), &result_record).await? {
        return load_manual_transition_job_record(api, job_id).await;
    }
-    load_manual_transition_job_record(api, job_id).await
+
+    for _ in 0..4 {
+        let (mut record, etag) = load_manual_transition_job_record_with_etag(api.clone(), job_id).await?;
+        if record.is_terminal() {
+            return Ok(record);
+        }
+        record.record_worker_result_with_reason(result, queue_snapshot, failure_reason);
+        match save_manual_transition_job_record_if_current(api.clone(), &record, &etag).await {
+            Ok(()) => {
+                if record.is_terminal() {
+                    delete_manual_transition_scope_admission_if_current(
+                        api.clone(),
+                        &record.scope_key,
+                        record.job_id,
+                        record.lease_id,
+                    )
+                    .await?;
+                } else {
+                    renew_manual_transition_scope_admission_from_job(api, &record).await?;
+                }
+                return Ok(record);
+            }
+            Err(Error::PreconditionFailed) => continue,
+            Err(err) => return Err(err),
+        }
+    }
+    Err(Error::PreconditionFailed)
 }

 pub async fn renew_manual_transition_job_lease(
@@ -23,7 +23,6 @@ use uuid::Uuid;
 use crate::bucket::lifecycle::config_boundary;
 use crate::bucket::lifecycle::lifecycle::TRANSITION_COMPLETE;
 use crate::bucket::lifecycle::tier_sweeper::{
-    delete_confirmed_transition_candidate_exact_with_lease_idempotent,
    delete_confirmed_transition_candidate_exact_with_manager_and_identity,
    delete_object_from_remote_tier_idempotent_with_manager_and_identity,
 };
@@ -617,199 +616,6 @@ pub enum TransitionTransactionRecoveryOutcome {
    Retained,
 }

-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum TransitionOperatorProbe {
-    Missing,
-    UnversionedPresent,
-    VersionedPresent(String),
-    Ambiguous,
-    Unsupported,
-}
-
-impl From<TransitionCandidateProbe> for TransitionOperatorProbe {
-    fn from(value: TransitionCandidateProbe) -> Self {
-        match value {
-            TransitionCandidateProbe::Missing => Self::Missing,
-            TransitionCandidateProbe::UnversionedPresent => Self::UnversionedPresent,
-            TransitionCandidateProbe::VersionedPresent(version_id) => Self::VersionedPresent(version_id),
-            TransitionCandidateProbe::Ambiguous => Self::Ambiguous,
-            TransitionCandidateProbe::Unsupported => Self::Unsupported,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
-pub struct TransitionOperatorStatus {
-    pub transaction_id: Uuid,
-    pub state: TransitionTransactionState,
-    pub tier_name: String,
-    pub remote_object: String,
-    pub not_after_unix_nanos: i64,
-    pub probe: TransitionOperatorProbe,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
-pub struct TransitionOperatorDeleteResult {
-    pub status: TransitionOperatorStatus,
-    pub journal_observed_after_delete: bool,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum TransitionOperatorError {
-    #[error("transition transaction was not found")]
-    NotFound,
-    #[error("transition transaction is still inside its active ownership window")]
-    NotExpired,
-    #[error("transition transaction state is not eligible for operator reconciliation: {0:?}")]
-    InvalidState(TransitionTransactionState),
-    #[error("an exact non-empty remote version is required")]
-    RemoteVersionRequired,
-    #[error("remote candidate is not proven missing: {0:?}")]
-    CandidateNotMissing(TransitionOperatorProbe),
-    #[error("remote candidate version does not match requested exact version: expected {expected}, observed {actual:?}")]
-    CandidateVersionMismatch {
-        expected: String,
-        actual: TransitionOperatorProbe,
-    },
-    #[error("transition transaction store failed: {0}")]
-    Store(#[source] Error),
-    #[error("remote tier reconciliation failed: {0}")]
-    Remote(#[source] std::io::Error),
-}
-
-type TransitionOperatorResult<T> = std::result::Result<T, TransitionOperatorError>;
-
-fn validate_operator_reconcile_transaction(
-    transaction: &TransitionTransaction,
-    now_unix_nanos: i128,
-) -> TransitionOperatorResult<()> {
-    transaction
-        .validate()
-        .map_err(|err| TransitionOperatorError::Store(Error::other(err)))?;
-    if transaction.state != TransitionTransactionState::UploadOutcomeUnknown {
-        return Err(TransitionOperatorError::InvalidState(transaction.state));
-    }
-    if now_unix_nanos < i128::from(transaction.not_after_unix_nanos) {
-        return Err(TransitionOperatorError::NotExpired);
-    }
-    Ok(())
-}
-
-async fn load_operator_reconcile_transaction(
-    api: Arc<ECStore>,
-    transaction_id: Uuid,
-) -> TransitionOperatorResult<TransitionTransaction> {
-    match load_transition_transaction_record(api, transaction_id).await {
-        Ok(transaction) => Ok(transaction),
-        Err(Error::ConfigNotFound) => Err(TransitionOperatorError::NotFound),
-        Err(err) => Err(TransitionOperatorError::Store(err)),
-    }
-}
-
-async fn operator_probe_transition_candidate(
-    api: Arc<ECStore>,
-    transaction: &TransitionTransaction,
-) -> TransitionOperatorResult<TransitionOperatorProbe> {
-    let lease = TierConfigMgr::acquire_operation_lease_for_backend_identity(
-        &api.tier_config_mgr(),
-        &transaction.tier_name,
-        transaction.backend_fingerprint,
-    )
-    .await
-    .map_err(|err| TransitionOperatorError::Remote(std::io::Error::other(err)))?;
-    lease
-        .probe_transition_candidate_for(&transaction.remote_object, transaction.transaction_id)
-        .await
-        .map(TransitionOperatorProbe::from)
-        .map_err(TransitionOperatorError::Remote)
-}
-
-pub async fn inspect_transition_transaction_for_operator(
-    api: Arc<ECStore>,
-    transaction_id: Uuid,
-) -> TransitionOperatorResult<TransitionOperatorStatus> {
-    let transaction = load_operator_reconcile_transaction(api.clone(), transaction_id).await?;
-    validate_operator_reconcile_transaction(&transaction, time::OffsetDateTime::now_utc().unix_timestamp_nanos())?;
-    let probe = operator_probe_transition_candidate(api, &transaction).await?;
-    Ok(TransitionOperatorStatus {
-        transaction_id,
-        state: transaction.state,
-        tier_name: transaction.tier_name,
-        remote_object: transaction.remote_object,
-        not_after_unix_nanos: transaction.not_after_unix_nanos,
-        probe,
-    })
-}
-
-pub async fn delete_transition_candidate_for_operator(
-    api: Arc<ECStore>,
-    transaction_id: Uuid,
-    remote_version_id: &str,
-) -> TransitionOperatorResult<TransitionOperatorDeleteResult> {
-    if remote_version_id.is_empty() {
-        return Err(TransitionOperatorError::RemoteVersionRequired);
-    }
-    let transaction = load_operator_reconcile_transaction(api.clone(), transaction_id).await?;
-    validate_operator_reconcile_transaction(&transaction, time::OffsetDateTime::now_utc().unix_timestamp_nanos())?;
-    let lease = TierConfigMgr::acquire_operation_lease_for_backend_identity(
-        &api.tier_config_mgr(),
-        &transaction.tier_name,
-        transaction.backend_fingerprint,
-    )
-    .await
-    .map_err(|err| TransitionOperatorError::Remote(std::io::Error::other(err)))?;
-    lease
-        .validate_remote_version_id(remote_version_id)
-        .map_err(TransitionOperatorError::Remote)?;
-    let before_delete_probe = lease
-        .probe_transition_candidate_for(&transaction.remote_object, transaction.transaction_id)
-        .await
-        .map(TransitionOperatorProbe::from)
-        .map_err(TransitionOperatorError::Remote)?;
-    if !matches!(&before_delete_probe, TransitionOperatorProbe::VersionedPresent(version_id) if version_id == remote_version_id) {
-        return Err(TransitionOperatorError::CandidateVersionMismatch {
-            expected: remote_version_id.to_string(),
-            actual: before_delete_probe,
-        });
-    }
-    delete_confirmed_transition_candidate_exact_with_lease_idempotent(&transaction.remote_object, remote_version_id, &lease)
-        .await
-        .map_err(TransitionOperatorError::Remote)?;
-    let probe = operator_probe_transition_candidate(api.clone(), &transaction).await?;
-    let journal_observed_after_delete = match load_transition_transaction_record(api, transaction_id).await {
-        Ok(_) => true,
-        Err(Error::ConfigNotFound) => false,
-        Err(err) => return Err(TransitionOperatorError::Store(err)),
-    };
-    Ok(TransitionOperatorDeleteResult {
-        status: TransitionOperatorStatus {
-            transaction_id,
-            state: transaction.state,
-            tier_name: transaction.tier_name,
-            remote_object: transaction.remote_object,
-            not_after_unix_nanos: transaction.not_after_unix_nanos,
-            probe,
-        },
-        journal_observed_after_delete,
-    })
-}
-
-pub async fn finalize_missing_transition_transaction_for_operator(
-    api: Arc<ECStore>,
-    transaction_id: Uuid,
-) -> TransitionOperatorResult<()> {
-    let transaction = load_operator_reconcile_transaction(api.clone(), transaction_id).await?;
-    validate_operator_reconcile_transaction(&transaction, time::OffsetDateTime::now_utc().unix_timestamp_nanos())?;
-    let probe = operator_probe_transition_candidate(api.clone(), &transaction).await?;
-    if probe != TransitionOperatorProbe::Missing {
-        return Err(TransitionOperatorError::CandidateNotMissing(probe));
-    }
-    delete_transition_transaction_record(api, transaction_id)
-        .await
-        .map_err(TransitionOperatorError::Store)
-}
-
 pub(crate) fn decode_transition_transaction_record(object: &str, data: &[u8]) -> Result<TransitionTransaction> {
    let transaction_id = transition_transaction_id_from_record_object_name(object)?;
    TransitionTransaction::decode(transaction_id, data)
@@ -894,7 +700,7 @@ async fn recover_unknown_upload_outcome(
    .map_err(Error::other)?;

    match lease
-        .probe_transition_candidate_for(&transaction.remote_object, transaction.transaction_id)
+        .probe_transition_candidate(&transaction.remote_object)
        .await
        .map_err(Error::other)?
    {
@@ -1291,27 +1097,6 @@ mod tests {
            .expect("upload state change should succeed")
    }

-    #[test]
-    fn operator_reconcile_requires_expired_unknown_upload_outcome() {
-        let mut transaction = new_transaction();
-        let active_deadline = transaction.not_after_unix_nanos;
-
-        assert!(matches!(
-            validate_operator_reconcile_transaction(&transaction, i128::from(active_deadline) + 1),
-            Err(TransitionOperatorError::InvalidState(TransitionTransactionState::UploadStarted))
-        ));
-
-        transaction
-            .advance(transaction.fence(), TransitionTransactionState::UploadOutcomeUnknown, None)
-            .expect("unknown upload outcome should be recorded");
-        assert!(matches!(
-            validate_operator_reconcile_transaction(&transaction, i128::from(active_deadline) - 1),
-            Err(TransitionOperatorError::NotExpired)
-        ));
-        validate_operator_reconcile_transaction(&transaction, i128::from(active_deadline))
-            .expect("expired unknown upload outcome should be eligible");
-    }
-
    fn cleanup_proof(transaction: &TransitionTransaction, decision: TransitionCleanupDecision) -> TransitionCleanupProof {
        TransitionCleanupProof {
            transaction_id: transaction.transaction_id,
@@ -46,11 +46,7 @@ use super::replication_target_boundary::{ReplicationTargetStore, replication_obj
 use super::replication_versioning_boundary::ReplicationVersioningStore;
 use super::runtime_boundary as runtime_sources;
 use rustfs_utils::http::{SUFFIX_REPLICATION_TIMESTAMP, get_str};
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
 use std::sync::Arc;
-use std::sync::LazyLock;
-use std::sync::RwLock as StdRwLock;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::Ordering;
 use time::OffsetDateTime;
@@ -78,66 +74,6 @@ pub struct DurableMrfBacklog {
    pub entries: Vec<MrfReplicateEntry>,
 }

-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct DurableMrfBucketBacklog {
-    pub bucket: String,
-    pub count: u64,
-    pub bytes: u64,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct DurableMrfBacklogSummary {
-    pub available: bool,
-    pub buckets: Vec<DurableMrfBucketBacklog>,
-}
-
-static DURABLE_MRF_BACKLOG_SUMMARY: LazyLock<StdRwLock<DurableMrfBacklogSummary>> =
-    LazyLock::new(|| StdRwLock::new(DurableMrfBacklogSummary::default()));
-
-fn durable_mrf_backlog_summary_from_sizes<I>(entries: I) -> DurableMrfBacklogSummary
-where
-    I: IntoIterator<Item = (String, i64)>,
-{
-    let mut buckets = HashMap::<String, DurableMrfBucketBacklog>::new();
-    for (bucket_name, entry_size) in entries {
-        let Ok(size) = u64::try_from(entry_size) else {
-            return DurableMrfBacklogSummary::default();
-        };
-
-        let bucket = match buckets.entry(bucket_name) {
-            Entry::Occupied(entry) => entry.into_mut(),
-            Entry::Vacant(entry) => {
-                let bucket = entry.key().clone();
-                entry.insert(DurableMrfBucketBacklog {
-                    bucket,
-                    ..Default::default()
-                })
-            }
-        };
-        bucket.count = bucket.count.saturating_add(1);
-        bucket.bytes = bucket.bytes.saturating_add(size);
-    }
-
-    DurableMrfBacklogSummary {
-        available: true,
-        buckets: buckets.into_values().collect(),
-    }
-}
-
-fn set_durable_mrf_backlog_summary(summary: DurableMrfBacklogSummary) {
-    match DURABLE_MRF_BACKLOG_SUMMARY.write() {
-        Ok(mut guard) => *guard = summary,
-        Err(poisoned) => *poisoned.into_inner() = summary,
-    }
-}
-
-pub fn durable_mrf_backlog_summary_snapshot() -> DurableMrfBacklogSummary {
-    match DURABLE_MRF_BACKLOG_SUMMARY.read() {
-        Ok(guard) => guard.clone(),
-        Err(poisoned) => poisoned.into_inner().clone(),
-    }
-}
-
 fn durable_mrf_backlog_from_read(result: Result<Vec<u8>, EcstoreError>) -> DurableMrfBacklog {
    match result {
        Ok(data) => match decode_mrf_file(&data) {
@@ -297,7 +233,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {

            let active_counter = self.active_lrg_workers.clone();
            let storage = self.storage.clone();
-            let stats = self.stats.clone();

            let handle = tokio::spawn(async move {
                let mut rx = rx;
@@ -306,18 +241,10 @@ impl<S: ReplicationStorage> ReplicationPool<S> {

                    match operation {
                        ReplicationOperation::Object(obj_info) => {
-                            let bucket = obj_info.bucket.clone();
-                            let size = obj_info.size;
-                            let delete_marker = obj_info.delete_marker;
-                            let op_type = obj_info.op_type;
                            replicate_object(*obj_info, storage.clone()).await;
-                            stats.dec_q(&bucket, size, delete_marker, op_type);
                        }
                        ReplicationOperation::Delete(del_info) => {
-                            let bucket = del_info.bucket.clone();
-                            let op_type = del_info.op_type;
                            replicate_delete(*del_info, storage.clone()).await;
-                            stats.dec_q(&bucket, 0, true, op_type);
                        }
                    }

@@ -383,22 +310,23 @@ impl<S: ReplicationStorage> ReplicationPool<S> {

                    match operation {
                        ReplicationOperation::Object(obj_info) => {
-                            let bucket = obj_info.bucket.clone();
-                            let size = obj_info.size;
-                            let delete_marker = obj_info.delete_marker;
-                            let op_type = obj_info.op_type;
-                            // Perform actual replication (placeholder)
-                            replicate_object(*obj_info, storage.clone()).await;
+                            stats
+                                .inc_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                                .await;

-                            stats.dec_q(&bucket, size, delete_marker, op_type);
+                            // Perform actual replication (placeholder)
+                            replicate_object(obj_info.as_ref().clone(), storage.clone()).await;
+
+                            stats
+                                .dec_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                                .await;
                        }
                        ReplicationOperation::Delete(del_info) => {
-                            let bucket = del_info.bucket.clone();
-                            let op_type = del_info.op_type;
+                            stats.inc_q(&del_info.bucket, 0, true, del_info.op_type).await;
                            // Perform actual delete replication (placeholder)
-                            replicate_delete(*del_info, storage.clone()).await;
+                            replicate_delete(del_info.as_ref().clone(), storage.clone()).await;

-                            stats.dec_q(&bucket, 0, true, op_type);
+                            stats.dec_q(&del_info.bucket, 0, true, del_info.op_type).await;
                        }
                    }

@@ -451,18 +379,16 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                    active_counter.fetch_add(1, Ordering::SeqCst);
                    match operation {
                        ReplicationOperation::Object(obj_info) => {
-                            let bucket = obj_info.bucket.clone();
-                            let size = obj_info.size;
-                            let delete_marker = obj_info.delete_marker;
-                            let op_type = obj_info.op_type;
-                            replicate_object(*obj_info, storage.clone()).await;
-                            stats.dec_q(&bucket, size, delete_marker, op_type);
+                            stats
+                                .inc_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                                .await;
+                            replicate_object(obj_info.as_ref().clone(), storage.clone()).await;
+                            stats
+                                .dec_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                                .await;
                        }
                        ReplicationOperation::Delete(del_info) => {
-                            let bucket = del_info.bucket.clone();
-                            let op_type = del_info.op_type;
                            replicate_delete(*del_info, storage.clone()).await;
-                            stats.dec_q(&bucket, 0, true, op_type);
                        }
                    }
                    active_counter.fetch_sub(1, Ordering::SeqCst);
@@ -603,13 +529,9 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
            if !lrg_workers.is_empty() {
                let index = (hash as usize) % lrg_workers.len();

-                if let Some(worker) = lrg_workers.get(index) {
-                    self.stats.inc_q(&ri.bucket, ri.size, ri.delete_marker, ri.op_type);
-                    if worker.try_send(ReplicationOperation::Object(Box::new(ri.clone()))).is_ok() {
-                        return ReplicationQueueAdmission::Queued;
-                    }
-                    self.stats.dec_q(&ri.bucket, ri.size, ri.delete_marker, ri.op_type);
-
+                if let Some(worker) = lrg_workers.get(index)
+                    && worker.try_send(ReplicationOperation::Object(Box::new(ri.clone()))).is_err()
+                {
                    // Try to add more workers if possible
                    let max_l_workers = *self.max_l_workers.read().await;
                    let existing = lrg_workers.len();
@@ -617,13 +539,17 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                    drop(lrg_workers);

                    // Queue to MRF if worker is busy.
-                    let admission = self.queue_mrf_save_admission(ri.to_mrf_entry(), "large_object").await;
+                    let admission =
+                        queue_mrf_save_admission(&self.mrf_save_tx, ri.to_mrf_entry(), &ri.bucket, &ri.name, "large_object")
+                            .await;

                    if let Some(resize) = resize {
                        self.resize_lrg_workers(resize.new_count, resize.existing_count).await;
                    }
                    return admission;
                }
+
+                return ReplicationQueueAdmission::Queued;
            }
            return ReplicationQueueAdmission::Missed;
        }
@@ -636,14 +562,12 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
            return ReplicationQueueAdmission::Missed;
        };

-        self.stats.inc_q(&ri.bucket, ri.size, ri.delete_marker, ri.op_type);
        if channel.try_send(ReplicationOperation::Object(Box::new(ri.clone()))).is_ok() {
            return ReplicationQueueAdmission::Queued;
        }
-        self.stats.dec_q(&ri.bucket, ri.size, ri.delete_marker, ri.op_type);

        // Queue to MRF if all workers are busy.
-        let admission = self.queue_mrf_save_admission(ri.to_mrf_entry(), "object").await;
+        let admission = queue_mrf_save_admission(&self.mrf_save_tx, ri.to_mrf_entry(), &ri.bucket, &ri.name, "object").await;

        // Try to scale up workers based on priority
        self.apply_queue_backpressure("object", true, "Replication queue is backpressured")
@@ -662,13 +586,18 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
            return ReplicationQueueAdmission::Missed;
        };

-        self.stats.inc_q(&doi.bucket, 0, true, doi.op_type);
        if channel.try_send(ReplicationOperation::Delete(Box::new(doi.clone()))).is_ok() {
            return ReplicationQueueAdmission::Queued;
        }
-        self.stats.dec_q(&doi.bucket, 0, true, doi.op_type);

-        let admission = self.queue_mrf_save_admission(doi.to_mrf_entry(), "delete").await;
+        let admission = queue_mrf_save_admission(
+            &self.mrf_save_tx,
+            doi.to_mrf_entry(),
+            &doi.bucket,
+            &doi.delete_object.object_name,
+            "delete",
+        )
+        .await;

        self.apply_queue_backpressure("delete", false, "Replication delete queue is backpressured")
            .await;
@@ -678,18 +607,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {

    /// Queues an MRF save operation
    async fn queue_mrf_save(&self, entry: MrfReplicateEntry) {
-        let _ = self.queue_mrf_save_admission(entry, "mrf_worker").await;
-    }
-
-    async fn queue_mrf_save_admission(&self, entry: MrfReplicateEntry, queue_type: &'static str) -> ReplicationQueueAdmission {
-        let bucket = entry.bucket.clone();
-        let size = entry.size;
-        let is_delete = matches!(entry.op, MrfOpKind::Delete);
-        let admission = queue_mrf_save_entry(&self.mrf_save_tx, entry, queue_type).await;
-        if admission == ReplicationQueueAdmission::Queued {
-            self.stats.inc_q(&bucket, size, is_delete, ReplicationType::Heal);
-        }
-        admission
+        let _ = queue_mrf_save_admission(&self.mrf_save_tx, entry, "", "", "mrf_worker").await;
    }

    /// Starts the MRF processor — one-shot at startup.
@@ -704,13 +622,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
        let handle = tokio::spawn(async move {
            let data = match ReplicationConfigStore::read(storage.clone(), ReplicationMetadataStore::MRF_REPLICATION_FILE).await {
                Ok(d) => d,
-                Err(EcstoreError::ConfigNotFound) => {
-                    set_durable_mrf_backlog_summary(DurableMrfBacklogSummary {
-                        available: true,
-                        buckets: Vec::new(),
-                    });
-                    return;
-                }
+                Err(EcstoreError::ConfigNotFound) => return, // no file yet — normal on first start
                Err(e) => {
                    warn!(
                        component = LOG_COMPONENT_ECSTORE,
@@ -741,9 +653,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                    return;
                }
            };
-            set_durable_mrf_backlog_summary(durable_mrf_backlog_summary_from_sizes(
-                entries.iter().map(|entry| (entry.bucket.clone(), entry.size)),
-            ));

            let total = entries.len();
            let mut queued_count = 0usize;
@@ -856,11 +765,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                    error = %e,
                    "Failed to clear MRF recovery file after replay — entries may be replayed again on next restart"
                );
-            } else {
-                set_durable_mrf_backlog_summary(DurableMrfBacklogSummary {
-                    available: true,
-                    buckets: Vec::new(),
-                });
            }

            if queued_count > 0 {
@@ -889,7 +793,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
            return;
        };
        let storage = self.storage.clone();
-        let stats = self.stats.clone();

        let handle = tokio::spawn(async move {
            // The on-disk MRF file is a restart-recovery backstop: entries are
@@ -915,7 +818,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                    entry = rx.recv() => match entry {
                        Some(e) => {
                            if pending.len() >= MRF_PENDING_CAP {
-                                dec_mrf_entries(stats.as_ref(), std::slice::from_ref(&e));
                                if !capped {
                                    capped = true;
                                    warn!(
@@ -934,31 +836,20 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                            // set, not the absolute length, so a large backlog is
                            // not rewritten on every single add).
                            if pending.len() - flushed_len >= 1000 && flush_mrf_to_disk(&pending, &storage).await {
-                                set_durable_mrf_backlog_summary(durable_mrf_backlog_summary_from_sizes(
-                                    pending.iter().map(|entry| (entry.bucket.clone(), entry.size)),
-                                ));
-                                dec_mrf_entries(stats.as_ref(), &pending[flushed_len..]);
                                flushed_len = pending.len();
                                dirty = false;
                            }
                        }
                        None => {
                            // Channel closed (pool shutting down) — final flush.
-                            if dirty && flush_mrf_to_disk(&pending, &storage).await {
-                                set_durable_mrf_backlog_summary(durable_mrf_backlog_summary_from_sizes(
-                                    pending.iter().map(|entry| (entry.bucket.clone(), entry.size)),
-                                ));
-                                dec_mrf_entries(stats.as_ref(), &pending[flushed_len..]);
+                            if dirty {
+                                flush_mrf_to_disk(&pending, &storage).await;
                            }
                            break;
                        }
                    },
                    _ = interval.tick() => {
                        if dirty && flush_mrf_to_disk(&pending, &storage).await {
-                            set_durable_mrf_backlog_summary(durable_mrf_backlog_summary_from_sizes(
-                                pending.iter().map(|entry| (entry.bucket.clone(), entry.size)),
-                            ));
-                            dec_mrf_entries(stats.as_ref(), &pending[flushed_len..]);
                            flushed_len = pending.len();
                            dirty = false;
                        }
@@ -981,22 +872,24 @@ impl<S: ReplicationStorage> ReplicationPool<S> {

            match operation {
                ReplicationOperation::Object(obj_info) => {
-                    let bucket = obj_info.bucket.clone();
-                    let size = obj_info.size;
-                    let delete_marker = obj_info.delete_marker;
-                    let op_type = obj_info.op_type;
-                    // Perform actual replication (placeholder)
-                    replicate_object(*obj_info, self.storage.clone()).await;
+                    stats
+                        .inc_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                        .await;

-                    stats.dec_q(&bucket, size, delete_marker, op_type);
+                    // Perform actual replication (placeholder)
+                    replicate_object(obj_info.as_ref().clone(), self.storage.clone()).await;
+
+                    stats
+                        .dec_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                        .await;
                }
                ReplicationOperation::Delete(del_info) => {
-                    let bucket = del_info.bucket.clone();
-                    let op_type = del_info.op_type;
-                    // Perform actual delete replication (placeholder)
-                    replicate_delete(*del_info, self.storage.clone()).await;
+                    stats.inc_q(&del_info.bucket, 0, true, del_info.op_type).await;

-                    stats.dec_q(&bucket, 0, true, op_type);
+                    // Perform actual delete replication (placeholder)
+                    replicate_delete(del_info.as_ref().clone(), self.storage.clone()).await;
+
+                    stats.dec_q(&del_info.bucket, 0, true, del_info.op_type).await;
                }
            }

@@ -1005,30 +898,16 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
    }

    /// Worker function for handling large object replication operations
-    async fn add_large_worker(
-        &self,
-        mut rx: Receiver<ReplicationOperation>,
-        active_counter: Arc<AtomicI32>,
-        stats: Arc<ReplicationStats>,
-        storage: Arc<S>,
-    ) {
+    async fn add_large_worker(&self, mut rx: Receiver<ReplicationOperation>, active_counter: Arc<AtomicI32>, storage: Arc<S>) {
        while let Some(operation) = rx.recv().await {
            active_counter.fetch_add(1, Ordering::SeqCst);

            match operation {
                ReplicationOperation::Object(obj_info) => {
-                    let bucket = obj_info.bucket.clone();
-                    let size = obj_info.size;
-                    let delete_marker = obj_info.delete_marker;
-                    let op_type = obj_info.op_type;
                    replicate_object(*obj_info, storage.clone()).await;
-                    stats.dec_q(&bucket, size, delete_marker, op_type);
                }
                ReplicationOperation::Delete(del_info) => {
-                    let bucket = del_info.bucket.clone();
-                    let op_type = del_info.op_type;
                    replicate_delete(*del_info, storage.clone()).await;
-                    stats.dec_q(&bucket, 0, true, op_type);
                }
            }

@@ -1048,19 +927,18 @@ impl<S: ReplicationStorage> ReplicationPool<S> {

            match operation {
                ReplicationOperation::Object(obj_info) => {
-                    let bucket = obj_info.bucket.clone();
-                    let size = obj_info.size;
-                    let delete_marker = obj_info.delete_marker;
-                    let op_type = obj_info.op_type;
+                    stats
+                        .inc_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                        .await;
+
                    replicate_object(obj_info.as_ref().clone(), self.storage.clone()).await;

-                    stats.dec_q(&bucket, size, delete_marker, op_type);
+                    stats
+                        .dec_q(&obj_info.bucket, obj_info.size, obj_info.delete_marker, obj_info.op_type)
+                        .await;
                }
                ReplicationOperation::Delete(del_info) => {
-                    let bucket = del_info.bucket.clone();
-                    let op_type = del_info.op_type;
                    replicate_delete(*del_info, self.storage.clone()).await;
-                    stats.dec_q(&bucket, 0, true, op_type);
                }
            }

@@ -1395,34 +1273,29 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
    }
 }

-async fn queue_mrf_save_entry(
+async fn queue_mrf_save_admission(
    tx: &Sender<MrfReplicateEntry>,
    entry: MrfReplicateEntry,
+    bucket: &str,
+    object: &str,
    queue_type: &'static str,
 ) -> ReplicationQueueAdmission {
-    let Err(error) = tx.send(entry).await else {
+    if tx.send(entry).await.is_ok() {
        return ReplicationQueueAdmission::Queued;
-    };
-    let entry = error.0;
+    }

    warn!(
        event = EVENT_REPLICATION_MRF_QUEUE_UNAVAILABLE,
        component = LOG_COMPONENT_ECSTORE,
        subsystem = LOG_SUBSYSTEM_REPLICATION,
-        bucket = %entry.bucket,
-        object = %entry.object,
+        bucket = %bucket,
+        object = %object,
        queue_type = queue_type,
        "MRF save channel unavailable — replication failure entry could not be persisted for retry"
    );
    ReplicationQueueAdmission::Missed
 }

-fn dec_mrf_entries(stats: &ReplicationStats, entries: &[MrfReplicateEntry]) {
-    for entry in entries {
-        stats.dec_q(&entry.bucket, entry.size, matches!(entry.op, MrfOpKind::Delete), ReplicationType::Heal);
-    }
-}
-
 /// Encodes `entries` and overwrites the MRF persistence file.
 /// Returns `true` on success; on failure logs the error and returns `false`.
 /// Callers must NOT clear their in-memory buffer on `false` so the next tick
@@ -2143,147 +2016,6 @@ mod tests {
        })
    }

-    async fn current_queue(pool: &ReplicationPool<LoadResyncNodeStore>, bucket: &str) -> (i64, i64) {
-        let stats = pool.stats.get_latest_replication_stats(bucket).await;
-        (stats.replication_stats.q_stat.curr.count, stats.replication_stats.q_stat.curr.bytes)
-    }
-
-    async fn wait_for_current_queue(pool: &ReplicationPool<LoadResyncNodeStore>, bucket: &str, expected: (i64, i64)) {
-        tokio::time::timeout(Duration::from_secs(10), async {
-            loop {
-                if current_queue(pool, bucket).await == expected {
-                    break;
-                }
-                tokio::task::yield_now().await;
-            }
-        })
-        .await
-        .expect("replication queue should reach the expected state");
-    }
-
-    #[tokio::test]
-    async fn regular_worker_admission_counts_channel_backlog_before_receive() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        let (tx, _rx) = mpsc::channel(1);
-        pool.workers.write().await.push(tx);
-
-        let admission = pool
-            .queue_replica_task(ReplicateObjectInfo {
-                bucket: "admission-bucket".to_string(),
-                name: "object".to_string(),
-                size: 4096,
-                op_type: ReplicationType::Object,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        assert_eq!(current_queue(&pool, "admission-bucket").await, (1, 4096));
-    }
-
-    #[tokio::test]
-    async fn large_worker_admission_counts_channel_backlog_before_receive() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        let (tx, _rx) = mpsc::channel(1);
-        pool.lrg_workers.write().await.push(tx);
-        let size = 128 * 1024 * 1024;
-
-        let admission = pool
-            .queue_replica_task(ReplicateObjectInfo {
-                bucket: "large-admission-bucket".to_string(),
-                name: "large-object".to_string(),
-                size,
-                op_type: ReplicationType::Object,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        assert_eq!(current_queue(&pool, "large-admission-bucket").await, (1, size));
-    }
-
-    #[tokio::test]
-    async fn delete_admission_counts_channel_backlog_before_receive() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        let (tx, _rx) = mpsc::channel(1);
-        pool.workers.write().await.push(tx);
-
-        let admission = pool
-            .queue_replica_delete_task(DeletedObjectReplicationInfo {
-                bucket: "delete-admission-bucket".to_string(),
-                delete_object: ReplicationDeletedObject {
-                    object_name: "deleted-object".to_string(),
-                    ..Default::default()
-                },
-                op_type: ReplicationType::Delete,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        assert_eq!(current_queue(&pool, "delete-admission-bucket").await, (1, 0));
-    }
-
-    #[tokio::test]
-    async fn regular_worker_drains_current_backlog_after_processing() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        pool.resize_workers(1, 0).await;
-
-        let admission = pool
-            .queue_replica_task(ReplicateObjectInfo {
-                bucket: "regular-drain-bucket".to_string(),
-                name: "object".to_string(),
-                size: 4096,
-                op_type: ReplicationType::Object,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        wait_for_current_queue(&pool, "regular-drain-bucket", (0, 0)).await;
-    }
-
-    #[tokio::test]
-    async fn large_worker_drains_current_backlog_after_processing() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        pool.resize_lrg_workers(1, 0).await;
-        let size = 128 * 1024 * 1024;
-
-        let admission = pool
-            .queue_replica_task(ReplicateObjectInfo {
-                bucket: "large-drain-bucket".to_string(),
-                name: "large-object".to_string(),
-                size,
-                op_type: ReplicationType::Object,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        wait_for_current_queue(&pool, "large-drain-bucket", (0, 0)).await;
-    }
-
-    #[tokio::test]
-    async fn regular_delete_worker_drains_current_backlog_after_processing() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        pool.resize_workers(1, 0).await;
-
-        let admission = pool
-            .queue_replica_delete_task(DeletedObjectReplicationInfo {
-                bucket: "delete-drain-bucket".to_string(),
-                delete_object: ReplicationDeletedObject {
-                    object_name: "deleted-object".to_string(),
-                    ..Default::default()
-                },
-                op_type: ReplicationType::Delete,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        wait_for_current_queue(&pool, "delete-drain-bucket", (0, 0)).await;
-    }
-
    fn load_resync_test_metadata() -> Vec<u8> {
        let mut status = BucketReplicationResyncStatus::new();
        status.targets_map.insert(
@@ -2569,37 +2301,6 @@ mod tests {
        assert_eq!(admission, ReplicationQueueAdmission::Missed);
    }

-    #[tokio::test]
-    async fn queue_replica_task_counts_mrf_pending_backlog_when_worker_queue_is_full() {
-        let shared = empty_resync_shared_state();
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", shared))).await;
-        let (tx, _rx) = mpsc::channel(1);
-        tx.try_send(ReplicationOperation::Object(Box::new(ReplicateObjectInfo {
-            bucket: "runtime-backlog".to_string(),
-            name: "already-buffered".to_string(),
-            size: 1,
-            op_type: ReplicationType::Object,
-            ..Default::default()
-        })))
-        .expect("test setup should fill the worker queue");
-        pool.workers.write().await.push(tx);
-
-        let admission = pool
-            .queue_replica_task(ReplicateObjectInfo {
-                bucket: "runtime-backlog".to_string(),
-                name: "fallback-object".to_string(),
-                size: 2048,
-                op_type: ReplicationType::Object,
-                ..Default::default()
-            })
-            .await;
-
-        assert_eq!(admission, ReplicationQueueAdmission::Queued);
-        let queued = pool.stats.get_latest_replication_stats("runtime-backlog").await;
-        assert_eq!(queued.replication_stats.q_stat.curr.count, 1);
-        assert_eq!(queued.replication_stats.q_stat.curr.bytes, 2048);
-    }
-
    #[test]
    fn replicate_object_info_from_object_info_preserves_ssec_checksum() {
        let checksum = bytes::Bytes::from_static(b"ssec-checksum");
@@ -2641,7 +2342,7 @@ mod tests {

        tx.try_send(first).expect("first MRF entry should fill the test channel");

-        let admission = queue_mrf_save_entry(&tx, second, "test");
+        let admission = queue_mrf_save_admission(&tx, second, "bucket", "second", "test");
        tokio::pin!(admission);

        assert!(
@@ -2986,30 +2687,6 @@ mod tests {
        assert!(missing_file.entries.is_empty());
    }

-    #[test]
-    fn durable_mrf_summary_aggregates_entries_by_bucket_for_obs() {
-        let summary =
-            durable_mrf_backlog_summary_from_sizes([("b1".to_string(), 1024), ("b1".to_string(), 512), ("b2".to_string(), 0)]);
-
-        assert!(summary.available);
-        let buckets = summary
-            .buckets
-            .into_iter()
-            .map(|bucket| (bucket.bucket.clone(), bucket))
-            .collect::<HashMap<_, _>>();
-        assert_eq!(buckets["b1"].count, 2);
-        assert_eq!(buckets["b1"].bytes, 1536);
-        assert_eq!(buckets["b2"].count, 1);
-        assert_eq!(buckets["b2"].bytes, 0);
-    }
-
-    #[test]
-    fn durable_mrf_summary_marks_invalid_sizes_unavailable() {
-        let invalid = durable_mrf_backlog_summary_from_sizes([("bucket".to_string(), -1)]);
-        assert!(!invalid.available);
-        assert!(invalid.buckets.is_empty());
-    }
-
    #[test]
    fn durable_mrf_snapshot_marks_corrupt_or_invalid_data_unavailable() {
        let corrupt = durable_mrf_backlog_from_read(Ok(vec![0, 1, 2]));
@@ -23,8 +23,8 @@ use super::replication_stats_boundary::{
 };
 use super::runtime_boundary as runtime_sources;
 use std::collections::HashMap;
+use std::sync::Arc;
 use std::sync::atomic::{AtomicI64, Ordering};
-use std::sync::{Arc, Mutex as StdMutex};
 use std::time::{Duration, SystemTime};
 use tokio::sync::{Mutex, RwLock};
 use tokio::time::interval;
@@ -143,7 +143,7 @@ pub struct ReplicationStats {
    // Active worker statistics
    pub workers: Arc<Mutex<ActiveWorkerStat>>,
    // Queue statistics cache
-    pub q_cache: Arc<StdMutex<QueueCache>>,
+    pub q_cache: Arc<Mutex<QueueCache>>,
    // Proxy statistics cache
    pub p_cache: Arc<Mutex<ProxyStatsCache>>,
    // MRF backlog statistics (simplified)
@@ -158,7 +158,7 @@ impl ReplicationStats {
        Self {
            sr_stats: Arc::new(SRStats::new()),
            workers: Arc::new(Mutex::new(ActiveWorkerStat::new())),
-            q_cache: Arc::new(StdMutex::new(QueueCache::new())),
+            q_cache: Arc::new(Mutex::new(QueueCache::new())),
            p_cache: Arc::new(Mutex::new(ProxyStatsCache::new())),
            mrf_stats: HashMap::new(),
            cache: Arc::new(RwLock::new(HashMap::new())),
@@ -198,9 +198,8 @@ impl ReplicationStats {
            let mut interval = interval(Duration::from_secs(2));
            loop {
                interval.tick().await;
-                if let Ok(mut cache) = q_cache_clone.lock() {
-                    cache.update();
-                }
+                let mut cache = q_cache_clone.lock().await;
+                cache.update();
            }
        });
    }
@@ -392,13 +391,12 @@ impl ReplicationStats {
        drop(cache);

        {
-            if let Ok(q_cache) = self.q_cache.lock() {
-                for (bucket, queue_stats) in &q_cache.bucket_stats {
-                    let bucket_stats = result.entry(bucket.clone()).or_insert_with(BucketReplicationStats::new);
-                    bucket_stats.q_stat = queue_stats.snapshot();
-                    bucket_stats.mark_node_local_provider_available();
-                    bucket_stats.queue_scope = ReplicationMetricScope::NodeLocal;
-                }
+            let q_cache = self.q_cache.lock().await;
+            for (bucket, queue_stats) in &q_cache.bucket_stats {
+                let bucket_stats = result.entry(bucket.clone()).or_insert_with(BucketReplicationStats::new);
+                bucket_stats.q_stat = queue_stats.snapshot();
+                bucket_stats.mark_node_local_provider_available();
+                bucket_stats.queue_scope = ReplicationMetricScope::NodeLocal;
            }
        }

@@ -431,11 +429,8 @@ impl ReplicationStats {
        let boot_time = SystemTime::UNIX_EPOCH; // simplified implementation
        let uptime = SystemTime::now().duration_since(boot_time).unwrap_or_default().as_secs() as i64;

-        let queued = self
-            .q_cache
-            .lock()
-            .map(|q_cache| q_cache.get_site_stats())
-            .unwrap_or_default();
+        let q_cache = self.q_cache.lock().await;
+        let queued = q_cache.get_site_stats();

        let p_cache = self.p_cache.lock().await;
        let proxied = p_cache.get_site_stats();
@@ -638,9 +633,8 @@ impl ReplicationStats {
        drop(cache);

        {
-            if let Ok(q_cache) = self.q_cache.lock()
-                && let Some(queue_stats) = q_cache.bucket_stats.get(bucket)
-            {
+            let q_cache = self.q_cache.lock().await;
+            if let Some(queue_stats) = q_cache.bucket_stats.get(bucket) {
                replication_stats.q_stat = queue_stats.snapshot();
            }
        }
@@ -671,17 +665,31 @@ impl ReplicationStats {
    }

    /// Increase queue statistics
-    pub fn inc_q(&self, bucket: &str, size: i64, _is_delete_repl: bool, _op_type: ReplicationType) {
-        if let Ok(mut q_cache) = self.q_cache.lock() {
-            q_cache.inc(bucket, size);
-        }
+    pub async fn inc_q(&self, bucket: &str, size: i64, _is_delete_repl: bool, _op_type: ReplicationType) {
+        let mut q_cache = self.q_cache.lock().await;
+        let stats = q_cache
+            .bucket_stats
+            .entry(bucket.to_string())
+            .or_insert_with(InQueueMetric::default);
+        stats.curr.now_bytes.fetch_add(size, Ordering::Relaxed);
+        stats.curr.now_count.fetch_add(1, Ordering::Relaxed);
+
+        q_cache.sr_queue_stats.curr.now_bytes.fetch_add(size, Ordering::Relaxed);
+        q_cache.sr_queue_stats.curr.now_count.fetch_add(1, Ordering::Relaxed);
    }

    /// Decrease queue statistics
-    pub fn dec_q(&self, bucket: &str, size: i64, _is_del_marker: bool, _op_type: ReplicationType) {
-        if let Ok(mut q_cache) = self.q_cache.lock() {
-            q_cache.dec(bucket, size);
-        }
+    pub async fn dec_q(&self, bucket: &str, size: i64, _is_del_marker: bool, _op_type: ReplicationType) {
+        let mut q_cache = self.q_cache.lock().await;
+        let stats = q_cache
+            .bucket_stats
+            .entry(bucket.to_string())
+            .or_insert_with(InQueueMetric::default);
+        stats.curr.now_bytes.fetch_sub(size, Ordering::Relaxed);
+        stats.curr.now_count.fetch_sub(1, Ordering::Relaxed);
+
+        q_cache.sr_queue_stats.curr.now_bytes.fetch_sub(size, Ordering::Relaxed);
+        q_cache.sr_queue_stats.curr.now_count.fetch_sub(1, Ordering::Relaxed);
    }

    /// Increase proxy metrics
@@ -793,14 +801,14 @@ mod tests {
    async fn latest_stats_include_queue_until_drained() {
        let stats = ReplicationStats::new();

-        stats.inc_q("queued-bucket", 4096, false, ReplicationType::Object);
+        stats.inc_q("queued-bucket", 4096, false, ReplicationType::Object).await;
        let queued = stats.get_latest_replication_stats("queued-bucket").await;
        assert!(queued.replication_stats.provider_available);
        assert_eq!(queued.replication_stats.q_stat.curr.count, 1);
        assert_eq!(queued.replication_stats.q_stat.curr.bytes, 4096);
        assert_eq!(queued.replication_stats.queue_scope, ReplicationMetricScope::NodeLocal);

-        stats.dec_q("queued-bucket", 4096, false, ReplicationType::Object);
+        stats.dec_q("queued-bucket", 4096, false, ReplicationType::Object).await;
        let drained = stats.get_latest_replication_stats("queued-bucket").await;
        assert_eq!(drained.replication_stats.q_stat.curr.count, 0);
        assert_eq!(drained.replication_stats.q_stat.curr.bytes, 0);
@@ -903,7 +911,7 @@ mod tests {
        for _ in 0..32 {
            let stats = Arc::clone(&stats);
            tasks.push(tokio::spawn(async move {
-                stats.inc_q("concurrent-bucket", 7, false, ReplicationType::Object);
+                stats.inc_q("concurrent-bucket", 7, false, ReplicationType::Object).await;
            }));
        }
        for task in tasks {
@@ -172,7 +172,7 @@ impl ProviderVersionCapabilities {
    }
 }

-pub(crate) fn validate_remote_version_id(version_id: &str) -> Result<(), Error> {
+fn validate_remote_version_id(version_id: &str) -> Result<(), Error> {
    if version_id.is_empty() {
        return Err(Error::new(
            ErrorKind::InvalidData,
@@ -46,6 +46,16 @@ lazy_static! {
        m.insert("x-amz-replication-status".to_string(), true);
        m
    };
+    static ref SSE_HEADERS: HashMap<String, bool> = {
+        let mut m = HashMap::new();
+        m.insert("x-amz-server-side-encryption".to_string(), true);
+        m.insert("x-amz-server-side-encryption-aws-kms-key-id".to_string(), true);
+        m.insert("x-amz-server-side-encryption-context".to_string(), true);
+        m.insert("x-amz-server-side-encryption-customer-algorithm".to_string(), true);
+        m.insert("x-amz-server-side-encryption-customer-key".to_string(), true);
+        m.insert("x-amz-server-side-encryption-customer-key-md5".to_string(), true);
+        m
+    };
 }

 pub fn is_standard_query_value(qs_key: &str) -> bool {
@@ -60,12 +70,16 @@ pub fn is_standard_header(header_key: &str) -> bool {
    *SUPPORTED_HEADERS.get(&header_key.to_lowercase()).unwrap_or(&false)
 }

+pub fn is_sse_header(header_key: &str) -> bool {
+    *SSE_HEADERS.get(&header_key.to_lowercase()).unwrap_or(&false)
+}
+
 pub fn is_amz_header(header_key: &str) -> bool {
    let key = header_key.to_lowercase();
    key.starts_with("x-amz-meta-")
        || key.starts_with("x-amz-grant-")
        || key == "x-amz-acl"
-        || rustfs_utils::http::is_sse_header(header_key)
+        || is_sse_header(header_key)
        || key.starts_with("x-amz-checksum-")
 }

@@ -12,20 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#[cfg(test)]
-use crate::cluster::rpc::http_auth::RPC_REPLAY_SCOPE_VERSION_HEADER;
-use crate::cluster::rpc::http_auth::{
-    RPC_AUTH_VERSION_HEADER, RPC_AUTH_VERSION_V2, RPC_BOOT_EPOCH_CHALLENGE_HEADER, RPC_BOOT_EPOCH_HEADER,
-    RPC_BOOT_EPOCH_PROOF_HEADER, RPC_CONTENT_SHA256_HEADER, TIMESTAMP_HEADER,
-};
-use crate::cluster::rpc::{
-    gen_tonic_replay_scope_headers, gen_tonic_signature_headers, normalize_tonic_rpc_audience, verify_tonic_boot_epoch_response,
-};
-#[cfg(test)]
-use crate::cluster::rpc::{tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers};
+use crate::cluster::rpc::http_auth::RPC_CONTENT_SHA256_HEADER;
+use crate::cluster::rpc::{gen_tonic_signature_headers, normalize_tonic_rpc_audience};
 use crate::disk::error::{DiskError, Error as DiskErrorType, RpcStatusError};
 use crate::runtime::sources as runtime_sources;
-use http::{Request as HttpRequest, Response as HttpResponse, Uri};
+use http::Uri;
 use rustfs_protos::{
    ChannelClass, create_new_channel, get_channel_for_class,
    proto_gen::node_service::{
@@ -33,19 +24,9 @@ use rustfs_protos::{
        tier_mutation_control_service_client::TierMutationControlServiceClient,
    },
 };
-use std::{
-    collections::HashMap,
-    error::Error,
-    future::Future,
-    io::ErrorKind,
-    pin::Pin,
-    sync::{LazyLock, Mutex},
-    task::{Context, Poll},
-};
+use std::{error::Error, io::ErrorKind};
 use tonic::{service::interceptor::InterceptedService, transport::Channel};
-use tower::Service;
 use tracing::debug;
-use uuid::Uuid;

 use super::context_propagation::{inject_request_id_into_metadata, inject_trace_context_into_metadata};

@@ -54,7 +35,7 @@ use super::context_propagation::{inject_request_id_into_metadata, inject_trace_c
 pub async fn node_service_time_out_client(
    addr: &String,
    interceptor: TonicInterceptor,
-) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>, Box<dyn Error>> {
+) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>, Box<dyn Error>> {
    // Default to the latency-sensitive control channel; bulk `bytes` RPCs opt in via the
    // `_for_class` variant below (grpc-optimization P1).
    node_service_time_out_client_for_class(addr, interceptor, ChannelClass::Control).await
@@ -63,14 +44,13 @@ pub async fn node_service_time_out_client(
 pub async fn heal_control_time_out_client(
    addr: &str,
    interceptor: TonicInterceptor,
-) -> Result<HealControlServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>, Box<dyn Error>> {
+) -> Result<HealControlServiceClient<InterceptedService<Channel, TonicInterceptor>>, Box<dyn Error>> {
    let interceptor = interceptor.with_rpc_audience(addr)?;
    let channel = match runtime_sources::cached_node_channel(addr).await {
        Some(channel) => channel,
        None => create_new_channel(addr).await?,
    };
    let max_message_size = rustfs_protos::HEAL_CONTROL_RPC_MAX_MESSAGE_SIZE;
-    let channel = ReplayScopeChannel::new(channel, interceptor.replay_scope_audience());
    Ok(HealControlServiceClient::with_interceptor(channel, interceptor)
        .max_decoding_message_size(max_message_size)
        .max_encoding_message_size(max_message_size))
@@ -79,14 +59,13 @@ pub async fn heal_control_time_out_client(
 pub async fn tier_mutation_control_time_out_client(
    addr: &str,
    interceptor: TonicInterceptor,
-) -> Result<TierMutationControlServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>, Box<dyn Error>> {
+) -> Result<TierMutationControlServiceClient<InterceptedService<Channel, TonicInterceptor>>, Box<dyn Error>> {
    let interceptor = interceptor.with_rpc_audience(addr)?;
    let channel = match runtime_sources::cached_node_channel(addr).await {
        Some(channel) => channel,
        None => create_new_channel(addr).await?,
    };
    let max_message_size = rustfs_protos::TIER_MUTATION_RPC_MAX_MESSAGE_SIZE;
-    let channel = ReplayScopeChannel::new(channel, interceptor.replay_scope_audience());
    Ok(TierMutationControlServiceClient::with_interceptor(channel, interceptor)
        .max_decoding_message_size(max_message_size)
        .max_encoding_message_size(max_message_size))
@@ -102,7 +81,7 @@ pub async fn node_service_time_out_client_for_class(
    addr: &String,
    interceptor: TonicInterceptor,
    class: ChannelClass,
-) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>, Box<dyn Error>> {
+) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>, Box<dyn Error>> {
    let interceptor = interceptor.with_rpc_audience(addr)?;
    let channel = match class {
        ChannelClass::Control => match runtime_sources::cached_node_channel(addr).await {
@@ -117,7 +96,6 @@ pub async fn node_service_time_out_client_for_class(
    };

    let max_message_size = rustfs_protos::internode_rpc_max_message_size();
-    let channel = ReplayScopeChannel::new(channel, interceptor.replay_scope_audience());
    Ok(NodeServiceClient::with_interceptor(channel, interceptor)
        .max_decoding_message_size(max_message_size)
        .max_encoding_message_size(max_message_size))
@@ -125,7 +103,7 @@ pub async fn node_service_time_out_client_for_class(

 pub async fn node_service_time_out_client_no_auth(
    addr: &String,
-) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>, Box<dyn Error>> {
+) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>, Box<dyn Error>> {
    node_service_time_out_client(addr, TonicInterceptor::NoOp(NoOpInterceptor)).await
 }

@@ -221,104 +199,6 @@ pub(crate) fn is_network_like_disk_error(err: &DiskErrorType) -> bool {
    }
 }

-/// The transport service that learns an authenticated peer boot epoch and adds the replay-scoped
-/// signature only after one has been observed. The v1/v2 interceptor stays inside this wrapper so
-/// old servers continue receiving precisely the metadata they understand.
-#[derive(Clone, Debug)]
-pub struct ReplayScopeChannel<S> {
-    inner: S,
-    audience: Option<String>,
-}
-
-/// The channel type used by internode clients after v2 authentication and replay-scope handling.
-pub type AuthenticatedChannel = ReplayScopeChannel<Channel>;
-
-static PEER_BOOT_EPOCHS: LazyLock<Mutex<HashMap<String, Uuid>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
-
-impl<S> ReplayScopeChannel<S> {
-    fn new(inner: S, audience: Option<String>) -> Self {
-        Self { inner, audience }
-    }
-}
-
-fn cached_peer_boot_epoch(audience: &str) -> Option<Uuid> {
-    PEER_BOOT_EPOCHS.lock().ok().and_then(|epochs| epochs.get(audience).copied())
-}
-
-fn remember_peer_boot_epoch(audience: String, epoch: Uuid) {
-    if let Ok(mut epochs) = PEER_BOOT_EPOCHS.lock() {
-        epochs.insert(audience, epoch);
-    }
-}
-
-impl<S, ReqBody, ResBody> Service<HttpRequest<ReqBody>> for ReplayScopeChannel<S>
-where
-    S: Service<HttpRequest<ReqBody>, Response = HttpResponse<ResBody>>,
-    S::Error: Send + 'static,
-    S::Future: Send + 'static,
-    ReqBody: Send + 'static,
-    ResBody: Send + 'static,
-{
-    type Response = HttpResponse<ResBody>;
-    type Error = S::Error;
-    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    fn call(&mut self, mut request: HttpRequest<ReqBody>) -> Self::Future {
-        let authenticated = self.audience.as_ref().is_some_and(|_| {
-            request
-                .headers()
-                .get(RPC_AUTH_VERSION_HEADER)
-                .and_then(|value| value.to_str().ok())
-                == Some(RPC_AUTH_VERSION_V2)
-        });
-        let challenge = authenticated.then(Uuid::new_v4);
-        if let (Some(audience), Some(challenge)) = (self.audience.as_deref(), challenge) {
-            // The challenge is independently HMAC-authenticated by the response proof. It is not
-            // part of v2 so old peers ignore it, while a new peer can safely advertise its epoch.
-            request.headers_mut().insert(
-                RPC_BOOT_EPOCH_CHALLENGE_HEADER,
-                challenge.to_string().parse().expect("UUID must be a valid header value"),
-            );
-            if let (Some(boot_epoch), Some(timestamp), Some(content_sha256)) = (
-                cached_peer_boot_epoch(audience),
-                request.headers().get(TIMESTAMP_HEADER).and_then(|value| value.to_str().ok()),
-                request
-                    .headers()
-                    .get(RPC_CONTENT_SHA256_HEADER)
-                    .and_then(|value| value.to_str().ok()),
-            ) {
-                match gen_tonic_replay_scope_headers(audience, request.uri().path(), timestamp, content_sha256, boot_epoch) {
-                    Ok(headers) => request.headers_mut().extend(headers),
-                    Err(error) => debug!(error = %error, "could not attach replay-scoped RPC signature"),
-                }
-            }
-        }
-
-        let audience = self.audience.clone();
-        let future = self.inner.call(request);
-        Box::pin(async move {
-            let response = future.await?;
-            if let (Some(audience), Some(challenge)) = (audience, challenge) {
-                match verify_tonic_boot_epoch_response(&audience, challenge, response.headers()) {
-                    Ok(epoch) => remember_peer_boot_epoch(audience, epoch),
-                    Err(error)
-                        if response.headers().contains_key(RPC_BOOT_EPOCH_HEADER)
-                            || response.headers().contains_key(RPC_BOOT_EPOCH_PROOF_HEADER) =>
-                    {
-                        debug!(error = %error, "peer boot epoch response proof was rejected")
-                    }
-                    Err(_) => {}
-                }
-            }
-            Ok(response)
-        })
-    }
-}
-
 pub struct TonicSignatureInterceptor {
    audience: Option<String>,
 }
@@ -377,13 +257,6 @@ impl TonicInterceptor {
        }
        Ok(self)
    }
-
-    fn replay_scope_audience(&self) -> Option<String> {
-        match self {
-            Self::Signature(interceptor) => interceptor.audience.clone(),
-            Self::NoOp(_) => None,
-        }
-    }
 }

 impl tonic::service::Interceptor for TonicInterceptor {
@@ -406,38 +279,6 @@ mod tests {
    use tracing_opentelemetry::OpenTelemetrySpanExt;
    use tracing_subscriber::{Registry, layer::SubscriberExt};

-    #[derive(Clone)]
-    struct EpochProofService {
-        audience: String,
-        seen_headers: std::sync::Arc<Mutex<Vec<http::HeaderMap>>>,
-    }
-
-    impl Service<HttpRequest<()>> for EpochProofService {
-        type Response = HttpResponse<()>;
-        type Error = std::convert::Infallible;
-        type Future = std::future::Ready<Result<Self::Response, Self::Error>>;
-
-        fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn call(&mut self, request: HttpRequest<()>) -> Self::Future {
-            self.seen_headers
-                .lock()
-                .expect("test header capture lock must not be poisoned")
-                .push(request.headers().clone());
-            let challenge = tonic_boot_epoch_challenge(request.headers())
-                .expect("client challenge must be syntactically valid")
-                .expect("authenticated client request must carry a boot epoch challenge");
-            let mut response = HttpResponse::new(());
-            response.headers_mut().extend(
-                tonic_boot_epoch_response_headers(&self.audience, challenge)
-                    .expect("test server must be able to sign an epoch proof"),
-            );
-            std::future::ready(Ok(response))
-        }
-    }
-
    fn ensure_test_rpc_secret() {
        runtime_sources::ensure_test_rpc_secret();
    }
@@ -579,52 +420,6 @@ mod tests {
        assert_eq!(interceptor.audience.as_deref(), Some("node-a:9000"));
    }

-    #[test]
-    fn replay_scope_channel_uses_epoch_proof_before_sending_v3() {
-        ensure_test_rpc_secret();
-        let audience = "replay-scope-client-test:9000";
-        PEER_BOOT_EPOCHS
-            .lock()
-            .expect("peer epoch cache lock must not be poisoned")
-            .remove(audience);
-        let seen_headers = std::sync::Arc::new(Mutex::new(Vec::new()));
-        let service = EpochProofService {
-            audience: audience.to_string(),
-            seen_headers: seen_headers.clone(),
-        };
-        let mut channel = ReplayScopeChannel::new(service, Some(audience.to_string()));
-        let make_request = || {
-            let mut request = HttpRequest::builder()
-                .uri("/node_service.NodeService/Ping")
-                .body(())
-                .expect("test RPC request must build");
-            request.headers_mut().extend(
-                gen_tonic_signature_headers(audience, "node_service.NodeService", "Ping", None)
-                    .expect("v2 test headers must mint"),
-            );
-            request
-        };
-
-        futures::executor::block_on(channel.call(make_request())).expect("first request must complete");
-        futures::executor::block_on(channel.call(make_request())).expect("second request must complete");
-
-        let headers = seen_headers.lock().expect("test header capture lock must not be poisoned");
-        assert_eq!(headers.len(), 2);
-        assert!(headers[0].contains_key(RPC_BOOT_EPOCH_CHALLENGE_HEADER));
-        assert!(
-            !headers[0].contains_key(RPC_REPLAY_SCOPE_VERSION_HEADER),
-            "the first request must remain v2-compatible until the peer proves its epoch"
-        );
-        assert!(
-            headers[1].contains_key(RPC_REPLAY_SCOPE_VERSION_HEADER),
-            "the second request must carry the replay-scoped v3 signature"
-        );
-        PEER_BOOT_EPOCHS
-            .lock()
-            .expect("peer epoch cache lock must not be poisoned")
-            .remove(audience);
-    }
-
    #[test]
    fn test_signature_interceptor_requires_generated_method_metadata() {
        ensure_test_rpc_secret();
@@ -20,8 +20,8 @@
 //! rustfs/rustfs#4402) is anchored by the `ghsa_r5qv_*` tests in the module
 //! below, plus the broader negative-signature suite. The advisory class is: a
 //! node must never accept an RPC whose auth is missing, malformed, or signed
-//! with the default/empty shared secret. Body-bound v2 requests and all replay-scoped v3
-//! requests additionally receive process-local replay protection. See
+//! with the default/empty shared secret. Body-bound v2 requests additionally
+//! receive process-local replay protection. See
 //! `docs/testing/security-regressions.md` for the full advisory -> test map.
 //!
 //! Advisory: <https://github.com/rustfs/rustfs/security/advisories/GHSA-r5qv-rc46-hv8q>
@@ -50,22 +50,13 @@ use uuid::Uuid;
 type HmacSha256 = Hmac<Sha256>;

 const SIGNATURE_HEADER: &str = "x-rustfs-signature";
-pub(crate) const TIMESTAMP_HEADER: &str = "x-rustfs-timestamp";
-pub(crate) const RPC_AUTH_VERSION_HEADER: &str = "x-rustfs-rpc-auth-version";
+const TIMESTAMP_HEADER: &str = "x-rustfs-timestamp";
+const RPC_AUTH_VERSION_HEADER: &str = "x-rustfs-rpc-auth-version";
 const RPC_SIGNATURE_V2_HEADER: &str = "x-rustfs-rpc-signature-v2";
 const RPC_NONCE_HEADER: &str = "x-rustfs-rpc-nonce";
 pub(crate) const RPC_CONTENT_SHA256_HEADER: &str = "x-rustfs-content-sha256";
-pub(crate) const RPC_AUTH_VERSION_V2: &str = "2";
-pub const RPC_REPLAY_SCOPE_VERSION_HEADER: &str = "x-rustfs-rpc-replay-scope-version";
-pub const RPC_REPLAY_SCOPE_SIGNATURE_HEADER: &str = "x-rustfs-rpc-signature-v3";
-pub const RPC_REPLAY_SCOPE_NONCE_HEADER: &str = "x-rustfs-rpc-replay-nonce";
-pub const RPC_BOOT_EPOCH_HEADER: &str = "x-rustfs-rpc-boot-epoch";
-pub const RPC_BOOT_EPOCH_CHALLENGE_HEADER: &str = "x-rustfs-rpc-boot-epoch-challenge";
-pub const RPC_BOOT_EPOCH_PROOF_HEADER: &str = "x-rustfs-rpc-boot-epoch-proof";
-const RPC_REPLAY_SCOPE_VERSION_V3: &str = "3";
+const RPC_AUTH_VERSION_V2: &str = "2";
 const RPC_RESPONSE_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-response-proof-v1\0";
-const RPC_REPLAY_SCOPE_DOMAIN: &[u8] = b"rustfs-rpc-replay-scope-v3\0";
-const RPC_BOOT_EPOCH_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-boot-epoch-proof-v1\0";
 const UNSIGNED_PAYLOAD: &str = "UNSIGNED-PAYLOAD";
 const UNSIGNED_PAYLOAD_NONCE: &str = "unsigned";
 const SIGNATURE_VALID_DURATION: i64 = 300; // 5 minutes
@@ -84,15 +75,9 @@ static INTERNODE_RPC_BODY_DIGEST_STRICT: LazyLock<bool> = LazyLock::new(|| {
        rustfs_config::DEFAULT_INTERNODE_RPC_BODY_DIGEST_STRICT,
    )
 });
-static INTERNODE_RPC_REPLAY_SCOPE_STRICT: LazyLock<bool> = LazyLock::new(|| {
-    get_env_bool(
-        rustfs_config::ENV_INTERNODE_RPC_REPLAY_SCOPE_STRICT,
-        rustfs_config::DEFAULT_INTERNODE_RPC_REPLAY_SCOPE_STRICT,
-    )
-});
-// Sized for peak legitimate authenticated RPC RPS x the retention window once replay scope is
-// active; overflow fails closed and increments the replay-cache overflow counter. Clamped to at
-// least 1 so a misconfigured zero cannot disable replay protection by rejecting every request.
+// Sized for peak legitimate body-bound mutation RPS x the retention window; overflow fails closed
+// and increments the replay-cache overflow counter. Clamped to at least 1 so a misconfigured zero
+// cannot disable replay protection by rejecting every body-bound request.
 static REPLAY_CACHE_CAPACITY: LazyLock<usize> = LazyLock::new(|| {
    rustfs_utils::get_env_usize(
        rustfs_config::ENV_INTERNODE_RPC_REPLAY_CACHE_CAPACITY,
@@ -101,7 +86,6 @@ static REPLAY_CACHE_CAPACITY: LazyLock<usize> = LazyLock::new(|| {
    .max(1)
 });
 static RPC_SECRET_RESOLUTION_LOG_ONCE: Once = Once::new();
-static RPC_BOOT_EPOCH: LazyLock<Uuid> = LazyLock::new(Uuid::new_v4);

 #[derive(Default)]
 struct RpcNonceCache {
@@ -329,189 +313,6 @@ fn verify_signature_v2(secret: &str, scope: SignatureV2Scope<'_>, signature: &st
    mac.verify_slice(&signature).is_ok()
 }

-#[derive(Clone, Copy)]
-struct ReplayScope<'a> {
-    audience: &'a str,
-    path: &'a str,
-    timestamp: &'a str,
-    nonce: Uuid,
-    content_sha256: &'a str,
-    boot_epoch: Uuid,
-}
-
-fn update_replay_scope(mac: &mut HmacSha256, scope: ReplayScope<'_>) {
-    mac.update(RPC_REPLAY_SCOPE_DOMAIN);
-    for part in [
-        scope.audience.as_bytes(),
-        b"|",
-        scope.path.as_bytes(),
-        b"|POST|",
-        scope.timestamp.as_bytes(),
-        b"|",
-        scope.nonce.as_bytes(),
-        b"|",
-        scope.content_sha256.as_bytes(),
-        b"|",
-        scope.boot_epoch.as_bytes(),
-    ] {
-        mac.update(part);
-    }
-}
-
-fn generate_replay_scope_signature(secret: &str, scope: ReplayScope<'_>) -> std::io::Result<String> {
-    let mut mac =
-        <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_replay_scope(&mut mac, scope);
-    Ok(general_purpose::STANDARD.encode(mac.finalize().into_bytes()))
-}
-
-fn verify_replay_scope_signature(secret: &str, scope: ReplayScope<'_>, signature: &str) -> bool {
-    let Ok(signature) = general_purpose::STANDARD.decode(signature) else {
-        return false;
-    };
-    let Ok(mut mac) = <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()) else {
-        return false;
-    };
-    update_replay_scope(&mut mac, scope);
-    mac.verify_slice(&signature).is_ok()
-}
-
-fn update_boot_epoch_proof(mac: &mut HmacSha256, audience: &str, challenge: Uuid, boot_epoch: Uuid) {
-    mac.update(RPC_BOOT_EPOCH_PROOF_DOMAIN);
-    mac.update(audience.as_bytes());
-    mac.update(b"|");
-    mac.update(challenge.as_bytes());
-    mac.update(boot_epoch.as_bytes());
-}
-
-fn generate_boot_epoch_proof(secret: &str, audience: &str, challenge: Uuid, boot_epoch: Uuid) -> std::io::Result<String> {
-    if audience.is_empty() || challenge.is_nil() || boot_epoch.is_nil() {
-        return Err(std::io::Error::other("Invalid RPC boot epoch proof scope"));
-    }
-    let mut mac =
-        <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_boot_epoch_proof(&mut mac, audience, challenge, boot_epoch);
-    Ok(general_purpose::STANDARD.encode(mac.finalize().into_bytes()))
-}
-
-fn verify_boot_epoch_proof(secret: &str, audience: &str, challenge: Uuid, boot_epoch: Uuid, proof: &str) -> std::io::Result<()> {
-    if audience.is_empty() || challenge.is_nil() || boot_epoch.is_nil() {
-        return Err(std::io::Error::other("Invalid RPC boot epoch proof scope"));
-    }
-    let proof = general_purpose::STANDARD
-        .decode(proof)
-        .map_err(|_| std::io::Error::other("Invalid RPC boot epoch proof"))?;
-    let mut mac =
-        <HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
-    update_boot_epoch_proof(&mut mac, audience, challenge, boot_epoch);
-    mac.verify_slice(&proof)
-        .map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid RPC boot epoch proof"))
-}
-
-fn non_nil_uuid(value: &str, name: &str) -> std::io::Result<Uuid> {
-    let value = Uuid::parse_str(value).map_err(|_| std::io::Error::other(format!("Invalid {name}")))?;
-    (!value.is_nil())
-        .then_some(value)
-        .ok_or_else(|| std::io::Error::other(format!("Invalid {name}")))
-}
-
-fn parse_tonic_rpc_path(path: &str) -> std::io::Result<(&str, &str)> {
-    path.strip_prefix('/')
-        .and_then(|path| path.split_once('/'))
-        .filter(|(service, rpc_method)| !service.is_empty() && !rpc_method.is_empty() && !rpc_method.contains('/'))
-        .ok_or_else(|| std::io::Error::other("Invalid RPC request path"))
-}
-
-/// The process-unique epoch included in every replay-scoped server verification.
-///
-/// A fresh process gets a fresh value, so a signature captured before a server restart cannot be
-/// admitted even though the bounded in-memory nonce cache necessarily starts empty again.
-pub fn tonic_rpc_boot_epoch() -> Uuid {
-    *RPC_BOOT_EPOCH
-}
-
-/// Build the additive replay-scope headers for a request that already carries rolling-upgrade-safe
-/// v1/v2 metadata. `timestamp` and `content_sha256` are deliberately reused from the v2 scope so
-/// old servers can continue validating the same request unchanged.
-pub fn gen_tonic_replay_scope_headers(
-    audience: &str,
-    path: &str,
-    timestamp: &str,
-    content_sha256: &str,
-    boot_epoch: Uuid,
-) -> std::io::Result<HeaderMap> {
-    if audience.is_empty() || !path.starts_with('/') || !valid_content_sha256(content_sha256) || boot_epoch.is_nil() {
-        return Err(std::io::Error::other("Invalid replay-scoped RPC signing scope"));
-    }
-    parse_tonic_rpc_path(path)?;
-    timestamp
-        .parse::<i64>()
-        .map_err(|_| std::io::Error::other("Invalid timestamp format"))?;
-
-    let nonce = Uuid::new_v4();
-    let signature = generate_replay_scope_signature(
-        &get_shared_secret()?,
-        ReplayScope {
-            audience,
-            path,
-            timestamp,
-            nonce,
-            content_sha256,
-            boot_epoch,
-        },
-    )?;
-    let mut headers = HeaderMap::new();
-    headers.insert(RPC_REPLAY_SCOPE_VERSION_HEADER, HeaderValue::from_static(RPC_REPLAY_SCOPE_VERSION_V3));
-    headers.insert(
-        RPC_REPLAY_SCOPE_SIGNATURE_HEADER,
-        header_value(&signature, RPC_REPLAY_SCOPE_SIGNATURE_HEADER)?,
-    );
-    headers.insert(
-        RPC_REPLAY_SCOPE_NONCE_HEADER,
-        header_value(&nonce.to_string(), RPC_REPLAY_SCOPE_NONCE_HEADER)?,
-    );
-    headers.insert(RPC_BOOT_EPOCH_HEADER, header_value(&boot_epoch.to_string(), RPC_BOOT_EPOCH_HEADER)?);
-    Ok(headers)
-}
-
-/// Parse the optional client challenge used to authenticate a server boot-epoch advertisement.
-pub fn tonic_boot_epoch_challenge(headers: &HeaderMap) -> std::io::Result<Option<Uuid>> {
-    headers
-        .get(RPC_BOOT_EPOCH_CHALLENGE_HEADER)
-        .map(|value| {
-            value
-                .to_str()
-                .map_err(|_| std::io::Error::other("Invalid RPC boot epoch challenge"))
-                .and_then(|value| non_nil_uuid(value, "RPC boot epoch challenge"))
-        })
-        .transpose()
-}
-
-/// Build the authenticated response headers for a client boot-epoch challenge.
-pub fn tonic_boot_epoch_response_headers(audience: &str, challenge: Uuid) -> std::io::Result<HeaderMap> {
-    let boot_epoch = tonic_rpc_boot_epoch();
-    let proof = generate_boot_epoch_proof(&get_shared_secret()?, audience, challenge, boot_epoch)?;
-    let mut headers = HeaderMap::new();
-    headers.insert(RPC_BOOT_EPOCH_HEADER, header_value(&boot_epoch.to_string(), RPC_BOOT_EPOCH_HEADER)?);
-    headers.insert(RPC_BOOT_EPOCH_PROOF_HEADER, header_value(&proof, RPC_BOOT_EPOCH_PROOF_HEADER)?);
-    Ok(headers)
-}
-
-/// Verify the server boot-epoch response for a challenge generated by this client.
-pub fn verify_tonic_boot_epoch_response(audience: &str, challenge: Uuid, headers: &HeaderMap) -> std::io::Result<Uuid> {
-    let boot_epoch = headers
-        .get(RPC_BOOT_EPOCH_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC boot epoch"))
-        .and_then(|value| non_nil_uuid(value, "RPC boot epoch"))?;
-    let proof = headers
-        .get(RPC_BOOT_EPOCH_PROOF_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC boot epoch proof"))?;
-    verify_boot_epoch_proof(&get_shared_secret()?, audience, challenge, boot_epoch, proof)?;
-    Ok(boot_epoch)
-}
-
 fn valid_content_sha256(value: &str) -> bool {
    value == UNSIGNED_PAYLOAD
        || (value.len() == 64
@@ -642,16 +443,6 @@ pub fn set_tonic_canonical_body_digest<T>(request: &mut tonic::Request<T>, canon
    Ok(())
 }

-pub fn set_tonic_mutation_body_digest<T: rustfs_protos::CanonicalMutationBody>(
-    request: &mut tonic::Request<T>,
-) -> std::io::Result<()> {
-    let canonical_body = request
-        .get_ref()
-        .canonical_body()
-        .map_err(|_| std::io::Error::other("RPC mutation body length cannot be represented"))?;
-    set_tonic_canonical_body_digest(request, &canonical_body)
-}
-
 pub fn verify_tonic_canonical_body_digest<T>(request: &tonic::Request<T>, canonical_body: &[u8]) -> std::io::Result<()> {
    let version = request
        .metadata()
@@ -675,7 +466,7 @@ pub fn verify_tonic_canonical_body_digest<T>(request: &tonic::Request<T>, canoni
    Ok(())
 }

-/// Verify a mutating RPC's canonical body digest with a rolling-upgrade fallback.
+/// Verify a mutating disk RPC's canonical body digest with a rolling-upgrade fallback.
 ///
 /// When the request carries a real (non-`UNSIGNED-PAYLOAD`) content SHA-256 it is verified exactly
 /// like [`verify_tonic_canonical_body_digest`]. The digest value is a member of the signed v2
@@ -706,7 +497,7 @@ fn verify_tonic_mutation_body_digest_with_strictness<T>(
        Some(digest) if digest != UNSIGNED_PAYLOAD => verify_tonic_canonical_body_digest(request, canonical_body),
        _ => {
            // RUSTFS_COMPAT_TODO(disk-mutation-body-digest): accept digestless peers during rolling upgrades. Remove after the
-            // minimum supported RustFS peer version body-binds every mutating RPC.
+            // minimum supported RustFS peer version body-binds every mutating disk RPC.
            if strict {
                return Err(std::io::Error::other("RPC mutation requires a body-bound v2 signature"));
            }
@@ -730,17 +521,6 @@ fn has_v2_auth_headers(headers: &HeaderMap) -> bool {
    .any(|name| headers.contains_key(*name))
 }

-fn has_replay_scope_headers(headers: &HeaderMap) -> bool {
-    [
-        RPC_REPLAY_SCOPE_VERSION_HEADER,
-        RPC_REPLAY_SCOPE_SIGNATURE_HEADER,
-        RPC_REPLAY_SCOPE_NONCE_HEADER,
-        RPC_BOOT_EPOCH_HEADER,
-    ]
-    .iter()
-    .any(|name| headers.contains_key(*name))
-}
-
 /// Whether the server requires target-bound v2 authentication on every internode gRPC request,
 /// rejecting the legacy constant-target fallback instead of accepting it. Default-off rollout
 /// lever gated on the v1-fallback counter reading zero fleet-wide; see
@@ -750,127 +530,9 @@ fn internode_rpc_signature_strict() -> bool {
    *INTERNODE_RPC_SIGNATURE_STRICT
 }

-fn internode_rpc_replay_scope_strict() -> bool {
-    *INTERNODE_RPC_REPLAY_SCOPE_STRICT
-}
-
-fn verify_tonic_replay_scope_signature(audience: &str, path: &str, headers: &HeaderMap) -> std::io::Result<()> {
-    if audience.is_empty() {
-        return Err(std::io::Error::other("Missing RPC audience"));
-    }
-    parse_tonic_rpc_path(path)?;
-
-    let version = headers
-        .get(RPC_REPLAY_SCOPE_VERSION_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC replay scope version"))?;
-    if version != RPC_REPLAY_SCOPE_VERSION_V3 {
-        return Err(std::io::Error::other("Unsupported RPC replay scope version"));
-    }
-    let signature = headers
-        .get(RPC_REPLAY_SCOPE_SIGNATURE_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC replay scope signature"))?;
-    let timestamp = headers
-        .get(TIMESTAMP_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing timestamp header"))?;
-    let signed_at = timestamp
-        .parse::<i64>()
-        .map_err(|_| std::io::Error::other("Invalid timestamp format"))?;
-    check_timestamp(signed_at)?;
-    let nonce = headers
-        .get(RPC_REPLAY_SCOPE_NONCE_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC replay scope nonce"))
-        .and_then(|value| non_nil_uuid(value, "RPC replay scope nonce"))?;
-    let content_sha256 = headers
-        .get(RPC_CONTENT_SHA256_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC content SHA-256"))?;
-    if !valid_content_sha256(content_sha256) {
-        return Err(std::io::Error::other("Invalid RPC content SHA-256"));
-    }
-    let boot_epoch = headers
-        .get(RPC_BOOT_EPOCH_HEADER)
-        .and_then(|value| value.to_str().ok())
-        .ok_or_else(|| std::io::Error::other("Missing RPC boot epoch"))
-        .and_then(|value| non_nil_uuid(value, "RPC boot epoch"))?;
-    let secret = get_shared_secret()?;
-    if !verify_replay_scope_signature(
-        &secret,
-        ReplayScope {
-            audience,
-            path,
-            timestamp,
-            nonce,
-            content_sha256,
-            boot_epoch,
-        },
-        signature,
-    ) {
-        return Err(std::io::Error::other("Invalid RPC replay scope signature"));
-    }
-    if boot_epoch != tonic_rpc_boot_epoch() {
-        return Err(std::io::Error::other("RPC boot epoch is stale"));
-    }
-    check_and_record_nonce(nonce, signed_at)
-}
-
 /// Verify gRPC authentication, preferring v2 without downgrade on malformed v2 metadata.
 pub fn verify_tonic_rpc_signature(audience: &str, path: &str, headers: &HeaderMap) -> std::io::Result<()> {
-    verify_tonic_rpc_signature_with_policy(
-        audience,
-        path,
-        headers,
-        internode_rpc_signature_strict(),
-        internode_rpc_replay_scope_strict(),
-        false,
-    )
-}
-
-/// Verify gRPC authentication while allowing the narrowly scoped v2 `Ping` bootstrap used to
-/// obtain an authenticated server boot epoch when replay-scope strictness is enabled.
-pub fn verify_tonic_rpc_signature_with_bootstrap(
-    audience: &str,
-    path: &str,
-    headers: &HeaderMap,
-    allow_replay_scope_bootstrap: bool,
-) -> std::io::Result<()> {
-    verify_tonic_rpc_signature_with_policy(
-        audience,
-        path,
-        headers,
-        internode_rpc_signature_strict(),
-        internode_rpc_replay_scope_strict(),
-        allow_replay_scope_bootstrap,
-    )
-}
-
-fn verify_tonic_rpc_signature_with_policy(
-    audience: &str,
-    path: &str,
-    headers: &HeaderMap,
-    signature_strict: bool,
-    replay_scope_strict: bool,
-    allow_replay_scope_bootstrap: bool,
-) -> std::io::Result<()> {
-    if has_replay_scope_headers(headers) {
-        return verify_tonic_replay_scope_signature(audience, path, headers);
-    }
-
-    // Only a method-bound v2 Ping with a syntactically valid challenge may bootstrap a strict
-    // client after its peer restarts. Legacy metadata never gets this exception.
-    let bootstrap = allow_replay_scope_bootstrap
-        && has_v2_auth_headers(headers)
-        && tonic_boot_epoch_challenge(headers).is_ok_and(|challenge| challenge.is_some());
-    if replay_scope_strict && !bootstrap {
-        return Err(std::io::Error::other("RPC replay-scoped authentication required"));
-    }
-
-    verify_tonic_rpc_signature_with_strictness(audience, path, headers, signature_strict)?;
-    global_internode_metrics().record_replay_scope_fallback();
-    Ok(())
+    verify_tonic_rpc_signature_with_strictness(audience, path, headers, internode_rpc_signature_strict())
 }

 /// [`verify_tonic_rpc_signature`] with the strict gate injected as a parameter, so both rollout
@@ -1015,28 +677,11 @@ mod tests {
    use crate::cluster::rpc::context_propagation::REQUEST_ID_HEADER;
    use crate::runtime::sources as runtime_sources;
    use http::{HeaderMap, Method};
-    use rustfs_protos::{
-        CanonicalMutationBody as _, PEER_RESTDRY_RUN, PEER_RESTSIGNAL, PEER_RESTSUB_SYS,
-        proto_gen::node_service::{Mss, SignalServiceRequest},
-    };
-    use std::collections::HashMap;
    use std::io::{self, Write};
    use std::sync::{Arc, Mutex};
    use time::OffsetDateTime;
    use tracing_subscriber::fmt::MakeWriter;

-    fn signal_service_request(signal: &str, sub_system: &str, dry_run: &str) -> SignalServiceRequest {
-        SignalServiceRequest {
-            vars: Some(Mss {
-                value: HashMap::from([
-                    (PEER_RESTSIGNAL.to_string(), signal.to_string()),
-                    (PEER_RESTSUB_SYS.to_string(), sub_system.to_string()),
-                    (PEER_RESTDRY_RUN.to_string(), dry_run.to_string()),
-                ]),
-            }),
-        }
-    }
-
    #[derive(Clone, Default)]
    struct CapturedLogs {
        buffer: Arc<Mutex<Vec<u8>>>,
@@ -1601,104 +1246,6 @@ mod tests {
        assert_eq!(error.to_string(), "Invalid RPC v2 signature");
    }

-    #[test]
-    fn replay_scope_binds_path_epoch_and_random_nonce() {
-        ensure_test_rpc_secret();
-        let path = "/node_service.NodeService/Ping";
-        let mut headers = gen_tonic_signature_headers("node-a:9000", "node_service.NodeService", "Ping", None)
-            .expect("v2 compatibility headers should build");
-        let timestamp = headers
-            .get(TIMESTAMP_HEADER)
-            .and_then(|value| value.to_str().ok())
-            .expect("v2 timestamp")
-            .to_string();
-        let content_sha256 = headers
-            .get(RPC_CONTENT_SHA256_HEADER)
-            .and_then(|value| value.to_str().ok())
-            .expect("v2 content digest")
-            .to_string();
-        headers.extend(
-            gen_tonic_replay_scope_headers("node-a:9000", path, &timestamp, &content_sha256, tonic_rpc_boot_epoch())
-                .expect("replay-scope headers should build"),
-        );
-
-        assert!(
-            verify_tonic_rpc_signature_with_policy("node-a:9000", path, &headers, false, false, false).is_ok(),
-            "the first replay-scoped request must be accepted"
-        );
-        let replay = verify_tonic_rpc_signature_with_policy("node-a:9000", path, &headers, false, false, false)
-            .expect_err("the random replay-scope nonce must be single-use");
-        assert_eq!(replay.to_string(), "RPC request replay detected");
-
-        let path_error = verify_tonic_replay_scope_signature("node-a:9000", "/node_service.NodeService/SignalService", &headers)
-            .expect_err("a replay-scoped signature must not move to another method");
-        assert_eq!(path_error.to_string(), "Invalid RPC replay scope signature");
-    }
-
-    #[test]
-    fn replay_scope_rejects_partial_metadata_and_stale_epoch_without_fallback() {
-        ensure_test_rpc_secret();
-        let path = "/node_service.NodeService/Ping";
-        let mut partial = gen_tonic_signature_headers("node-a:9000", "node_service.NodeService", "Ping", None)
-            .expect("v2 compatibility headers should build");
-        partial.insert(RPC_REPLAY_SCOPE_VERSION_HEADER, HeaderValue::from_static(RPC_REPLAY_SCOPE_VERSION_V3));
-        let error = verify_tonic_rpc_signature_with_policy("node-a:9000", path, &partial, false, false, false)
-            .expect_err("partial replay-scope metadata must never downgrade to v2");
-        assert_eq!(error.to_string(), "Missing RPC replay scope signature");
-
-        let timestamp = partial
-            .get(TIMESTAMP_HEADER)
-            .and_then(|value| value.to_str().ok())
-            .expect("v2 timestamp")
-            .to_string();
-        let content_sha256 = partial
-            .get(RPC_CONTENT_SHA256_HEADER)
-            .and_then(|value| value.to_str().ok())
-            .expect("v2 content digest")
-            .to_string();
-        let stale_epoch = Uuid::new_v4();
-        partial.extend(
-            gen_tonic_replay_scope_headers("node-a:9000", path, &timestamp, &content_sha256, stale_epoch)
-                .expect("replay-scope headers should build"),
-        );
-        let stale = verify_tonic_rpc_signature_with_policy("node-a:9000", path, &partial, false, false, false)
-            .expect_err("a signature from a prior server boot epoch must be rejected");
-        assert_eq!(stale.to_string(), "RPC boot epoch is stale");
-    }
-
-    #[test]
-    fn replay_scope_strictness_allows_only_authenticated_ping_bootstrap() {
-        ensure_test_rpc_secret();
-        let mut headers = gen_tonic_signature_headers("node-a:9000", "node_service.NodeService", "Ping", None)
-            .expect("v2 compatibility headers should build");
-        let rejected =
-            verify_tonic_rpc_signature_with_policy("node-a:9000", "/node_service.NodeService/Ping", &headers, false, true, false)
-                .expect_err("strict replay scope must reject stripped new metadata");
-        assert_eq!(rejected.to_string(), "RPC replay-scoped authentication required");
-
-        headers.insert(
-            RPC_BOOT_EPOCH_CHALLENGE_HEADER,
-            HeaderValue::from_str(&Uuid::new_v4().to_string()).expect("UUID header"),
-        );
-        assert!(
-            verify_tonic_rpc_signature_with_policy("node-a:9000", "/node_service.NodeService/Ping", &headers, false, true, true,)
-                .is_ok(),
-            "only the signed Ping bootstrap may obtain a new server epoch in strict mode"
-        );
-    }
-
-    #[test]
-    fn boot_epoch_response_proof_binds_audience_challenge_and_epoch() {
-        ensure_test_rpc_secret();
-        let challenge = Uuid::new_v4();
-        let headers = tonic_boot_epoch_response_headers("node-a:9000", challenge).expect("proof headers should build");
-        let epoch =
-            verify_tonic_boot_epoch_response("node-a:9000", challenge, &headers).expect("matching proof headers should verify");
-        assert_eq!(epoch, tonic_rpc_boot_epoch());
-        assert!(verify_tonic_boot_epoch_response("node-b:9000", challenge, &headers).is_err());
-        assert!(verify_tonic_boot_epoch_response("node-a:9000", Uuid::new_v4(), &headers).is_err());
-    }
-
    #[test]
    fn malformed_v2_auth_does_not_downgrade_to_valid_legacy_signature() {
        ensure_test_rpc_secret();
@@ -2049,72 +1596,6 @@ mod tests {
        assert_eq!(stripped.to_string(), "RPC content SHA-256 mismatch");
    }

-    #[test]
-    fn signal_service_mutation_contract_rejects_tampering_and_replay() {
-        ensure_test_rpc_secret();
-        let body = signal_service_request("2", "scanner", "false")
-            .canonical_body()
-            .expect("small signal request should encode");
-        let mut request = tonic::Request::new(());
-        set_tonic_canonical_body_digest(&mut request, &body).expect("canonical body digest should be attached");
-        let content_sha256 = request
-            .metadata()
-            .get(RPC_CONTENT_SHA256_HEADER)
-            .and_then(|value| value.to_str().ok());
-        let headers = gen_tonic_signature_headers("node-a:9000", "node_service.NodeService", "SignalService", content_sha256)
-            .expect("body-bound auth headers should build");
-        request.metadata_mut().as_mut().extend(headers.clone());
-
-        assert!(
-            verify_tonic_rpc_signature("node-a:9000", "/node_service.NodeService/SignalService", &headers).is_ok(),
-            "the first body-bound signal request must authenticate"
-        );
-        assert!(verify_tonic_mutation_body_digest(&request, &body).is_ok());
-
-        let tampered = signal_service_request("1", "scanner", "false")
-            .canonical_body()
-            .expect("small signal request should encode");
-        let error = verify_tonic_mutation_body_digest(&request, &tampered)
-            .expect_err("changing the signal must invalidate the signed digest");
-        assert_eq!(error.to_string(), "RPC content SHA-256 mismatch");
-
-        let replay = verify_tonic_rpc_signature("node-a:9000", "/node_service.NodeService/SignalService", &headers)
-            .expect_err("reusing the signal nonce must fail");
-        assert_eq!(replay.to_string(), "RPC request replay detected");
-    }
-
-    #[test]
-    #[serial_test::serial(rpc_body_digest_fallback_counter)]
-    fn signal_service_mutation_contract_preserves_rollout_fallback_and_strictness() {
-        let body = signal_service_request("2", "scanner", "false")
-            .canonical_body()
-            .expect("small signal request should encode");
-        let before = global_internode_metrics().snapshot().body_digest_fallback_total;
-        let digestless = tonic::Request::new(());
-
-        assert!(
-            verify_tonic_mutation_body_digest_with_strictness(&digestless, &body, false).is_ok(),
-            "old peers must remain compatible while the rollout gate is open"
-        );
-        assert_eq!(
-            global_internode_metrics().snapshot().body_digest_fallback_total,
-            before + 1,
-            "accepted digestless signal requests must be visible in the fallback metric"
-        );
-
-        let error = verify_tonic_mutation_body_digest_with_strictness(&digestless, &body, true)
-            .expect_err("strict mode must reject a digestless signal request");
-        assert_eq!(error.to_string(), "RPC mutation requires a body-bound v2 signature");
-
-        let mut bound = tonic::Request::new(());
-        set_tonic_canonical_body_digest(&mut bound, &body).expect("canonical body digest should be attached");
-        bound
-            .metadata_mut()
-            .as_mut()
-            .insert(RPC_AUTH_VERSION_HEADER, HeaderValue::from_static(RPC_AUTH_VERSION_V2));
-        assert!(verify_tonic_mutation_body_digest_with_strictness(&bound, &body, true).is_ok());
-    }
-
    #[test]
    fn nonce_cache_rejects_replay_after_wall_clock_regression() {
        let now = Instant::now();
@@ -26,25 +26,20 @@ pub(crate) mod runtime_sources;
 pub use background_monitor::shutdown_background_monitors;
 pub(crate) use background_monitor::spawn_background_monitor;
 pub use client::{
-    AuthenticatedChannel, TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client,
-    node_service_time_out_client_no_auth,
+    TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client, node_service_time_out_client_no_auth,
 };
-// Re-exported through `api::rpc`; not every item is consumed inside this crate.
-#[allow(unused_imports)]
 pub use http_auth::{
-    TONIC_RPC_PREFIX, build_auth_headers, gen_signature_headers, gen_tonic_replay_scope_headers, gen_tonic_signature_headers,
-    normalize_tonic_rpc_audience, set_tonic_canonical_body_digest, set_tonic_mutation_body_digest, sign_ns_scanner_capability,
-    sign_tonic_rpc_response_proof, tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers, verify_ns_scanner_capability,
-    verify_rpc_signature, verify_tonic_boot_epoch_response, verify_tonic_canonical_body_digest,
-    verify_tonic_mutation_body_digest, verify_tonic_rpc_response_proof, verify_tonic_rpc_signature,
-    verify_tonic_rpc_signature_with_bootstrap,
+    TONIC_RPC_PREFIX, build_auth_headers, gen_signature_headers, gen_tonic_signature_headers, normalize_tonic_rpc_audience,
+    set_tonic_canonical_body_digest, sign_ns_scanner_capability, sign_tonic_rpc_response_proof, verify_ns_scanner_capability,
+    verify_rpc_signature, verify_tonic_canonical_body_digest, verify_tonic_mutation_body_digest, verify_tonic_rpc_response_proof,
+    verify_tonic_rpc_signature,
 };
 #[cfg(test)]
 pub(crate) use internode_data_transport::TcpHttpInternodeDataTransport;
 pub use internode_data_transport::build_internode_data_transport_from_env;
 pub(crate) use peer_rest_client::TierConfigReloadOutcome;
 pub use peer_rest_client::{
-    KMS_SIGNAL_SUBSYSTEM, PEER_RESTDRY_RUN, PEER_RESTSIGNAL, PEER_RESTSUB_SYS, PeerRestClient, SERVICE_SIGNAL_REFRESH_CONFIG,
+    PEER_RESTDRY_RUN, PEER_RESTSIGNAL, PEER_RESTSUB_SYS, PeerRestClient, SERVICE_SIGNAL_REFRESH_CONFIG,
    SERVICE_SIGNAL_RELOAD_DYNAMIC, ScannerPeerActivity,
 };
 pub(crate) use peer_s3_client::heal_bucket_local_on_disks;
@@ -13,10 +13,10 @@
 // limitations under the License.

 use crate::cluster::rpc::client::{
-    AuthenticatedChannel, TonicInterceptor, embedded_tonic_status, gen_tonic_signature_interceptor, heal_control_time_out_client,
+    TonicInterceptor, embedded_tonic_status, gen_tonic_signature_interceptor, heal_control_time_out_client,
    is_network_like_status, message_has_network_needle, node_service_time_out_client, tier_mutation_control_time_out_client,
 };
-use crate::cluster::rpc::{set_tonic_canonical_body_digest, set_tonic_mutation_body_digest, verify_tonic_rpc_response_proof};
+use crate::cluster::rpc::{set_tonic_canonical_body_digest, verify_tonic_rpc_response_proof};
 use crate::error::{Error, Result};
 use crate::storage_api_contracts::internode::{
    SCANNER_ACTIVITY_LEGACY_PROTOCOL_VERSION, SCANNER_ACTIVITY_PREVIOUS_PROTOCOL_VERSION, SCANNER_ACTIVITY_PROTOCOL_VERSION,
@@ -45,12 +45,11 @@ use rustfs_protos::proto_gen::node_service::{
    HealControlRequest, LoadBucketMetadataRequest, LoadGroupRequest, LoadPolicyMappingRequest, LoadPolicyRequest,
    LoadRebalanceMetaRequest, LoadServiceAccountRequest, LoadTransitionTierConfigRequest, LoadUserRequest,
    LocalStorageInfoRequest, Mss, ReloadPoolMetaRequest, ReloadSiteReplicationConfigRequest, ScannerActivityRequest,
-    ScannerActivityResponse, ServerInfoRequest, SignalServiceRequest, SignalServiceResponse, StartDecommissionRequest,
-    StartProfilingRequest, StopRebalanceRequest, TierMutationAbortRequest, TierMutationCommitRequest,
-    TierMutationControlResponse, TierMutationPeerState, TierMutationPrepareRequest, node_service_client::NodeServiceClient,
+    ScannerActivityResponse, ServerInfoRequest, SignalServiceRequest, StartDecommissionRequest, StartProfilingRequest,
+    StopRebalanceRequest, TierMutationAbortRequest, TierMutationCommitRequest, TierMutationControlResponse,
+    TierMutationPeerState, TierMutationPrepareRequest, node_service_client::NodeServiceClient,
    tier_mutation_control_service_client::TierMutationControlServiceClient,
 };
-pub use rustfs_protos::{PEER_RESTDRY_RUN, PEER_RESTSIGNAL, PEER_RESTSUB_SYS};
 use rustfs_protos::{TierMutationRpcPhase, evict_failed_connection};
 use rustfs_utils::XHost;
 use serde::{Deserialize, Serialize as _};
@@ -58,7 +57,7 @@ use std::{
    collections::HashMap,
    io::Cursor,
    sync::{
-        Arc, Weak,
+        Arc,
        atomic::{AtomicBool, Ordering},
    },
    time::SystemTime,
@@ -66,17 +65,15 @@ use std::{
 use tokio::{net::TcpStream, time::Duration};
 use tonic::Request;
 use tonic::service::interceptor::InterceptedService;
+use tonic::transport::Channel;
 use tracing::{debug, info, warn};
 use uuid::Uuid;

+pub const PEER_RESTSIGNAL: &str = "signal";
+pub const PEER_RESTSUB_SYS: &str = "sub-sys";
+pub const PEER_RESTDRY_RUN: &str = "dry-run";
 pub const SERVICE_SIGNAL_REFRESH_CONFIG: u64 = 1;
 pub const SERVICE_SIGNAL_RELOAD_DYNAMIC: u64 = 2;
-/// Dynamic config subsystem for the cluster-persisted KMS configuration.
-///
-/// KMS configuration lives in its own cluster object rather than in the server
-/// config document, so it is not a `ServerConfig` subsystem; it only shares the
-/// reload signal transport.
-pub const KMS_SIGNAL_SUBSYSTEM: &str = "kms";
 const BACKGROUND_HEAL_STATUS_MAX_MESSAGE_SIZE: usize = 64 * 1024;
 const HEAL_CONTROL_FINGERPRINT_MAX_SIZE: usize = 256;
 const HEAL_CONTROL_PAYLOAD_MAX_SIZE: usize = 64 * 1024;
@@ -105,13 +102,8 @@ fn decode_bucket_stats_response(response: GetBucketStatsDataResponse) -> Result<
 }

 fn validate_signal_service_protocol(sig: u64, sub_sys: &str, protocol_version: u32) -> Result<()> {
-    // The version stays pinned to DYNAMIC_CONFIG_PROTOCOL_VERSION rather than
-    // being bumped per subsystem: the comparison is shared, so raising it would
-    // retire peers that already converge scanner and heal config correctly.
-    // Subsystems added after a peer was built are rejected by that peer's own
-    // subsystem allow-list, which surfaces as an explicit failed signal.
    if sig == SERVICE_SIGNAL_RELOAD_DYNAMIC
-        && matches!(sub_sys, SCANNER_SUB_SYS | HEAL_SUB_SYS | KMS_SIGNAL_SUBSYSTEM)
+        && matches!(sub_sys, SCANNER_SUB_SYS | HEAL_SUB_SYS)
        && protocol_version < rustfs_protos::DYNAMIC_CONFIG_PROTOCOL_VERSION
    {
        return Err(Error::other(format!("peer does not support dynamic {sub_sys} config convergence")));
@@ -232,21 +224,6 @@ fn validate_heal_control_response_proof(canonical_response: &[u8], proof: &[u8])
        .map_err(|_| Error::other("peer returned an invalid heal control response proof"))
 }

-fn decode_remote_version_state_capability(expected_member: &str, result: &[u8]) -> Result<Uuid> {
-    let (topology_member, process_epoch) = rustfs_protos::decode_remote_version_state_capability(result).map_err(Error::other)?;
-    if topology_member != expected_member {
-        return Err(Error::other(
-            "peer returned a remote version state capability for a different topology member",
-        ));
-    }
-    let server_epoch =
-        Uuid::from_slice(process_epoch).map_err(|_| Error::other("peer returned an invalid remote version state epoch"))?;
-    if server_epoch.is_nil() {
-        return Err(Error::other("peer returned a nil remote version state epoch"));
-    }
-    Ok(server_epoch)
-}
-
 #[derive(Clone, Debug)]
 pub struct PeerLiveEventsBatch {
    pub events: Vec<u8>,
@@ -258,7 +235,6 @@ pub struct PeerLiveEventsBatch {
 pub struct PeerRestClient {
    pub host: XHost,
    pub grid_host: String,
-    topology_member: String,
    offline: Arc<AtomicBool>,
    recovery_running: Arc<AtomicBool>,
 }
@@ -351,54 +327,14 @@ impl PeerRestClient {
    }

    pub fn new(host: XHost, grid_host: String) -> Self {
-        let topology_member = host.to_string();
        Self {
            host,
            grid_host,
-            topology_member,
            offline: Arc::new(AtomicBool::new(false)),
            recovery_running: Arc::new(AtomicBool::new(false)),
        }
    }

-    fn parse_topology_host(peer_host_port: &str, grid_host: &str) -> Result<XHost> {
-        let url = url::Url::parse(grid_host).map_err(|_| Error::other("peer grid host is not a valid URL"))?;
-        if !matches!(url.scheme(), "http" | "https")
-            || !url.username().is_empty()
-            || url.password().is_some()
-            || url.query().is_some()
-            || url.fragment().is_some()
-            || url.path() != "/"
-        {
-            return Err(Error::other("peer grid host has an invalid URL shape"));
-        }
-        let url_host = url.host().ok_or_else(|| Error::other("peer grid host is missing a host"))?;
-        let topology_host = match url.port() {
-            Some(port) => format!("{url_host}:{port}"),
-            None => url_host.to_string(),
-        };
-        let explicit_port = url.port();
-        let name = match url_host {
-            url::Host::Domain(domain) => domain.to_string(),
-            url::Host::Ipv4(address) => address.to_string(),
-            url::Host::Ipv6(address) if explicit_port.is_none() => format!("[{address}]"),
-            url::Host::Ipv6(address) => address.to_string(),
-        };
-        let port = url
-            .port_or_known_default()
-            .filter(|port| *port > 0)
-            .ok_or_else(|| Error::other("peer grid host is missing a valid port"))?;
-        let host = XHost {
-            name,
-            port,
-            is_port_set: explicit_port.is_some(),
-        };
-        if topology_host != peer_host_port {
-            return Err(Error::other("peer topology host does not match its grid URL"));
-        }
-        Ok(host)
-    }
-
    fn build_clients_from_slots(
        slots: Vec<(String, Option<String>, bool)>,
    ) -> (Vec<Option<Self>>, Vec<Option<Self>>, Vec<String>) {
@@ -412,14 +348,10 @@ impl PeerRestClient {
            }

            let client = match grid_host {
-                Some(grid_host) => match Self::parse_topology_host(&peer_host_port, &grid_host) {
-                    Ok(host) => {
-                        let mut client = PeerRestClient::new(host, grid_host);
-                        client.topology_member = peer_host_port.clone();
-                        Some(client)
-                    }
+                Some(grid_host) => match XHost::try_from(peer_host_port.clone()) {
+                    Ok(host) => Some(PeerRestClient::new(host, grid_host)),
                    Err(err) => {
-                        warn!(peer = %peer_host_port, "peer topology host parse failed while constructing peer client: {err:?}");
+                        warn!(peer = %peer_host_port, "Xhost parse failed while constructing peer client: {err:?}");
                        None
                    }
                },
@@ -460,7 +392,7 @@ impl PeerRestClient {
        (remote, all, remote_topology_hosts)
    }

-    pub async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>> {
+    pub async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>> {
        if self.offline.load(Ordering::Acquire) {
            self.mark_offline_and_spawn_recovery();
            return Err(Error::other(format!("peer {} is temporarily offline", self.grid_host)));
@@ -481,7 +413,7 @@ impl PeerRestClient {
        &self,
    ) -> Result<
        rustfs_protos::proto_gen::node_service::heal_control_service_client::HealControlServiceClient<
-            InterceptedService<AuthenticatedChannel, TonicInterceptor>,
+            InterceptedService<Channel, TonicInterceptor>,
        >,
    > {
        if self.offline.load(Ordering::Acquire) {
@@ -502,7 +434,7 @@ impl PeerRestClient {

    async fn get_tier_mutation_control_client(
        &self,
-    ) -> Result<TierMutationControlServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>> {
+    ) -> Result<TierMutationControlServiceClient<InterceptedService<Channel, TonicInterceptor>>> {
        if self.offline.load(Ordering::Acquire) {
            self.mark_offline_and_spawn_recovery();
            return Err(Error::other(format!("peer {} is temporarily offline", self.grid_host)));
@@ -568,8 +500,9 @@ impl PeerRestClient {
        }

        let grid_host = self.grid_host.clone();
-        let offline = Arc::downgrade(&self.offline);
-        let recovery_running = Arc::downgrade(&self.recovery_running);
+        let offline = Arc::clone(&self.offline);
+        let recovery_running = Arc::clone(&self.recovery_running);
+        let span = Self::recovery_monitor_span(&grid_host);
        // The offline flag and its recovery are the silent half of
        // rustfs/backlog#888: log the monitor's start and its success so an
        // "offline then back" episode leaves a trace on the observing node.
@@ -578,34 +511,13 @@ impl PeerRestClient {
            grid_host = %self.grid_host,
            "peer RPC connection marked offline after a network-like failure; starting background recovery monitor"
        );
-        drop(Self::spawn_recovery_monitor(grid_host, offline, recovery_running));
-    }
-
-    fn spawn_recovery_monitor(
-        grid_host: String,
-        offline: Weak<AtomicBool>,
-        recovery_running: Weak<AtomicBool>,
-    ) -> tokio::task::JoinHandle<()> {
-        let span = Self::recovery_monitor_span(&grid_host);
        super::spawn_background_monitor(span, async move {
            let mut delay = get_drive_active_check_interval();
            let connect_timeout = get_drive_active_check_timeout();

            for attempt in 1..=PEER_REST_RECOVERY_MAX_ATTEMPTS {
-                if offline.strong_count() == 0 || recovery_running.strong_count() == 0 {
-                    return;
-                }
                tokio::time::sleep(delay).await;
-                if offline.strong_count() == 0 || recovery_running.strong_count() == 0 {
-                    return;
-                }
                if Self::perform_connectivity_check(&grid_host, connect_timeout).await.is_ok() {
-                    let Some(offline) = offline.upgrade() else {
-                        return;
-                    };
-                    let Some(recovery_running) = recovery_running.upgrade() else {
-                        return;
-                    };
                    offline.store(false, Ordering::Release);
                    recovery_running.store(false, Ordering::Release);
                    info!(
@@ -625,10 +537,8 @@ impl PeerRestClient {
                attempts = PEER_REST_RECOVERY_MAX_ATTEMPTS,
                "peer recovery monitor reached max attempts; will retry on next request"
            );
-            if let Some(recovery_running) = recovery_running.upgrade() {
-                recovery_running.store(false, Ordering::Release);
-            }
-        })
+            recovery_running.store(false, Ordering::Release);
+        });
    }

    #[cfg(test)]
@@ -1246,24 +1156,14 @@ impl PeerRestClient {
        validate_heal_control_capability_proof(&canonical_ack, &proof)
    }

-    pub async fn probe_remote_version_state(&self, topology_fingerprint: String) -> Result<(String, Uuid)> {
-        let probe = rustfs_protos::remote_version_state_capability_probe(Uuid::new_v4().as_bytes());
-        let result = self
-            .heal_control(rustfs_protos::HEAL_CONTROL_PROTOCOL_VERSION, topology_fingerprint, probe)
-            .await?;
-        let epoch = decode_remote_version_state_capability(&self.topology_member, &result)?;
-        Ok((self.topology_member.clone(), epoch))
-    }
-
    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 {
+                let 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 {
@@ -1283,10 +1183,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(DeleteBucketMetadataRequest {
+                let request = Request::new(DeleteBucketMetadataRequest {
                    bucket: bucket.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.delete_bucket_metadata(request).await?.into_inner();
                if !response.success {
@@ -1306,10 +1205,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(DeletePolicyRequest {
+                let request = Request::new(DeletePolicyRequest {
                    policy_name: policy.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.delete_policy(request).await?.into_inner();
                if !response.success {
@@ -1329,10 +1227,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadPolicyRequest {
+                let request = Request::new(LoadPolicyRequest {
                    policy_name: policy.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.load_policy(request).await?.into_inner();
                if !response.success {
@@ -1352,12 +1249,11 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadPolicyMappingRequest {
+                let request = Request::new(LoadPolicyMappingRequest {
                    user_or_group: user_or_group.to_string(),
                    user_type,
                    is_group,
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.load_policy_mapping(request).await?.into_inner();
                if !response.success {
@@ -1377,10 +1273,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(DeleteUserRequest {
+                let request = Request::new(DeleteUserRequest {
                    access_key: access_key.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.delete_user(request).await?.into_inner();
                if !response.success {
@@ -1400,10 +1295,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(DeleteServiceAccountRequest {
+                let request = Request::new(DeleteServiceAccountRequest {
                    access_key: access_key.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.delete_service_account(request).await?.into_inner();
                if !response.success {
@@ -1423,11 +1317,10 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadUserRequest {
+                let request = Request::new(LoadUserRequest {
                    access_key: access_key.to_string(),
                    temp,
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.load_user(request).await?.into_inner();
                if !response.success {
@@ -1447,10 +1340,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadServiceAccountRequest {
+                let request = Request::new(LoadServiceAccountRequest {
                    access_key: access_key.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.load_service_account(request).await?.into_inner();
                if !response.success {
@@ -1470,10 +1362,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadGroupRequest {
+                let request = Request::new(LoadGroupRequest {
                    group: group.to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.load_group(request).await?.into_inner();
                if !response.success {
@@ -1493,8 +1384,7 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(ReloadSiteReplicationConfigRequest {});
-                set_tonic_mutation_body_digest(&mut request)?;
+                let request = Request::new(ReloadSiteReplicationConfigRequest {});

                let response = client.reload_site_replication_config(request).await?.into_inner();
                if !response.success {
@@ -1511,22 +1401,6 @@ impl PeerRestClient {
    }

    pub async fn signal_service(&self, sig: u64, sub_sys: &str, dry_run: bool, _exec_at: SystemTime) -> Result<()> {
-        self.signal_service_checked(sig, sub_sys, dry_run).await.map(|_| ())
-    }
-
-    /// Report the KMS configuration fingerprint the peer is currently running.
-    ///
-    /// Sent as a dry-run reload signal so the peer answers without swapping its
-    /// own configuration. `None` means the peer has no KMS configuration. The
-    /// fingerprint is advisory and feeds cluster status reporting only, so the
-    /// response is not proof-signed.
-    pub async fn kms_config_fingerprint(&self) -> Result<Option<String>> {
-        self.signal_service_checked(SERVICE_SIGNAL_RELOAD_DYNAMIC, KMS_SIGNAL_SUBSYSTEM, true)
-            .await
-            .map(|response| response.config_fingerprint)
-    }
-
-    async fn signal_service_checked(&self, sig: u64, sub_sys: &str, dry_run: bool) -> Result<SignalServiceResponse> {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
@@ -1534,10 +1408,9 @@ impl PeerRestClient {
                vars.insert(PEER_RESTSIGNAL.to_string(), sig.to_string());
                vars.insert(PEER_RESTSUB_SYS.to_string(), sub_sys.to_string());
                vars.insert(PEER_RESTDRY_RUN.to_string(), dry_run.to_string());
-                let mut request = Request::new(SignalServiceRequest {
+                let request = Request::new(SignalServiceRequest {
                    vars: Some(Mss { value: vars }),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.signal_service(request).await?.into_inner();
                if !response.success {
@@ -1547,7 +1420,7 @@ impl PeerRestClient {
                    return Err(Error::other(""));
                }
                validate_signal_service_protocol(sig, sub_sys, response.protocol_version)?;
-                Ok(response)
+                Ok(())
            }
            .await,
        )
@@ -1606,8 +1479,7 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(ReloadPoolMetaRequest {});
-                set_tonic_mutation_body_digest(&mut request)?;
+                let request = Request::new(ReloadPoolMetaRequest {});

                let response = client.reload_pool_meta(request).await?.into_inner();
                if !response.success {
@@ -1628,10 +1500,9 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(StopRebalanceRequest {
+                let request = Request::new(StopRebalanceRequest {
                    expected_rebalance_id: expected_rebalance_id.unwrap_or_default().to_string(),
                });
-                set_tonic_mutation_body_digest(&mut request)?;

                let response = client.stop_rebalance(request).await?.into_inner();
                if !response.success {
@@ -1652,8 +1523,7 @@ impl PeerRestClient {
        self.finalize_result(
            async {
                let mut client = self.get_client().await?;
-                let mut request = Request::new(LoadRebalanceMetaRequest { start_rebalance });
-                set_tonic_mutation_body_digest(&mut request)?;
+                let request = Request::new(LoadRebalanceMetaRequest { start_rebalance });

                let response = client.load_rebalance_meta(request).await?.into_inner();

@@ -1692,8 +1562,7 @@ impl PeerRestClient {
                    })
                    .collect::<Result<Vec<_>>>()?;
                let mut client = self.get_client().await?;
-                let mut request = Request::new(StartDecommissionRequest { pool_indices });
-                set_tonic_mutation_body_digest(&mut request)?;
+                let request = Request::new(StartDecommissionRequest { pool_indices });

                let response = client.start_decommission(request).await?.into_inner();
                if !response.success {
@@ -1716,8 +1585,7 @@ impl PeerRestClient {
                let pool_index = u32::try_from(pool_index)
                    .map_err(|_| Error::other(format!("decommission pool index {pool_index} exceeds RPC range")))?;
                let mut client = self.get_client().await?;
-                let mut request = Request::new(CancelDecommissionRequest { pool_index });
-                set_tonic_mutation_body_digest(&mut request)?;
+                let request = Request::new(CancelDecommissionRequest { pool_index });

                let response = client.cancel_decommission(request).await?.into_inner();
                if !response.success {
@@ -1740,8 +1608,7 @@ impl PeerRestClient {
                let pool_index = u32::try_from(pool_index)
                    .map_err(|_| Error::other(format!("decommission pool index {pool_index} exceeds RPC range")))?;
                let mut client = self.get_client().await?;
-                let mut request = Request::new(ClearDecommissionRequest { pool_index });
-                set_tonic_mutation_body_digest(&mut request)?;
+                let request = Request::new(ClearDecommissionRequest { pool_index });

                let response = client.clear_decommission(request).await?.into_inner();
                if !response.success {
@@ -1761,14 +1628,10 @@ impl PeerRestClient {
    pub async fn load_transition_tier_config(&self) -> Result<()> {
        match self.load_transition_tier_config_outcome().await {
            TierConfigReloadOutcome::Success => Ok(()),
-            // Only a reconnect-class failure says anything about the channel.
-            // `finalize_result` marks the peer offline and evicts its connection
-            // whenever the message looks network-like, and a peer that answered
-            // and rejected the apply can easily report one ("release RPC failed:
-            // transport error"). Routing those through here would gate a healthy,
-            // responding peer out of every unrelated RPC.
-            TierConfigReloadOutcome::TransientReconnect(err) => self.finalize_result(Err(err)).await,
-            TierConfigReloadOutcome::TransientRetrySameChannel(err) | TierConfigReloadOutcome::Terminal(err) => Err(err),
+            TierConfigReloadOutcome::TransientReconnect(err) | TierConfigReloadOutcome::TransientRetrySameChannel(err) => {
+                self.finalize_result(Err(err)).await
+            }
+            TierConfigReloadOutcome::Terminal(err) => Err(err),
        }
    }

@@ -1794,9 +1657,6 @@ impl PeerRestClient {
            Err(err) => return tier_config_reload_connection_outcome(err),
        };
        let mut request = Request::new(LoadTransitionTierConfigRequest {});
-        if let Err(err) = set_tonic_mutation_body_digest(&mut request) {
-            return TierConfigReloadOutcome::Terminal(Error::other(err));
-        }
        request.set_timeout(rustfs_protos::heal_control_execution_timeout());

        let response = match client.load_transition_tier_config(request).await {
@@ -1850,24 +1710,13 @@ fn is_tier_config_reload_connection_failure(err: &Error) -> bool {
    message_has_network_needle(&message)
 }

-/// Classifies a reload the peer answered but refused to apply.
-///
-/// The peer replied, so the channel is healthy and only the remote apply
-/// failed. Those failures are transient by nature: the reload reads the tier
-/// mutation intents and takes the distributed tier-config lock, both of which
-/// fail while any other node is restarting or while the lock quorum is briefly
-/// disturbed. Retiring the worker on the first such rejection leaves that peer
-/// pinned to the old configuration with nothing left to heal it, so it answers
-/// `TierNotFound` for a tier the rest of the cluster already committed until a
-/// second admin mutation happens to spawn a fresh worker.
-///
-/// Convergence is the whole point of this path, so a rejection is retried on
-/// the same channel. The worker's exponential backoff caps the cost at one
-/// reload every `TIER_CONFIG_RELOAD_RETRY_CAP`, and `Terminal` stays reachable
-/// for transport and gRPC status failures, which is where a genuinely
-/// unrecoverable peer surfaces.
 fn tier_config_reload_remote_failure(error_info: Option<String>) -> TierConfigReloadOutcome {
-    TierConfigReloadOutcome::TransientRetrySameChannel(Error::other(error_info.unwrap_or_default()))
+    let error_info = error_info.unwrap_or_default();
+    if matches!(error_info.as_str(), "errServerNotInitialized" | "ServerNotInitialized") {
+        TierConfigReloadOutcome::TransientRetrySameChannel(Error::other(error_info))
+    } else {
+        TierConfigReloadOutcome::Terminal(Error::other(error_info))
+    }
 }

 fn tier_config_reload_status_outcome(status: tonic::Status) -> TierConfigReloadOutcome {
@@ -1877,14 +1726,6 @@ fn tier_config_reload_status_outcome(status: tonic::Status) -> TierConfigReloadO
        TierConfigReloadOutcome::TransientReconnect(status.into())
    } else if status.code() == Code::Unknown && status.message().starts_with("Service was not ready:") {
        TierConfigReloadOutcome::TransientRetrySameChannel(status.into())
-    } else if status.code() == Code::Unknown
-        && is_tier_config_reload_connection_failure(&Error::other(status.message().to_string()))
-    {
-        // tonic reports a connection dropped mid-call as `Unknown` carrying the
-        // transport error text rather than as `Unavailable`, which is what a peer
-        // restarting under an active mutation produces. Reconnect and retry, so
-        // the restart does not permanently retire this peer's reload worker.
-        TierConfigReloadOutcome::TransientReconnect(status.into())
    } else {
        TierConfigReloadOutcome::Terminal(status.into())
    }
@@ -1894,13 +1735,9 @@ fn tier_config_reload_status_outcome(status: tonic::Status) -> TierConfigReloadO
 mod tests {
    use super::*;
    use crate::config::com::STORAGE_CLASS_SUB_SYS;
-    use crate::layout::{disks_layout::DisksLayout, endpoints::SetupType};
-    use rustfs_config::{ENV_KUBERNETES_SERVICE_HOST, ENV_LOCAL_ENDPOINT_HOST, ENV_STARTUP_TOPOLOGY_WAIT_MODE};
    use serde_json::Value;
-    use serial_test::serial;
    use std::io::{self, Write};
    use std::sync::{Arc, Mutex};
-    use temp_env::async_with_vars;
    use tracing_subscriber::{Registry, fmt::MakeWriter, layer::SubscriberExt};

    #[test]
@@ -2018,115 +1855,30 @@ mod tests {
    fn build_clients_from_slots_preserves_missing_remote_topology_slots() {
        let slots = vec![
            ("127.0.0.1:9000".to_string(), None, true),
-            (
-                "rustfs-1.invalid:9001".to_string(),
-                Some("http://rustfs-1.invalid:9001".to_string()),
-                false,
-            ),
-            ("rustfs-2.invalid".to_string(), Some("http://rustfs-2.invalid".to_string()), false),
+            ("127.0.0.1:9001".to_string(), Some("http://127.0.0.1:9001".to_string()), false),
            ("127.0.0.1:notaport".to_string(), Some("http://127.0.0.1:notaport".to_string()), false),
            ("127.0.0.1:9003".to_string(), None, false),
        ];

        let (remote, all, remote_topology_hosts) = PeerRestClient::build_clients_from_slots(slots);

-        assert_eq!(remote.len(), 4, "local node is excluded but remote slots are not compacted away");
-        assert_eq!(all.len(), 5, "all slots preserve the sorted cluster topology shape");
+        assert_eq!(remote.len(), 3, "local node is excluded but remote slots are not compacted away");
+        assert_eq!(all.len(), 4, "all slots preserve the sorted cluster topology shape");
        assert_eq!(
            remote_topology_hosts,
            vec![
-                "rustfs-1.invalid:9001".to_string(),
-                "rustfs-2.invalid".to_string(),
+                "127.0.0.1:9001".to_string(),
                "127.0.0.1:notaport".to_string(),
                "127.0.0.1:9003".to_string()
            ]
        );
-        let unresolved = remote[0]
-            .as_ref()
-            .expect("temporarily unresolved remote peer should retain a client");
-        assert_eq!(unresolved.host.to_string(), "rustfs-1.invalid:9001");
-        let default_port = remote[1]
-            .as_ref()
-            .expect("temporarily unresolved scheme-default remote peer should retain a client");
-        assert_eq!(default_port.host.to_string(), "rustfs-2.invalid");
-        assert_eq!(default_port.host.port, 80);
-        assert!(!default_port.host.is_port_set);
-        assert!(remote[2].is_none(), "unparseable remote peer should remain observable as a missing slot");
-        assert!(remote[3].is_none(), "missing grid host should remain observable as a missing slot");
+        assert!(remote[0].is_some(), "valid remote peer should get a client");
+        assert!(remote[1].is_none(), "unparseable remote peer should remain observable as a missing slot");
+        assert!(remote[2].is_none(), "missing grid host should remain observable as a missing slot");
        assert!(all[0].is_none(), "local node is represented by the local server_info row");
        assert!(all[1].is_some());
-        assert!(all[2].is_some());
+        assert!(all[2].is_none());
        assert!(all[3].is_none());
-        assert!(all[4].is_none());
-    }
-
-    #[test]
-    fn topology_host_parser_preserves_names_and_bracketed_ipv6() {
-        let domain = PeerRestClient::parse_topology_host("rustfs-1.invalid", "https://rustfs-1.invalid")
-            .expect("unresolved HTTPS topology host should parse without DNS");
-        assert_eq!(domain.to_string(), "rustfs-1.invalid");
-        assert_eq!(domain.port, 443);
-        assert!(!domain.is_port_set);
-
-        let ipv6 = PeerRestClient::parse_topology_host("[2001:db8::1]:9000", "http://[2001:db8::1]:9000")
-            .expect("bracketed IPv6 topology host should parse without changing its identity");
-        assert_eq!(ipv6.to_string(), "[2001:db8::1]:9000");
-
-        let default_port_ipv6 = PeerRestClient::parse_topology_host("[2001:db8::2]", "http://[2001:db8::2]")
-            .expect("scheme-default IPv6 topology host should parse without DNS");
-        assert_eq!(default_port_ipv6.to_string(), "[2001:db8::2]");
-        assert_eq!(default_port_ipv6.port, 80);
-        assert!(!default_port_ipv6.is_port_set);
-
-        assert!(PeerRestClient::parse_topology_host("peer.invalid:0", "http://peer.invalid:0").is_err());
-        assert!(PeerRestClient::parse_topology_host("peer-a.invalid:9000", "http://peer-b.invalid:9000").is_err());
-        assert!(PeerRestClient::parse_topology_host("peer.invalid:9000", "http://peer.invalid:9000/unexpected").is_err());
-    }
-
-    #[tokio::test]
-    #[serial]
-    async fn unresolved_default_port_endpoint_topology_retains_all_peer_clients() {
-        let volumes = (0..4)
-            .map(|index| format!("http://rustfs-{index}.invalid:80/data{index}"))
-            .collect::<Vec<_>>();
-        let layout = DisksLayout::from_volumes(&volumes).expect("distributed default-port topology should parse");
-
-        async_with_vars(
-            [
-                (ENV_STARTUP_TOPOLOGY_WAIT_MODE, Some("orchestrated")),
-                (ENV_LOCAL_ENDPOINT_HOST, Some("rustfs-0.invalid")),
-                (ENV_KUBERNETES_SERVICE_HOST, None),
-            ],
-            async {
-                let (server_pools, setup_type) = EndpointServerPools::create_server_endpoints("0.0.0.0:80", &layout)
-                    .await
-                    .expect("explicit local identity should avoid peer DNS during endpoint construction");
-                assert_eq!(setup_type, SetupType::DistErasure);
-
-                let (remote, all, remote_topology_hosts) =
-                    PeerRestClient::build_clients_from_slots(server_pools.peer_grid_host_slots_sorted());
-                assert_eq!(remote.len(), 3);
-                assert!(
-                    remote.iter().all(Option::is_some),
-                    "unresolved remote peers must retain reconnectable clients"
-                );
-                assert_eq!(all.len(), 4);
-                assert_eq!(all.iter().filter(|client| client.is_none()).count(), 1);
-                assert_eq!(remote_topology_hosts.len(), 3);
-                assert!(
-                    remote_topology_hosts.iter().all(|host| !host.contains(':')),
-                    "scheme-default ports must preserve the legacy topology identity"
-                );
-                assert!(
-                    remote
-                        .iter()
-                        .flatten()
-                        .all(|client| client.host.port == 80 && !client.host.is_port_set),
-                    "scheme-default peers must retain the effective dial port"
-                );
-            },
-        )
-        .await;
    }

    #[test]
@@ -2374,19 +2126,6 @@ mod tests {
            .expect("full refresh compatibility is guarded by its scanner preflight");
    }

-    #[test]
-    fn dynamic_kms_config_requires_versioned_peer_acknowledgement() {
-        let err = validate_signal_service_protocol(SERVICE_SIGNAL_RELOAD_DYNAMIC, KMS_SIGNAL_SUBSYSTEM, 0)
-            .expect_err("an unversioned peer must not claim KMS config convergence");
-        assert!(err.to_string().contains("does not support dynamic"));
-        validate_signal_service_protocol(
-            SERVICE_SIGNAL_RELOAD_DYNAMIC,
-            KMS_SIGNAL_SUBSYSTEM,
-            rustfs_protos::DYNAMIC_CONFIG_PROTOCOL_VERSION,
-        )
-        .expect("a current peer should support dynamic KMS config");
-    }
-
    #[test]
    fn peer_rest_client_marks_network_like_errors() {
        assert!(PeerRestClient::is_network_like_error(&Error::other("transport error")));
@@ -2540,12 +2279,9 @@ mod tests {
            tier_config_reload_status_outcome(tonic::Status::cancelled("request cancelled")),
            TierConfigReloadOutcome::Terminal(_)
        ));
-        // A peer that answered and then refused the apply is retried rather than
-        // retired: the channel is healthy, so the rejection reflects remote state
-        // that the next attempt can find healed.
        assert!(matches!(
            tier_config_reload_remote_failure(Some("backend unavailable".to_string())),
-            TierConfigReloadOutcome::TransientRetrySameChannel(_)
+            TierConfigReloadOutcome::Terminal(_)
        ));
        assert!(matches!(
            tier_config_reload_remote_failure(Some("errServerNotInitialized".to_string())),
@@ -2569,50 +2305,6 @@ mod tests {
        ));
    }

-    /// A tier mutation issued while another node restarts must still converge on
-    /// the nodes that stayed up. Those peers answer the reload RPC and reject the
-    /// apply, because reloading reads the tier mutation intents and takes the
-    /// distributed tier-config lock while the lock quorum is still disturbed.
-    /// Classifying those rejections as terminal retired the reload worker on its
-    /// first attempt and pinned the peer to the previous configuration, so it
-    /// served `TierNotFound` for an already-committed tier until an unrelated
-    /// second admin mutation spawned a new worker.
-    #[test]
-    fn tier_config_reload_retries_peers_that_reject_the_apply_mid_restart() {
-        for error_info in [
-            "Lock acquisition timeout for resource '.rustfs.sys/config/tier-config.bin.lock' after 5s",
-            "Resource '.rustfs.sys/config/tier-config.bin.lock' is already locked by node-3",
-            "Internal error: release RPC failed: transport error",
-            "save_config_with_opts: err: PreconditionFailed",
-            "erasure read quorum",
-        ] {
-            assert!(
-                matches!(
-                    tier_config_reload_remote_failure(Some(error_info.to_string())),
-                    TierConfigReloadOutcome::TransientRetrySameChannel(_)
-                ),
-                "a peer that rejected the apply must stay retryable so it converges: {error_info}"
-            );
-        }
-
-        // An absent error message is still a rejection, not a reason to stop.
-        assert!(matches!(
-            tier_config_reload_remote_failure(None),
-            TierConfigReloadOutcome::TransientRetrySameChannel(_)
-        ));
-
-        // tonic surfaces a connection dropped mid-call as `Unknown`, not `Unavailable`.
-        assert!(matches!(
-            tier_config_reload_status_outcome(tonic::Status::unknown("transport error")),
-            TierConfigReloadOutcome::TransientReconnect(_)
-        ));
-        // An `Unknown` that is not transport-shaped stays terminal.
-        assert!(matches!(
-            tier_config_reload_status_outcome(tonic::Status::unknown("peer response unknown")),
-            TierConfigReloadOutcome::Terminal(_)
-        ));
-    }
-
    #[tokio::test]
    async fn tier_config_reload_single_attempt_clears_offline_gate_without_redial() {
        let client = test_peer_client();
@@ -2689,22 +2381,6 @@ mod tests {
        }
    }

-    #[test]
-    fn remote_version_state_capability_decoder_fails_closed() {
-        let epoch = Uuid::new_v4();
-        let result = rustfs_protos::encode_remote_version_state_capability("node-a:9000", epoch.as_bytes())
-            .expect("small capability response should encode");
-        assert_eq!(
-            decode_remote_version_state_capability("node-a:9000", &result).expect("valid epoch should decode"),
-            epoch
-        );
-        assert!(decode_remote_version_state_capability("node-b:9000", &result).is_err());
-        assert!(decode_remote_version_state_capability("node-a:9000", &result[..result.len() - 1]).is_err());
-        let nil = rustfs_protos::encode_remote_version_state_capability("node-a:9000", Uuid::nil().as_bytes())
-            .expect("small capability response should encode");
-        assert!(decode_remote_version_state_capability("node-a:9000", &nil).is_err());
-    }
-
    struct TierMutationResponseFixture<'a> {
        version: u32,
        phase: TierMutationRpcPhase,
@@ -2929,31 +2605,6 @@ mod tests {
        assert!(!client.offline.load(Ordering::Acquire));
    }

-    #[tokio::test(start_paused = true)]
-    async fn dropped_peer_client_releases_and_stops_its_recovery_monitor() {
-        let client = test_peer_client();
-        client.offline.store(true, Ordering::Release);
-        client.recovery_running.store(true, Ordering::Release);
-        let offline = Arc::downgrade(&client.offline);
-        let recovery_running = Arc::downgrade(&client.recovery_running);
-        let handle = PeerRestClient::spawn_recovery_monitor(client.grid_host.clone(), offline.clone(), recovery_running.clone());
-        let started = tokio::time::Instant::now();
-
-        drop(client);
-
-        assert!(offline.upgrade().is_none(), "detached recovery must not retain offline state");
-        assert!(
-            recovery_running.upgrade().is_none(),
-            "detached recovery must not retain its running state"
-        );
-        handle.await.expect("recovery monitor should not panic");
-        assert_eq!(
-            tokio::time::Instant::now(),
-            started,
-            "recovery monitor should stop before advancing to its first delayed probe"
-        );
-    }
-
    #[tokio::test]
    async fn peer_rest_client_finalize_result_keeps_online_for_app_errors_mentioning_unavailable() {
        // Regression: application error text containing "unavailable" (a
@@ -3001,11 +2652,6 @@ mod tests {
                .with_span_list(true),
        );
        let _guard = tracing::subscriber::set_default(subscriber);
-        // The `recovery-monitor` callsite is shared with the production
-        // `mark_offline_and_spawn_recovery` path that sibling tests exercise from
-        // subscriber-less threads; without this the span can be cached as
-        // `Interest::never()` and silently degrade to `Span::none()`.
-        let _callsite_pin = crate::test_tracing::pin_callsite_interest_for_test();

        let client = test_peer_client();
        let span = tracing::info_span!("request-span", request_id = "req-peer-rest");
@@ -14,10 +14,8 @@

 use crate::bucket::metadata_sys;
 use crate::cluster::rpc::client::{
-    AuthenticatedChannel, TonicInterceptor, gen_tonic_signature_interceptor, is_network_like_disk_error,
-    node_service_time_out_client,
+    TonicInterceptor, gen_tonic_signature_interceptor, is_network_like_disk_error, node_service_time_out_client,
 };
-use crate::cluster::rpc::set_tonic_mutation_body_digest;
 use crate::disk::error::DiskError;
 use crate::disk::error::{Error, Result};
 use crate::disk::error_reduce::{BUCKET_OP_IGNORED_ERRS, is_all_buckets_not_found, reduce_write_quorum_errs};
@@ -41,84 +39,16 @@ use rustfs_protos::proto_gen::node_service::node_service_client::NodeServiceClie
 use rustfs_protos::proto_gen::node_service::{
    DeleteBucketRequest, GetBucketInfoRequest, HealBucketRequest, ListBucketRequest, MakeBucketRequest,
 };
-#[cfg(test)]
-use std::sync::{
-    Mutex as StdMutex,
-    atomic::{AtomicBool, Ordering},
-};
 use std::{collections::HashMap, fmt::Debug, sync::Arc, time::Duration};
-#[cfg(test)]
-use tokio::sync::Notify;
 use tokio::{net::TcpStream, sync::RwLock, time};
 use tokio_util::sync::CancellationToken;
 use tonic::Request;
 use tonic::service::interceptor::InterceptedService;
+use tonic::transport::Channel;
 use tracing::{debug, info, warn};

 type Client = Arc<Box<dyn PeerS3Client>>;

-#[cfg(test)]
-#[derive(Default)]
-pub(crate) struct DeleteBucketEmptyScanBarrier {
-    arrived: AtomicBool,
-    arrived_notify: Notify,
-    released: AtomicBool,
-    release_notify: Notify,
-}
-
-#[cfg(test)]
-impl DeleteBucketEmptyScanBarrier {
-    pub(crate) async fn wait_until_paused(&self) {
-        loop {
-            let notified = self.arrived_notify.notified();
-            if self.arrived.load(Ordering::Acquire) {
-                return;
-            }
-            notified.await;
-        }
-    }
-
-    pub(crate) fn release(&self) {
-        self.released.store(true, Ordering::Release);
-        self.release_notify.notify_waiters();
-    }
-
-    async fn pause(&self) {
-        self.arrived.store(true, Ordering::Release);
-        self.arrived_notify.notify_waiters();
-        loop {
-            let notified = self.release_notify.notified();
-            if self.released.load(Ordering::Acquire) {
-                return;
-            }
-            notified.await;
-        }
-    }
-}
-
-#[cfg(test)]
-static DELETE_BUCKET_EMPTY_SCAN_BARRIER: StdMutex<Option<Arc<DeleteBucketEmptyScanBarrier>>> = StdMutex::new(None);
-
-#[cfg(test)]
-pub(crate) fn install_delete_bucket_empty_scan_barrier() -> Arc<DeleteBucketEmptyScanBarrier> {
-    let barrier = Arc::new(DeleteBucketEmptyScanBarrier::default());
-    *DELETE_BUCKET_EMPTY_SCAN_BARRIER
-        .lock()
-        .expect("empty scan barrier lock should not be poisoned") = Some(barrier.clone());
-    barrier
-}
-
-#[cfg(test)]
-async fn pause_after_delete_bucket_empty_scan() {
-    let barrier = DELETE_BUCKET_EMPTY_SCAN_BARRIER
-        .lock()
-        .expect("empty scan barrier lock should not be poisoned")
-        .take();
-    if let Some(barrier) = barrier {
-        barrier.pause().await;
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct ScannerBucketListing {
    pub buckets: Vec<BucketInfo>,
@@ -159,22 +89,6 @@ fn reduce_pool_write_quorum_errs(per_pool_errs: &[Option<Error>]) -> Option<Erro
    reduce_write_quorum_errs(per_pool_errs, BUCKET_OP_IGNORED_ERRS, pool_write_quorum(per_pool_errs.len()))
 }

-fn resolve_heal_bucket_mode(opts: &mut HealOpts, pool_errs: &[Option<Error>]) -> Result<()> {
-    if opts.recreate {
-        return Ok(());
-    }
-    if let Some(err) = pool_errs
-        .iter()
-        .flatten()
-        .find(|err| **err != Error::DiskNotFound && **err != Error::VolumeNotFound)
-    {
-        return Err(err.clone());
-    }
-    opts.remove = is_all_buckets_not_found(pool_errs);
-    opts.recreate = !opts.remove;
-    Ok(())
-}
-
 #[async_trait]
 pub trait PeerS3Client: Debug + Sync + Send + 'static {
    async fn heal_bucket(&self, bucket: &str, opts: &HealOpts) -> Result<HealResultItem>;
@@ -245,7 +159,10 @@ impl S3PeerSys {
            pool_errs.push(reduce_pool_write_quorum_errs(&per_pool_errs));
        }

-        resolve_heal_bucket_mode(&mut opts, &pool_errs)?;
+        if !opts.recreate {
+            opts.remove = is_all_buckets_not_found(&pool_errs);
+            opts.recreate = !opts.remove;
+        }

        let mut futures = Vec::new();
        let heal_bucket_results = Arc::new(RwLock::new(vec![HealResultItem::default(); self.clients.len()]));
@@ -719,22 +636,24 @@ impl PeerS3Client for LocalPeerS3Client {
            return Err(Error::ErasureWriteQuorum);
        }

-        if opts.force_if_empty && !opts.force {
+        let force = if opts.force_if_empty && !opts.force {
            for disk in local_disks.iter() {
                if has_xlmeta_files(&disk.path().join(bucket)).await.map_err(Error::Io)? {
                    return Err(Error::VolumeNotEmpty);
                }
            }
-            #[cfg(test)]
-            pause_after_delete_bucket_empty_scan().await;
-        }
+            true
+        } else {
+            opts.force
+        };

        let mut futures = Vec::with_capacity(local_disks.len());

        for disk in local_disks.iter() {
-            // `force_if_empty` is validation-only. Passing it as force would let
-            // a PutObject committed after the scan be removed recursively.
-            futures.push(disk.delete_volume(bucket, opts.force));
+            // Non-force delete refuses a non-empty bucket (VolumeNotEmpty), which
+            // the recreate loop below turns into BucketNotEmpty; only an explicit
+            // force delete removes recursively (backlog#799 B1).
+            futures.push(disk.delete_volume(bucket, force));
        }

        let results = join_all(futures).await;
@@ -797,15 +716,6 @@ pub struct RemotePeerS3Client {
 }

 impl RemotePeerS3Client {
-    fn encode_delete_bucket_options(opts: &DeleteBucketOptions) -> Result<String> {
-        let mut remote_opts = opts.clone();
-        // Older peers promote `force_if_empty` to recursive force after their
-        // metadata scan. Keep this coordinator-only hint off the wire so a
-        // mixed-version delete fails closed on non-empty directory remnants.
-        remote_opts.force_if_empty = false;
-        serde_json::to_string(&remote_opts).map_err(Into::into)
-    }
-
    fn recovery_monitor_span(addr: &str) -> tracing::Span {
        tracing::info_span!(
            "recovery-monitor",
@@ -832,7 +742,7 @@ impl RemotePeerS3Client {
        client
    }

-    pub async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>> {
+    pub async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>> {
        node_service_time_out_client(&self.addr, TonicInterceptor::Signature(gen_tonic_signature_interceptor()))
            .await
            .map_err(|err| Error::other(format!("can not get client, err: {err}")))
@@ -1007,11 +917,10 @@ impl PeerS3Client for RemotePeerS3Client {
            || async {
                let options: String = serde_json::to_string(opts)?;
                let mut client = self.get_client().await?;
-                let mut request = Request::new(HealBucketRequest {
+                let request = Request::new(HealBucketRequest {
                    bucket: bucket.to_string(),
                    options,
                });
-                set_tonic_mutation_body_digest(&mut request)?;
                let response = client.heal_bucket(request).await?.into_inner();
                if !response.success {
                    return if let Some(err) = response.error {
@@ -1064,11 +973,10 @@ impl PeerS3Client for RemotePeerS3Client {
            || async {
                let options = serde_json::to_string(opts)?;
                let mut client = self.get_client().await?;
-                let mut request = Request::new(MakeBucketRequest {
+                let request = Request::new(MakeBucketRequest {
                    name: bucket.to_string(),
                    options,
                });
-                set_tonic_mutation_body_digest(&mut request)?;
                let response = client.make_bucket(request).await?.into_inner();

                if !response.success {
@@ -1116,14 +1024,13 @@ impl PeerS3Client for RemotePeerS3Client {
    async fn delete_bucket(&self, bucket: &str, opts: &DeleteBucketOptions) -> Result<()> {
        self.execute_with_timeout(
            || async {
-                let options = Self::encode_delete_bucket_options(opts)?;
+                let options = serde_json::to_string(opts)?;
                let mut client = self.get_client().await?;

-                let mut request = Request::new(DeleteBucketRequest {
+                let request = Request::new(DeleteBucketRequest {
                    bucket: bucket.to_string(),
                    options,
                });
-                set_tonic_mutation_body_digest(&mut request)?;
                let response = client.delete_bucket(request).await?.into_inner();
                if !response.success {
                    return if let Some(err) = response.error {
@@ -1490,49 +1397,6 @@ mod tests {
        }
    }

-    #[test]
-    fn remote_delete_bucket_options_fail_closed_for_legacy_peers() {
-        let encoded = RemotePeerS3Client::encode_delete_bucket_options(&DeleteBucketOptions {
-            no_lock: true,
-            no_recreate: true,
-            force_if_empty: true,
-            ..Default::default()
-        })
-        .expect("remote delete options should serialize");
-        let legacy_opts: DeleteBucketOptions =
-            serde_json::from_str(&encoded).expect("legacy peer should decode remote delete options");
-
-        assert!(legacy_opts.no_lock);
-        assert!(legacy_opts.no_recreate);
-        assert!(!legacy_opts.force);
-        assert!(!legacy_opts.force_if_empty);
-
-        let legacy_recursive_force = if legacy_opts.force_if_empty && !legacy_opts.force {
-            true
-        } else {
-            legacy_opts.force
-        };
-        assert!(
-            !legacy_recursive_force,
-            "legacy peer must not upgrade empty-only delete to recursive force"
-        );
-    }
-
-    #[test]
-    fn remote_delete_bucket_options_preserve_explicit_force() {
-        let encoded = RemotePeerS3Client::encode_delete_bucket_options(&DeleteBucketOptions {
-            force: true,
-            force_if_empty: true,
-            ..Default::default()
-        })
-        .expect("remote force-delete options should serialize");
-        let remote_opts: DeleteBucketOptions =
-            serde_json::from_str(&encoded).expect("remote peer should decode force-delete options");
-
-        assert!(remote_opts.force);
-        assert!(!remote_opts.force_if_empty);
-    }
-
    #[tokio::test]
    async fn test_execute_with_timeout_marks_remote_peer_faulty_on_network_like_error() {
        let client = test_remote_peer("http://peer-network-error:9000");
@@ -1690,54 +1554,6 @@ mod tests {
        reset_local_disk_test_state().await;
    }

-    #[tokio::test]
-    #[serial]
-    async fn local_peer_force_if_empty_preserves_unclassified_file_in_selected_pool() {
-        reset_local_disk_test_state().await;
-
-        let temp_dir = TempDir::new().expect("create temp dir for empty-only delete regression");
-        let disks = init_test_local_disks_for_pools(
-            &temp_dir,
-            &[(0, 1), (1, 1)],
-            "local-peer-force-if-empty-preserves-unclassified-file",
-        )
-        .await;
-        let bucket = "empty-only-delete-bucket";
-        let marker = "object/commit-marker";
-        let data = bytes::Bytes::from_static(b"committed object data");
-
-        disks[1]
-            .make_volume(bucket)
-            .await
-            .expect("bucket should be created in the selected pool");
-        disks[1]
-            .write_all(bucket, marker, data.clone())
-            .await
-            .expect("unclassified committed file should be written");
-
-        let err = LocalPeerS3Client::new_with_local_disks(None, Some(vec![1]), disks.clone())
-            .delete_bucket(
-                bucket,
-                &DeleteBucketOptions {
-                    force_if_empty: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect_err("empty-only delete must not recursively remove an unclassified file");
-
-        assert_eq!(err, Error::VolumeNotEmpty);
-        assert_eq!(
-            disks[1]
-                .read_all(bucket, marker)
-                .await
-                .expect("unclassified committed file should be preserved"),
-            data
-        );
-
-        reset_local_disk_test_state().await;
-    }
-
    #[tokio::test]
    #[serial]
    async fn heal_bucket_local_recreates_missing_bucket_volumes() {
@@ -1802,30 +1618,6 @@ mod tests {
        assert_eq!(err, Error::VolumeExists);
    }

-    #[test]
-    fn heal_bucket_mode_fails_closed_on_incomplete_topology() {
-        let mut opts = HealOpts::default();
-        assert_eq!(
-            resolve_heal_bucket_mode(&mut opts, &[Some(Error::ErasureWriteQuorum)]),
-            Err(Error::ErasureWriteQuorum)
-        );
-        assert!(!opts.recreate);
-        assert!(!opts.remove);
-    }
-
-    #[test]
-    fn heal_bucket_mode_distinguishes_deleted_and_partial_buckets() {
-        let mut deleted = HealOpts::default();
-        resolve_heal_bucket_mode(&mut deleted, &[Some(Error::VolumeNotFound)]).unwrap();
-        assert!(deleted.remove);
-        assert!(!deleted.recreate);
-
-        let mut partial = HealOpts::default();
-        resolve_heal_bucket_mode(&mut partial, &[None, Some(Error::VolumeNotFound)]).unwrap();
-        assert!(!partial.remove);
-        assert!(partial.recreate);
-    }
-
    #[tokio::test]
    async fn test_make_bucket_reduces_quorum_by_pool_participants() {
        let peer_sys = S3PeerSys {
@@ -13,8 +13,8 @@
 // limitations under the License.

 use crate::cluster::rpc::client::{
-    AuthenticatedChannel, TonicInterceptor, gen_tonic_signature_interceptor, is_network_like_disk_error,
-    node_service_time_out_client, node_service_time_out_client_for_class, node_service_time_out_client_no_auth,
+    TonicInterceptor, gen_tonic_signature_interceptor, is_network_like_disk_error, node_service_time_out_client,
+    node_service_time_out_client_for_class, node_service_time_out_client_no_auth,
 };
 use crate::cluster::rpc::http_auth::set_tonic_canonical_body_digest;
 use crate::cluster::rpc::internode_data_transport::{
@@ -25,7 +25,7 @@ use crate::disk::error::{Error, Result};
 use crate::disk::{
    BatchReadVersionReq, BatchReadVersionResp, CheckPartsResp, DeleteOptions, DiskAPI, DiskInfo, DiskInfoOptions, DiskLocation,
    DiskOption, FileInfoVersions, FileReader, FileWriter, PartTransactionAction, ReadMultipleReq, ReadMultipleResp, ReadOptions,
-    RenameDataResp, SnapshotLeaseToken, UpdateMetadataOpts, VolumeInfo, WalkDirOptions, batch_read_version_one_by_one,
+    RenameDataResp, UpdateMetadataOpts, VolumeInfo, WalkDirOptions, batch_read_version_one_by_one,
    disk_store::{
        DEFAULT_RUSTFS_DRIVE_ACTIVE_MONITORING, ENV_RUSTFS_DRIVE_ACTIVE_MONITORING, SKIP_IF_SUCCESS_BEFORE,
        get_drive_active_check_interval, get_drive_active_check_timeout, get_drive_disk_info_timeout, get_drive_list_dir_timeout,
@@ -50,9 +50,8 @@ use rustfs_protos::proto_gen::node_service::{
    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,
+    RenameFileRequest, SettlePartTransactionRequest, StatVolumeRequest, UpdateMetadataRequest, VerifyFileRequest,
+    WriteAllRequest, WriteMetadataRequest, node_service_client::NodeServiceClient,
 };
 use serde::{Serialize, de::DeserializeOwned};
 use std::{
@@ -71,7 +70,7 @@ use tokio::{
    time::timeout,
 };
 use tokio_util::sync::CancellationToken;
-use tonic::{Code, Request, service::interceptor::InterceptedService};
+use tonic::{Code, Request, service::interceptor::InterceptedService, transport::Channel};
 use tracing::{debug, trace, warn};
 use uuid::Uuid;

@@ -101,18 +100,6 @@ const LOG_COMPONENT_ECSTORE: &str = "ecstore";
 const LOG_SUBSYSTEM_REMOTE_DISK: &str = "remote_disk";
 const EVENT_REMOTE_DISK_HEALTH: &str = "remote_disk_health";
 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 snapshot_lease_token_from_response(response: SnapshotLeaseResponse) -> Result<SnapshotLeaseToken> {
-    if !response.success {
-        return Err(response.error.unwrap_or_default().into());
-    }
-    if response.protocol_version != SNAPSHOT_LEASE_PROTOCOL_VERSION {
-        return Err(Error::other("remote snapshot lease protocol is incompatible"));
-    }
-    SnapshotLeaseToken::from_slice(&response.token)
-}

 /// Bind a mutating disk RPC to its canonical body: the digest lands in the request metadata, and
 /// the signing interceptor folds it (plus a replay-protected nonce) into the v2 signature scope
@@ -1083,7 +1070,7 @@ impl RemoteDisk {
        internode_offline_bypass_reason(&self.addr).map(Error::other)
    }

-    async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>> {
+    async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>> {
        if let Some(err) = self.offline_bypass_error() {
            return Err(err);
        }
@@ -1096,7 +1083,7 @@ impl RemoteDisk {
    /// Routes onto the isolated bulk channel pool so large transfers cannot head-of-line block
    /// lock/health RPCs (grpc-optimization P1). Falls back to the control channel when isolation
    /// is disabled.
-    async fn get_bulk_client(&self) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>> {
+    async fn get_bulk_client(&self) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>> {
        if let Some(err) = self.offline_bypass_error() {
            return Err(err);
        }
@@ -1797,81 +1784,6 @@ impl DiskAPI for RemoteDisk {
        .await
    }

-    async fn acquire_snapshot_lease(&self, volume: &str, path: &str) -> Result<SnapshotLeaseToken> {
-        self.execute_with_timeout(
-            || async {
-                let mut client = self
-                    .get_client()
-                    .await
-                    .map_err(|err| Error::other(format!("can not get client, err: {err}")))?;
-                let mut request = Request::new(SnapshotLeaseRequest {
-                    disk: self.endpoint.to_string(),
-                    volume: volume.to_string(),
-                    path: path.to_string(),
-                    ttl_ms: u64::try_from(REMOTE_SNAPSHOT_LEASE_TTL.as_millis())
-                        .map_err(|_| Error::other("snapshot lease TTL cannot be represented"))?,
-                });
-                let canonical_body = rustfs_protos::canonical_snapshot_lease_request_body(request.get_ref());
-                attach_mutation_body_digest(&mut request, canonical_body, "acquire_snapshot_lease")?;
-                let response = client.acquire_snapshot_lease(request).await?.into_inner();
-                snapshot_lease_token_from_response(response)
-            },
-            get_max_timeout_duration(),
-        )
-        .await
-    }
-
-    async fn renew_snapshot_lease(&self, volume: &str, path: &str, token: SnapshotLeaseToken) -> Result<SnapshotLeaseToken> {
-        self.execute_with_timeout(
-            || async {
-                let mut client = self
-                    .get_client()
-                    .await
-                    .map_err(|err| Error::other(format!("can not get client, err: {err}")))?;
-                let mut request = Request::new(SnapshotLeaseRenewRequest {
-                    disk: self.endpoint.to_string(),
-                    volume: volume.to_string(),
-                    path: path.to_string(),
-                    token: token.as_bytes().to_vec().into(),
-                    ttl_ms: u64::try_from(REMOTE_SNAPSHOT_LEASE_TTL.as_millis())
-                        .map_err(|_| Error::other("snapshot lease TTL cannot be represented"))?,
-                });
-                let canonical_body = rustfs_protos::canonical_snapshot_lease_renew_request_body(request.get_ref());
-                attach_mutation_body_digest(&mut request, canonical_body, "renew_snapshot_lease")?;
-                let response = client.renew_snapshot_lease(request).await?.into_inner();
-                snapshot_lease_token_from_response(response)
-            },
-            get_max_timeout_duration(),
-        )
-        .await
-    }
-
-    async fn release_snapshot_lease(&self, volume: &str, path: &str, token: SnapshotLeaseToken) -> Result<()> {
-        self.execute_with_timeout(
-            || async {
-                let mut client = self
-                    .get_client()
-                    .await
-                    .map_err(|err| Error::other(format!("can not get client, err: {err}")))?;
-                let mut request = Request::new(SnapshotLeaseReleaseRequest {
-                    disk: self.endpoint.to_string(),
-                    volume: volume.to_string(),
-                    path: path.to_string(),
-                    token: token.as_bytes().to_vec().into(),
-                });
-                let canonical_body = rustfs_protos::canonical_snapshot_lease_release_request_body(request.get_ref());
-                attach_mutation_body_digest(&mut request, canonical_body, "release_snapshot_lease")?;
-                let response = client.release_snapshot_lease(request).await?.into_inner();
-                if !response.success {
-                    return Err(response.error.unwrap_or_default().into());
-                }
-                Ok(())
-            },
-            get_max_timeout_duration(),
-        )
-        .await
-    }
-
    #[tracing::instrument(level = "trace", skip_all)]
    async fn write_metadata(&self, _org_volume: &str, volume: &str, path: &str, fi: FileInfo) -> Result<()> {
        trace!(
@@ -3005,7 +2917,6 @@ mod tests {
    use crate::cluster::rpc::internode_data_transport::{InternodeDataTransportCapabilities, TcpHttpInternodeDataTransport};
    use crate::runtime::sources as runtime_sources;
    use serde_json::Value;
-    use serial_test::serial;
    use std::io::{self as std_io, Write};
    use std::pin::Pin;
    use std::sync::{Arc, Mutex, Mutex as StdMutex, Once};
@@ -3019,48 +2930,6 @@ mod tests {

    static INIT: Once = Once::new();

-    // `#[serial(internode_metrics)]` marks every test that observes
-    // `global_internode_metrics()`. Those counters are a process-wide singleton:
-    // some of these tests snapshot a counter, run one decode, and assert on the
-    // delta, while others deliberately record decode errors or call
-    // `reset_internode_metrics_for_test()`. Run concurrently in one process they
-    // corrupt each other's deltas — a sibling's error bumps the "no decode error"
-    // assertion off zero, and a sibling's reset can drive an `after > before`
-    // assertion backwards.
-    //
-    // The marker only takes effect under the `cargo test` fallback; nextest
-    // already isolates each test in its own process, so every test there gets its
-    // own copy of the counters (see `docs/testing/README.md`). Any new test that
-    // reads or mutates the global internode metrics belongs in this group.
-
-    #[test]
-    fn snapshot_lease_response_requires_current_protocol_and_valid_token() {
-        let token = SnapshotLeaseToken::new();
-        let response = SnapshotLeaseResponse {
-            success: true,
-            token: token.as_bytes().to_vec().into(),
-            protocol_version: SNAPSHOT_LEASE_PROTOCOL_VERSION,
-            error: None,
-        };
-        assert_eq!(snapshot_lease_token_from_response(response).unwrap(), token);
-
-        let incompatible = SnapshotLeaseResponse {
-            success: true,
-            token: token.as_bytes().to_vec().into(),
-            protocol_version: SNAPSHOT_LEASE_PROTOCOL_VERSION + 1,
-            error: None,
-        };
-        assert!(snapshot_lease_token_from_response(incompatible).is_err());
-
-        let malformed = SnapshotLeaseResponse {
-            success: true,
-            token: Bytes::from_static(b"not-a-uuid"),
-            protocol_version: SNAPSHOT_LEASE_PROTOCOL_VERSION,
-            error: None,
-        };
-        assert!(snapshot_lease_token_from_response(malformed).is_err());
-    }
-
    #[test]
    fn list_volumes_decode_rejects_a_malformed_entry() {
        let valid = serde_json::to_string(&VolumeInfo {
@@ -3321,7 +3190,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn read_multiple_response_decode_prefers_msgpack_payloads() {
        let endpoint = sample_remote_endpoint();
        let msgpack_resp = sample_read_multiple_resp("msgpack", b"binary");
@@ -3344,7 +3212,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn read_multiple_response_decode_falls_back_to_json_payloads() {
        let endpoint = sample_remote_endpoint();
        let json_resp = sample_read_multiple_resp("json", b"fallback");
@@ -3366,7 +3233,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn rename_data_response_accepts_legacy_json_without_decode_error() {
        crate::cluster::rpc::runtime_sources::reset_internode_metrics_for_test();
        let response = RenameDataResp {
@@ -3518,7 +3384,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn read_multiple_response_decode_reports_corrupt_msgpack_item() {
        let endpoint = sample_remote_endpoint();
        let response = ReadMultipleResponse {
@@ -3544,7 +3409,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn read_multiple_response_decode_reports_corrupt_json_item() {
        let endpoint = sample_remote_endpoint();
        let response = ReadMultipleResponse {
@@ -3585,7 +3449,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn batch_read_version_response_decode_prefers_msgpack_payloads() {
        let endpoint = sample_remote_endpoint();
        let msgpack_resp = sample_batch_read_version_resp(7, "msgpack-object", true);
@@ -3606,7 +3469,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn batch_read_version_response_rejects_invalid_success_metadata() {
        let endpoint = sample_remote_endpoint();
        let mut response_item = sample_batch_read_version_resp(0, "invalid-object", true);
@@ -3626,7 +3488,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn batch_read_version_response_decode_reports_corrupt_msgpack_item() {
        let endpoint = sample_remote_endpoint();
        let response = BatchReadVersionResponse {
@@ -3653,7 +3514,6 @@ mod tests {
    }

    #[test]
-    #[serial(internode_metrics)]
    fn batch_read_version_response_decode_reports_corrupt_json_item() {
        let endpoint = sample_remote_endpoint();
        let response = BatchReadVersionResponse {
@@ -4443,7 +4303,6 @@ mod tests {
    }

    #[tokio::test]
-    #[serial(internode_metrics)]
    async fn test_remote_disk_create_file_retries_once_on_retryable_open_write_error() {
        let transport = RetryingOpenWriteInternodeDataTransport::with_steps(vec![
            OpenWriteTestStep::Error(DiskError::from(rustfs_rio::new_test_internode_http_io_error(
@@ -4482,7 +4341,6 @@ mod tests {
    }

    #[tokio::test]
-    #[serial(internode_metrics)]
    async fn test_remote_disk_read_file_stream_retries_once_on_retryable_open_read_error() {
        // A transient reset-by-peer on a shard read during the read-after-write window must be
        // absorbed by one re-dial rather than eroding read quorum (issue #2761).
@@ -4814,11 +4672,9 @@ mod tests {
    async fn test_remote_disk_endpoints_with_different_schemes() {
        let test_cases = vec![
            ("http://server:9000", "server:9000"),
-            ("http://plain-server:80", "plain-server"),
-            ("http://plain-server", "plain-server"),
-            ("https://secure-server:443", "secure-server"),
+            ("https://secure-server:443", "secure-server"), // Default HTTPS port is omitted
            ("http://192.168.1.100:8080", "192.168.1.100:8080"),
-            ("https://secure-server", "secure-server"),
+            ("https://secure-server", "secure-server"), // No port specified
        ];

        for (url_str, expected_hostname) in test_cases {
@@ -5334,11 +5190,6 @@ mod tests {
                .with_span_list(true),
        );
        let _guard = tracing::subscriber::set_default(subscriber);
-        // The `recovery-monitor` span and the monitor's own log events are
-        // production callsites that sibling tests exercise from subscriber-less
-        // threads; without this they can be cached as `Interest::never()` and go
-        // silently missing here.
-        let _callsite_pin = crate::test_tracing::pin_callsite_interest_for_test();

        let endpoint = Endpoint {
            url: url::Url::parse("http://127.0.0.1:59996/data").expect("endpoint URL should parse"),
@@ -5393,11 +5244,6 @@ mod tests {
                .with_span_list(true),
        );
        let _guard = tracing::subscriber::set_default(subscriber);
-        // The `recovery-monitor` span and the monitor's own log events are
-        // production callsites that sibling tests exercise from subscriber-less
-        // threads; without this they can be cached as `Interest::never()` and go
-        // silently missing here.
-        let _callsite_pin = crate::test_tracing::pin_callsite_interest_for_test();

        let addr = "http://127.0.0.1:59997".to_string();
        let endpoint = Endpoint {
@@ -12,10 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-use crate::cluster::rpc::client::{
-    AuthenticatedChannel, TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client,
-};
-use crate::cluster::rpc::set_tonic_mutation_body_digest;
+use crate::cluster::rpc::client::{TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client};
 use async_trait::async_trait;
 use bytes::Bytes;
 use rustfs_lock::{
@@ -31,6 +28,7 @@ use std::time::Duration;
 use tokio::time::timeout;
 use tonic::Request;
 use tonic::service::interceptor::InterceptedService;
+use tonic::transport::Channel;
 use tracing::{debug, info, warn};

 /// Remote lock client implementation
@@ -79,7 +77,7 @@ impl RemoteClient {
        }
    }

-    pub async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<AuthenticatedChannel, TonicInterceptor>>> {
+    pub async fn get_client(&self) -> Result<NodeServiceClient<InterceptedService<Channel, TonicInterceptor>>> {
        // P3-2 offline bypass (now covering the lock path too): fast-fail a peer already marked
        // offline instead of paying the connect timeout, so dsync reaches quorum sooner. Does not
        // change quorum; the self-healing re-probe keeps the peer recoverable.
@@ -315,11 +313,10 @@ impl LockClient for RemoteClient {
        info!("remote acquire_exclusive for {}", request.resource);
        let mut client = self.get_client().await?;
        let resource_summary = request.resource.to_string();
-        let mut req = Request::new(GenerallyLockRequest {
+        let req = Request::new(GenerallyLockRequest {
            args: serde_json::to_string(&request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        set_tonic_mutation_body_digest(&mut req)?;

        let resp = match self.execute_rpc("lock", &resource_summary, client.lock(req)).await {
            Ok(resp) => resp.into_inner(),
@@ -350,7 +347,7 @@ impl LockClient for RemoteClient {

        let mut client = self.get_client().await?;
        let resource_summary = Self::summarize_resources(requests);
-        let mut req = Request::new(BatchGenerallyLockRequest {
+        let req = Request::new(BatchGenerallyLockRequest {
            args: requests
                .iter()
                .map(|request| {
@@ -358,7 +355,6 @@ impl LockClient for RemoteClient {
                })
                .collect::<Result<Vec<_>>>()?,
        });
-        set_tonic_mutation_body_digest(&mut req)?;

        let resp = match self
            .execute_rpc("lock_batch", &resource_summary, client.lock_batch(req))
@@ -399,8 +395,7 @@ impl LockClient for RemoteClient {
            .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?;
        let mut client = self.get_client().await?;
        let resource_summary = unlock_request.resource.to_string();
-        let mut req = Request::new(GenerallyLockRequest { args: request_string });
-        set_tonic_mutation_body_digest(&mut req)?;
+        let req = Request::new(GenerallyLockRequest { args: request_string });
        let resp = self
            .execute_rpc("release", &resource_summary, client.un_lock(req))
            .await?
@@ -419,7 +414,7 @@ impl LockClient for RemoteClient {
        let unlock_requests = lock_ids.iter().map(Self::create_unlock_request).collect::<Vec<_>>();
        let mut client = self.get_client().await?;
        let resource_summary = Self::summarize_resources(&unlock_requests);
-        let mut req = Request::new(BatchGenerallyLockRequest {
+        let req = Request::new(BatchGenerallyLockRequest {
            args: unlock_requests
                .iter()
                .map(|request| {
@@ -427,7 +422,6 @@ impl LockClient for RemoteClient {
                })
                .collect::<Result<Vec<_>>>()?,
        });
-        set_tonic_mutation_body_digest(&mut req)?;

        let resp = self
            .execute_rpc("release_batch", &resource_summary, client.un_lock_batch(req))
@@ -446,11 +440,10 @@ impl LockClient for RemoteClient {
        let refresh_request = Self::create_unlock_request(lock_id);
        let mut client = self.get_client().await?;
        let resource_summary = refresh_request.resource.to_string();
-        let mut req = Request::new(GenerallyLockRequest {
+        let req = Request::new(GenerallyLockRequest {
            args: serde_json::to_string(&refresh_request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        set_tonic_mutation_body_digest(&mut req)?;
        let resp = self
            .execute_rpc("refresh", &resource_summary, client.refresh(req))
            .await?
@@ -466,11 +459,10 @@ impl LockClient for RemoteClient {
        let force_request = Self::create_unlock_request(lock_id);
        let mut client = self.get_client().await?;
        let resource_summary = force_request.resource.to_string();
-        let mut req = Request::new(GenerallyLockRequest {
+        let req = Request::new(GenerallyLockRequest {
            args: serde_json::to_string(&force_request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        set_tonic_mutation_body_digest(&mut req)?;
        let resp = self
            .execute_rpc("force_release", &resource_summary, client.force_un_lock(req))
            .await?
@@ -491,11 +483,10 @@ impl LockClient for RemoteClient {
        let mut client = self.get_client().await?;

        // Try to acquire a very short-lived lock to test availability
-        let mut req = Request::new(GenerallyLockRequest {
+        let req = Request::new(GenerallyLockRequest {
            args: serde_json::to_string(&status_request)
                .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
        });
-        set_tonic_mutation_body_digest(&mut req)?;

        // Try exclusive lock first with very short timeout
        let resp = match self.execute_rpc("check_status", &resource_summary, client.lock(req)).await {
@@ -506,11 +497,10 @@ impl LockClient for RemoteClient {
        if resp.success {
            // If we successfully acquired the lock, the resource was free.
            // Immediately release it on a best-effort basis.
-            let mut release_req = Request::new(GenerallyLockRequest {
+            let release_req = Request::new(GenerallyLockRequest {
                args: serde_json::to_string(&status_request)
                    .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?,
            });
-            set_tonic_mutation_body_digest(&mut release_req)?;
            let _ = self
                .execute_rpc("check_status_release", &resource_summary, client.un_lock(release_req))
                .await;
@@ -53,14 +53,12 @@ use std::sync::LazyLock;
 use std::sync::{Arc, RwLock};
 use tokio::sync::{OwnedRwLockWriteGuard, RwLock as AsyncRwLock};
 use tracing::{debug, error, info, instrument, warn};
-use uuid::Uuid;

 pub const CONFIG_PREFIX: &str = "config";
 const SERVER_CONFIG_OBJECT: &str = "config/config.json";
-const CONFIG_TRANSACTION_LOCK_SUFFIX: &str = ".transaction.lock";

-// Server-config lock order: SERVER_CONFIG_LOCK -> transaction lock ->
-// SERVER_CONFIG_OBJECT. Readers and writers must never reverse this order.
+// Server-config lock order: SERVER_CONFIG_LOCK -> distributed namespace lock
+// for SERVER_CONFIG_OBJECT. Readers and writers must never reverse this order.
 static SERVER_CONFIG_LOCK: LazyLock<Arc<AsyncRwLock<()>>> = LazyLock::new(|| Arc::new(AsyncRwLock::new(())));

 fn config_task_join_error(operation: &'static str, error: tokio::task::JoinError) -> Error {
@@ -78,11 +76,8 @@ where
    T: Send + 'static,
 {
    tokio::spawn(async move {
-        // Lock order: SERVER_CONFIG_LOCK -> transaction lock -> object lock.
+        // Lock order: SERVER_CONFIG_LOCK -> namespace write lock.
        let _local_guard = SERVER_CONFIG_LOCK.write().await;
-        let transaction_lock = server_config_transaction_lock_path();
-        let transaction_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &transaction_lock).await?;
-        let _transaction_guard = transaction_lock.get_write_lock(get_lock_acquire_timeout()).await?;
        let namespace_lock = store.new_ns_lock(RUSTFS_META_BUCKET, SERVER_CONFIG_OBJECT).await?;
        let _write_guard = namespace_lock.get_write_lock(get_lock_acquire_timeout()).await?;
        Ok(operation().await)
@@ -101,11 +96,8 @@ where
    T: Send + 'static,
 {
    tokio::spawn(async move {
-        // Lock order: SERVER_CONFIG_LOCK -> transaction lock -> object lock.
+        // Lock order: SERVER_CONFIG_LOCK -> namespace read lock.
        let _local_guard = SERVER_CONFIG_LOCK.read().await;
-        let transaction_lock = server_config_transaction_lock_path();
-        let transaction_lock = store.new_ns_lock(RUSTFS_META_BUCKET, &transaction_lock).await?;
-        let _transaction_guard = transaction_lock.get_read_lock(get_lock_acquire_timeout()).await?;
        let namespace_lock = store.new_ns_lock(RUSTFS_META_BUCKET, SERVER_CONFIG_OBJECT).await?;
        let _read_guard = namespace_lock.get_read_lock(get_lock_acquire_timeout()).await?;
        Ok(operation().await)
@@ -575,21 +567,6 @@ where
 }

 pub async fn save_config_with_opts<S>(api: Arc<S>, file: &str, data: Vec<u8>, opts: &ObjectOptions) -> Result<()>
-where
-    S: ObjectIO<
-            Error = Error,
-            RangeSpec = HTTPRangeSpec,
-            HeaderMap = HeaderMap,
-            ObjectOptions = ObjectOptions,
-            ObjectInfo = ObjectInfo,
-            GetObjectReader = GetObjectReader,
-            PutObjectReader = PutObjReader,
-        >,
-{
-    save_config_with_opts_and_metadata(api, file, data, opts).await.map(|_| ())
-}
-
-async fn save_config_with_opts_and_metadata<S>(api: Arc<S>, file: &str, data: Vec<u8>, opts: &ObjectOptions) -> Result<ObjectInfo>
 where
    S: ObjectIO<
            Error = Error,
@@ -602,13 +579,11 @@ where
        >,
 {
    let mut put_data = PutObjReader::from_vec(data);
-    match api.put_object(RUSTFS_META_BUCKET, file, &mut put_data, opts).await {
-        Ok(object_info) => Ok(object_info),
-        Err(err) => {
-            error!("save_config_with_opts: err: {:?}, file: {}", err, file);
-            Err(err)
-        }
+    if let Err(err) = api.put_object(RUSTFS_META_BUCKET, file, &mut put_data, opts).await {
+        error!("save_config_with_opts: err: {:?}, file: {}", err, file);
+        return Err(err);
    }
+    Ok(())
 }

 fn new_server_config() -> Config {
@@ -619,12 +594,8 @@ async fn new_and_save_server_config<S>(api: Arc<S>) -> Result<Config>
 where
    S: EcstoreObjectIO + StorageAdminApi + NamespaceLocking<Error = Error, NamespaceLock = rustfs_lock::NamespaceLockWrapper>,
 {
-    let snapshot = read_server_config_snapshot(api.clone()).await?;
-    if snapshot.object_exists() {
-        return Ok(snapshot.config.clone());
-    }
    let cfg = new_server_config();
-    save_server_config_snapshot(api, &cfg, &snapshot).await?;
+    save_server_config(api, &cfg).await?;

    Ok(cfg)
 }
@@ -646,10 +617,6 @@ pub fn server_config_path() -> String {
    SERVER_CONFIG_OBJECT.to_string()
 }

-fn server_config_transaction_lock_path() -> String {
-    format!("{}{CONFIG_TRANSACTION_LOCK_SUFFIX}", server_config_path())
-}
-
 fn storage_class_kvs_mut(cfg: &mut Config) -> &mut KVS {
    let sub_cfg = cfg.0.entry(STORAGE_CLASS_SUB_SYS.to_string()).or_insert_with(|| {
        let mut section = HashMap::new();
@@ -852,9 +819,6 @@ fn apply_external_scalar_config_map(
    let Some(config_value) = root.get(descriptor.subsystem_key) else {
        return Ok(false);
    };
-    if descriptor.subsystem_key == HEAL_SUB_SYS && config_value.is_null() {
-        return Ok(false);
-    }
    let overrides = decode_scalar_config_value(config_value, descriptor)?;

    if overrides.is_empty() {
@@ -1499,142 +1463,21 @@ fn build_audit_object(cfg: &Config) -> Map<String, Value> {
    build_target_object(cfg, &audit_target_descriptors())
 }

-fn sync_rendered_target_instance(existing: Value, rendered: Option<&Value>, valid_keys: &[&str]) -> Option<Value> {
-    match existing {
-        Value::Object(mut instance) => {
-            for key in valid_keys {
-                instance.remove(*key);
-            }
-            if let Some(Value::Object(rendered)) = rendered {
-                instance.extend(rendered.clone());
-            }
-            (!instance.is_empty()).then_some(Value::Object(instance))
-        }
-        Value::Array(entries) => {
-            let mut pending = rendered
-                .and_then(Value::as_object)
-                .map(|rendered| {
-                    rendered
-                        .iter()
-                        .filter_map(|(key, value)| parse_target_scalar_value(key, value).map(|value| (key.clone(), value)))
-                        .collect::<HashMap<_, _>>()
-                })
-                .unwrap_or_default();
-            let mut updated = Vec::with_capacity(entries.len().saturating_add(pending.len()));
-            for entry in entries {
-                let Some(entry_obj) = entry.as_object() else {
-                    updated.push(entry);
-                    continue;
-                };
-                let Some(key) = entry_obj.get("key").and_then(Value::as_str) else {
-                    updated.push(entry);
-                    continue;
-                };
-                if !valid_keys.contains(&key) {
-                    updated.push(entry);
-                    continue;
-                }
-                let Some(value) = pending.remove(key) else {
-                    continue;
-                };
-                let mut entry_obj = entry_obj.clone();
-                entry_obj.insert("value".to_string(), Value::String(value));
-                updated.push(Value::Object(entry_obj));
-            }
-            updated.extend(rendered_scalar_config_kvs_entries(&pending));
-            (!updated.is_empty()).then_some(Value::Array(updated))
-        }
-        value if rendered.is_none() => Some(value),
-        _ => rendered.cloned(),
-    }
-}
-
 fn sync_rendered_target_object(
    target_obj: &mut Map<String, Value>,
    rendered_target: &Map<String, Value>,
    descriptors: &[TargetConfigDescriptor],
 ) {
    for descriptor in descriptors {
-        let existing = target_obj.remove(descriptor.external_key);
-        let alias = target_obj.remove(descriptor.subsystem_key);
-        let mut section = existing
-            .or(alias)
-            .and_then(|value| value.as_object().cloned())
-            .unwrap_or_default();
-        let rendered = rendered_target.get(descriptor.external_key).and_then(Value::as_object);
-
-        if is_target_instance_shorthand(&section, descriptor.valid_keys) {
-            let has_named_instances = rendered.is_some_and(|instances| instances.keys().any(|name| name != "default"));
-            if !has_named_instances {
-                if let Some(section) = sync_rendered_target_instance(
-                    Value::Object(section),
-                    rendered.and_then(|instances| instances.get("default")),
-                    descriptor.valid_keys,
-                ) {
-                    target_obj.insert(descriptor.external_key.to_string(), section);
-                }
-                continue;
+        match rendered_target.get(descriptor.external_key) {
+            Some(Value::Object(v)) => {
+                target_obj.insert(descriptor.external_key.to_string(), Value::Object(v.clone()));
+                target_obj.remove(descriptor.subsystem_key);
            }
-
-            let mut nested = Map::new();
-            if let Some(default) = sync_rendered_target_instance(
-                Value::Object(section),
-                rendered.and_then(|instances| instances.get("default")),
-                descriptor.valid_keys,
-            ) {
-                nested.insert("default".to_string(), default);
+            _ => {
+                target_obj.remove(descriptor.external_key);
+                target_obj.remove(descriptor.subsystem_key);
            }
-            if let Some(rendered) = rendered {
-                for (instance_name, instance) in rendered {
-                    if instance_name != "default" {
-                        nested.insert(instance_name.clone(), instance.clone());
-                    }
-                }
-            }
-            if !nested.is_empty() {
-                target_obj.insert(descriptor.external_key.to_string(), Value::Object(nested));
-            }
-            continue;
-        }
-
-        if let Some(default_alias) = section.remove(DEFAULT_DELIMITER) {
-            if let Some(default) = section.get_mut("default") {
-                if let Some(alias) = sync_rendered_target_instance(default_alias, None, descriptor.valid_keys) {
-                    match (default, alias) {
-                        (Value::Object(default), Value::Object(alias)) => {
-                            for (key, value) in alias {
-                                default.entry(key).or_insert(value);
-                            }
-                        }
-                        (Value::Array(default), Value::Array(alias)) => default.extend(alias),
-                        _ => {}
-                    }
-                }
-            } else {
-                section.insert("default".to_string(), default_alias);
-            }
-        }
-
-        let mut merged = Map::new();
-        for (instance_name, instance) in section {
-            if let Some(instance) = sync_rendered_target_instance(
-                instance,
-                rendered.and_then(|instances| instances.get(&instance_name)),
-                descriptor.valid_keys,
-            ) {
-                merged.insert(instance_name, instance);
-            }
-        }
-        if let Some(rendered) = rendered {
-            for (instance_name, instance) in rendered {
-                if !merged.contains_key(instance_name) {
-                    merged.insert(instance_name.clone(), instance.clone());
-                }
-            }
-        }
-
-        if !merged.is_empty() {
-            target_obj.insert(descriptor.external_key.to_string(), Value::Object(merged));
        }
    }
 }
@@ -1653,14 +1496,6 @@ fn encode_server_config_blob(cfg: &Config, seed: Option<&[u8]>) -> Result<Vec<u8
        Some(Value::Object(v)) => v,
        _ => Map::new(),
    };
-    for key in [
-        storageclass::CLASS_STANDARD,
-        storageclass::CLASS_RRS,
-        storageclass::OPTIMIZE,
-        storageclass::INLINE_BLOCK,
-    ] {
-        sc_obj.remove(key);
-    }
    for (k, v) in build_storageclass_object(cfg) {
        sc_obj.insert(k, v);
    }
@@ -1668,10 +1503,7 @@ fn encode_server_config_blob(cfg: &Config, seed: Option<&[u8]>) -> Result<Vec<u8
    root.remove("storage_class");

    for descriptor in [scanner_config_descriptor(), heal_config_descriptor()] {
-        let mut existing = root.remove(descriptor.subsystem_key);
-        if descriptor.subsystem_key == HEAL_SUB_SYS && existing.as_ref().is_some_and(Value::is_null) {
-            existing = None;
-        }
+        let existing = root.remove(descriptor.subsystem_key);
        let rendered = build_scalar_config_object(cfg, descriptor);
        if let Some(config_value) = sync_rendered_scalar_config_value(existing, &rendered, descriptor)? {
            root.insert(descriptor.subsystem_key.to_string(), config_value);
@@ -1728,7 +1560,6 @@ fn is_standard_object_server_config(data: &[u8]) -> bool {
    matches!(root.get("version"), Some(Value::String(v)) if !v.trim().is_empty())
        && matches!(root.get("storageclass"), Some(Value::Object(_)))
        && !root.contains_key("storage_class")
-        && !matches!(root.get(HEAL_SUB_SYS), Some(Value::Null))
 }

 fn configs_semantically_equal(lhs: &Config, rhs: &Config) -> bool {
@@ -1762,7 +1593,7 @@ where
            FileInfo = FileInfo,
            ObjectToDelete = ObjectToDelete,
            DeletedObject = DeletedObject,
-        > + NamespaceLocking<Error = Error, NamespaceLock = rustfs_lock::NamespaceLockWrapper>,
+        >,
 {
    if let Some(decrypt) = &decrypt_fn {
        register_server_config_decrypt_fn(decrypt.clone());
@@ -1770,7 +1601,14 @@ where

    let config_file = server_config_path();
    match api
-        .get_object_info(RUSTFS_META_BUCKET, &config_file, &ObjectOptions::default())
+        .get_object_info(
+            RUSTFS_META_BUCKET,
+            &config_file,
+            &ObjectOptions {
+                no_lock: true,
+                ..Default::default()
+            },
+        )
        .await
    {
        Ok(_) => {
@@ -1786,6 +1624,7 @@ where

    let opts = ObjectOptions {
        max_parity: true,
+        no_lock: true,
        ..Default::default()
    };

@@ -1838,33 +1677,7 @@ where
        }
    };

-    let snapshot = match read_server_config_snapshot(api.clone()).await {
-        Ok(snapshot) => snapshot,
-        Err(err) => {
-            warn!("recheck target server config failed, skip migration: {:?}", err);
-            return;
-        }
-    };
-    if snapshot.object_exists() {
-        debug!("server config was created while legacy migration was preparing, skip migration");
-        return;
-    }
-
-    match save_config_with_opts(
-        api,
-        &config_file,
-        normalized,
-        &ObjectOptions {
-            max_parity: true,
-            http_preconditions: Some(HTTPPreconditions {
-                if_none_match: Some("*".to_string()),
-                ..Default::default()
-            }),
-            ..Default::default()
-        },
-    )
-    .await
-    {
+    match save_config(api, &config_file, normalized).await {
        Ok(()) => {
            info!("Migrated compatible server config from legacy metadata bucket");
        }
@@ -1956,13 +1769,8 @@ where
 {
    let config_file = server_config_path();

-    // Try to read the configuration file.
-    let data = if namespace_lock_held {
-        read_config_no_lock(api.clone(), &config_file).await
-    } else {
-        read_config(api.clone(), &config_file).await
-    };
-    match data {
+    // Try to read the configuration file
+    match read_config_no_lock(api.clone(), &config_file).await {
        Ok(data) => read_server_config(api, &data, namespace_lock_held).await,
        Err(Error::ConfigNotFound) => handle_missing_config(api, "Read the main configuration", namespace_lock_held).await,
        Err(err) => handle_config_read_error(err, &config_file),
@@ -1979,12 +1787,7 @@ where
        warn!("Received empty configuration data, try to reread from '{}'", config_file);

        // Try to read the configuration again
-        let data = if namespace_lock_held {
-            read_config_no_lock(api.clone(), &config_file).await
-        } else {
-            read_config(api.clone(), &config_file).await
-        };
-        match data {
+        match read_config_no_lock(api.clone(), &config_file).await {
            Ok(cfg_data) => {
                let cfg = decode_persisted_server_config(&cfg_data)?;
                return Ok(cfg.merge());
@@ -2233,16 +2036,11 @@ pub struct ServerConfigSnapshot {
    raw: Option<Vec<u8>>,
    seed: Option<Vec<u8>>,
    etag: Option<String>,
-    generation: Option<Uuid>,
    _local_guard: OwnedRwLockWriteGuard<()>,
    _guard: rustfs_lock::NamespaceLockGuard,
 }

 impl ServerConfigSnapshot {
-    pub fn object_exists(&self) -> bool {
-        self.raw.is_some()
-    }
-
    pub fn ensure_lock_held(&self) -> Result<()> {
        if self._guard.is_lock_lost() {
            return Err(Error::other("server config transaction lock was lost"));
@@ -2253,34 +2051,12 @@ impl ServerConfigSnapshot {
    pub fn is_lock_lost(&self) -> bool {
        self._guard.is_lock_lost()
    }
-
-    pub fn generation(&self) -> Option<Uuid> {
-        self.generation
-    }
 }

-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ServerConfigSaveResult {
-    persisted: bool,
-    generation: Option<Uuid>,
-}
-
-impl ServerConfigSaveResult {
-    pub fn persisted(&self) -> bool {
-        self.persisted
-    }
-
-    pub fn generation(&self) -> Option<Uuid> {
-        self.generation
-    }
-}
-
-/// Read a server config transaction snapshot while holding a dedicated
-/// transaction lock. The config object's normal namespace lock remains
-/// available to fence reads and the conditional write at commit time.
-/// The transaction guard remains live until the snapshot is dropped,
-/// serializing persistence and history ordering across admin nodes. Runtime
-/// state is reloaded from the durable object after this guard is released.
+/// Read a server config transaction snapshot while holding the same local and
+/// distributed write locks used by every other server-config writer. Internal
+/// reads and the later conditional write use no-lock object I/O; the guards
+/// remain live until the snapshot is dropped.
 pub async fn read_server_config_snapshot<S>(api: Arc<S>) -> Result<ServerConfigSnapshot>
 where
    S: ObjectIO<
@@ -2295,10 +2071,12 @@ where
 {
    let config_file = server_config_path();
    let local_guard = SERVER_CONFIG_LOCK.clone().write_owned().await;
-    let transaction_lock = server_config_transaction_lock_path();
-    let lock = api.new_ns_lock(RUSTFS_META_BUCKET, &transaction_lock).await?;
+    let lock = api.new_ns_lock(RUSTFS_META_BUCKET, &config_file).await?;
    let guard = lock.get_write_lock(get_lock_acquire_timeout()).await?;
-    let read_options = ObjectOptions::default();
+    let read_options = ObjectOptions {
+        no_lock: true,
+        ..Default::default()
+    };
    match read_config_with_metadata_inner(api, &config_file, &read_options, true).await {
        Ok((raw, object_info)) => {
            let (config, seed) = decode_persisted_server_config_with_seed(&raw)?;
@@ -2307,7 +2085,6 @@ where
                raw: Some(raw),
                seed: Some(seed),
                etag: object_info.etag,
-                generation: object_info.data_dir.filter(|generation| !generation.is_nil()),
                _local_guard: local_guard,
                _guard: guard,
            })
@@ -2317,7 +2094,6 @@ where
            raw: None,
            seed: None,
            etag: None,
-            generation: None,
            _local_guard: local_guard,
            _guard: guard,
        }),
@@ -2332,27 +2108,6 @@ where
 /// lock, so a concurrent update or transaction lease loss cannot commit an
 /// unfenced overwrite.
 pub async fn save_server_config_snapshot<S>(api: Arc<S>, cfg: &Config, snapshot: &ServerConfigSnapshot) -> Result<bool>
-where
-    S: ObjectIO<
-            Error = Error,
-            RangeSpec = HTTPRangeSpec,
-            HeaderMap = HeaderMap,
-            ObjectOptions = ObjectOptions,
-            ObjectInfo = ObjectInfo,
-            GetObjectReader = GetObjectReader,
-            PutObjectReader = PutObjReader,
-        > + NamespaceLocking<Error = Error, NamespaceLock = rustfs_lock::NamespaceLockWrapper>,
-{
-    save_server_config_snapshot_with_generation(api, cfg, snapshot)
-        .await
-        .map(|result| result.persisted())
-}
-
-pub async fn save_server_config_snapshot_with_generation<S>(
-    api: Arc<S>,
-    cfg: &Config,
-    snapshot: &ServerConfigSnapshot,
-) -> Result<ServerConfigSaveResult>
 where
    S: ObjectIO<
            Error = Error,
@@ -2371,19 +2126,13 @@ where
        && configs_semantically_equal(&snapshot.config, cfg)
    {
        debug!("server config unchanged and already in standard object shape, skip write");
-        return Ok(ServerConfigSaveResult {
-            persisted: false,
-            generation: snapshot.generation(),
-        });
+        return Ok(false);
    }

    let data = encode_server_config_blob(cfg, snapshot.seed.as_deref())?;
    if snapshot.raw.as_deref().is_some_and(|current| current == data.as_slice()) {
        debug!("server config bytes unchanged after encode, skip write");
-        return Ok(ServerConfigSaveResult {
-            persisted: false,
-            generation: snapshot.generation(),
-        });
+        return Ok(false);
    }

    let http_preconditions = if snapshot.raw.is_some() {
@@ -2403,22 +2152,19 @@ where
        }
    };

-    snapshot.ensure_lock_held()?;
-    let object_info = save_config_with_opts_and_metadata(
+    save_config_with_opts(
        api,
        &config_file,
        data,
        &ObjectOptions {
            max_parity: true,
+            no_lock: true,
            http_preconditions: Some(http_preconditions),
            ..Default::default()
        },
    )
    .await?;
-    Ok(ServerConfigSaveResult {
-        persisted: true,
-        generation: object_info.data_dir.filter(|generation| !generation.is_nil()),
-    })
+    Ok(true)
 }

 /// Saves the server config while an upper layer holds the namespace write
@@ -2555,9 +2301,8 @@ mod tests {
    use super::{
        SERVER_CONFIG_LOCK, ServerConfigSnapshot, apply_dynamic_config_for_sub_sys_with, config_task_join_error,
        configs_semantically_equal, decode_server_config_blob, encode_server_config_blob, is_standard_object_server_config,
-        lookup_configs, new_and_save_server_config, read_config, read_config_preserve_empty, read_config_with_metadata,
-        read_config_without_migrate, read_server_config_snapshot, save_server_config, save_server_config_snapshot,
-        save_server_config_snapshot_with_generation, server_config_transaction_lock_path, storage_class_kvs_mut,
+        lookup_configs, read_config, read_config_preserve_empty, read_config_with_metadata, read_config_without_migrate,
+        read_server_config_snapshot, save_server_config, save_server_config_snapshot, server_config_path, storage_class_kvs_mut,
    };
    use crate::config::{audit, heal, notify, oidc, scanner};
    use crate::disk::endpoint::Endpoint;
@@ -2566,9 +2311,7 @@ mod tests {
    use crate::object_api::{GetObjectReader, ObjectInfo, ObjectOptions, PutObjReader};
    use crate::runtime::sources as runtime_sources;
    use crate::set_disk::SetDisks;
-    use crate::storage_api_contracts::{
-        admin::StorageAdminApi, namespace::NamespaceLocking as _, object::HTTPPreconditions, range::HTTPRangeSpec,
-    };
+    use crate::storage_api_contracts::{admin::StorageAdminApi, namespace::NamespaceLocking as _, range::HTTPRangeSpec};
    use http::HeaderMap;
    use rustfs_config::audit::{AUDIT_AMQP_SUB_SYS, AUDIT_KAFKA_SUB_SYS, AUDIT_MQTT_SUB_SYS, AUDIT_WEBHOOK_SUB_SYS};
    use rustfs_config::notify::{
@@ -3361,85 +3104,6 @@ mod tests {
        );
    }

-    #[test]
-    fn root_heal_null_decodes_as_no_override_and_is_canonicalized_on_save() {
-        let seed = br#"{
-          "version":"33",
-          "storageclass":{"standard":"","rrs":""},
-          "heal":null,
-          "future_root":{"mode":"keep"},
-          "openid":{"default":{
-            "config_url":"https://issuer.example/.well-known/openid-configuration",
-            "client_id":"console",
-            "client_secret":"oidc-secret",
-            "future_provider_control":"keep"
-          }},
-          "notify":{"webhook":{"primary":{
-            "enable":true,
-            "endpoint":"https://notify.example/hook",
-            "auth_token":"notify-secret",
-            "future_notify_control":"keep"
-          }}},
-          "logger":{"webhook":{"primary":{
-            "enable":true,
-            "endpoint":"https://audit.example/hook",
-            "auth_token":"audit-secret",
-            "future_audit_control":"keep"
-          }}}
-        }"#;
-
-        let cfg = decode_server_config_blob(seed).expect("root heal null should mean no persisted override");
-        assert!(cfg.get_value(HEAL_SUB_SYS, DEFAULT_DELIMITER).is_none());
-        assert!(!is_standard_object_server_config(seed));
-
-        let encoded = encode_server_config_blob(&cfg, Some(seed)).expect("legacy seed should canonicalize on an authorized save");
-        let value: Value = serde_json::from_slice(&encoded).expect("canonical config should be valid JSON");
-        assert!(value.get(HEAL_SUB_SYS).is_none());
-        assert_eq!(value["future_root"]["mode"].as_str(), Some("keep"));
-        assert_eq!(value["openid"]["default"]["client_secret"].as_str(), Some("oidc-secret"));
-        assert_eq!(value["openid"]["default"]["future_provider_control"].as_str(), Some("keep"));
-        assert_eq!(value["notify"]["webhook"]["primary"]["auth_token"].as_str(), Some("notify-secret"));
-        assert_eq!(value["notify"]["webhook"]["primary"]["future_notify_control"].as_str(), Some("keep"));
-        assert_eq!(value["logger"]["webhook"]["primary"]["auth_token"].as_str(), Some("audit-secret"));
-        assert_eq!(value["logger"]["webhook"]["primary"]["future_audit_control"].as_str(), Some("keep"));
-        assert!(is_standard_object_server_config(&encoded));
-    }
-
-    #[test]
-    fn invalid_scalar_and_nested_null_config_shapes_remain_rejected() {
-        let invalid_sections = [
-            r#""scanner":null"#,
-            r#""heal":"""#,
-            r#""heal":false"#,
-            r#""heal":0"#,
-            r#""heal":{"default":null}"#,
-            r#""heal":{"_":null}"#,
-            r#""heal":{"bitrot_cycle":null}"#,
-            r#""heal":[{"key":"bitrot_cycle","value":null}]"#,
-        ];
-
-        for section in invalid_sections {
-            let input = format!(r#"{{"version":"33","storageclass":{{"standard":"","rrs":""}},{section}}}"#);
-            let err = decode_server_config_blob(input.as_bytes()).expect_err("invalid scalar shape must remain rejected");
-            assert!(
-                err.to_string().contains("expected"),
-                "invalid section {section} returned an unrelated error: {err}"
-            );
-        }
-    }
-
-    #[test]
-    fn valid_heal_object_and_kvs_array_shapes_remain_accepted() {
-        let empty_object = br#"{"version":"33","storageclass":{"standard":"","rrs":""},"heal":{}}"#;
-        let cfg = decode_server_config_blob(empty_object).expect("empty heal object should decode as no override");
-        assert!(cfg.get_value(HEAL_SUB_SYS, DEFAULT_DELIMITER).is_none());
-
-        let kvs_array =
-            br#"{"version":"33","storageclass":{"standard":"","rrs":""},"heal":[{"key":"bitrot_cycle","value":"off"}]}"#;
-        let cfg = decode_server_config_blob(kvs_array).expect("heal KVS array should decode");
-        assert!(cfg.get_value(HEAL_SUB_SYS, DEFAULT_DELIMITER).is_some());
-    }
-
    #[test]
    fn scanner_update_preserves_unknown_root_and_oidc_provider_fields() {
        let seed = br#"{
@@ -3467,171 +3131,6 @@ mod tests {
        assert_eq!(value["openid"]["default"]["client_id"].as_str(), Some("console"));
    }

-    #[test]
-    fn storageclass_reset_removes_stale_inline_block_from_seed() {
-        let seed = br#"{
-          "version":"33",
-          "storageclass":{
-            "standard":"EC:2",
-            "rrs":"EC:1",
-            "optimize":"availability",
-            "inline_block":"64KiB",
-            "future_storage_control":"keep"
-          }
-        }"#;
-
-        let encoded = encode_server_config_blob(&Config::new(), Some(seed)).expect("storageclass reset should encode");
-        let value: Value = serde_json::from_slice(&encoded).expect("encoded config should be valid json");
-        let storageclass = value["storageclass"].as_object().expect("storageclass object");
-
-        assert!(storageclass.get(crate::config::storageclass::INLINE_BLOCK).is_none());
-        assert_eq!(storageclass["future_storage_control"].as_str(), Some("keep"));
-    }
-
-    #[test]
-    fn target_update_preserves_unknown_fields_without_restoring_removed_instances() {
-        let seed = br#"{
-          "version":"33",
-          "storageclass":{"standard":"","rrs":""},
-          "notify":{"webhook":{
-            "primary":{
-              "enable":true,
-              "endpoint":"https://notify.example/old",
-              "auth_token":"notify-secret",
-              "future_control":"keep"
-            },
-            "removed":{"enable":true,"endpoint":"https://notify.example/removed"},
-            "retained":{"enable":true,"endpoint":"https://notify.example/retained","future_control":"keep"},
-            "enable":{"enable":true,"endpoint":"https://notify.example/named-enable","future_control":"keep"}
-          }}
-        }"#;
-        let mut cfg = decode_server_config_blob(seed).expect("target seed should decode");
-        let webhook = cfg
-            .0
-            .get_mut(NOTIFY_WEBHOOK_SUB_SYS)
-            .expect("notify webhook subsystem should exist");
-        webhook
-            .get_mut("primary")
-            .expect("primary target should exist")
-            .insert(rustfs_config::WEBHOOK_ENDPOINT.to_string(), "https://notify.example/new".to_string());
-        webhook.remove("removed");
-        webhook.remove("retained");
-
-        let encoded = encode_server_config_blob(&cfg, Some(seed)).expect("target update should encode");
-        let value: Value = serde_json::from_slice(&encoded).expect("encoded config should be valid json");
-        let webhook = value["notify"]["webhook"].as_object().expect("webhook section");
-
-        assert_eq!(webhook["primary"]["endpoint"].as_str(), Some("https://notify.example/new"));
-        assert_eq!(webhook["primary"]["auth_token"].as_str(), Some("notify-secret"));
-        assert_eq!(webhook["primary"]["future_control"].as_str(), Some("keep"));
-        assert!(webhook.get("removed").is_none());
-        assert_eq!(webhook["retained"]["future_control"].as_str(), Some("keep"));
-        assert!(webhook["retained"].get("enable").is_none());
-        assert!(webhook["retained"].get("endpoint").is_none());
-        assert_eq!(webhook["enable"]["endpoint"].as_str(), Some("https://notify.example/named-enable"));
-        assert_eq!(webhook["enable"]["future_control"].as_str(), Some("keep"));
-    }
-
-    #[test]
-    fn shorthand_target_update_preserves_shape_and_unknown_nested_fields() {
-        let seed = br#"{
-          "version":"33",
-          "storageclass":{"standard":"","rrs":""},
-          "notify":{"webhook":{
-            "enable":true,
-            "endpoint":"https://notify.example/old",
-            "future_control":{"endpoint":"leave-untouched","mode":"keep"}
-          }}
-        }"#;
-        let mut cfg = decode_server_config_blob(seed).expect("shorthand target should decode");
-        cfg.0
-            .get_mut(NOTIFY_WEBHOOK_SUB_SYS)
-            .and_then(|targets| targets.get_mut(DEFAULT_DELIMITER))
-            .expect("default webhook target should exist")
-            .insert(rustfs_config::WEBHOOK_ENDPOINT.to_string(), "https://notify.example/new".to_string());
-
-        let encoded = encode_server_config_blob(&cfg, Some(seed)).expect("shorthand target update should encode");
-        let value: Value = serde_json::from_slice(&encoded).expect("encoded config should be valid json");
-        let webhook = value["notify"]["webhook"].as_object().expect("webhook shorthand object");
-
-        assert_eq!(webhook["endpoint"].as_str(), Some("https://notify.example/new"));
-        assert!(webhook.get("default").is_none());
-        assert_eq!(webhook["future_control"]["endpoint"].as_str(), Some("leave-untouched"));
-        assert_eq!(webhook["future_control"]["mode"].as_str(), Some("keep"));
-        let decoded = decode_server_config_blob(&encoded).expect("updated shorthand target should remain decodable");
-        assert_eq!(
-            decoded
-                .get_value(NOTIFY_WEBHOOK_SUB_SYS, DEFAULT_DELIMITER)
-                .expect("updated default webhook target")
-                .get(rustfs_config::WEBHOOK_ENDPOINT),
-            "https://notify.example/new"
-        );
-    }
-
-    #[test]
-    fn target_kvs_update_preserves_unknown_entries_and_attributes() {
-        let seed = br#"{
-          "version":"33",
-          "storageclass":{"standard":"","rrs":""},
-          "notify":{"webhook":{"primary":[
-            {"key":"enable","value":"on","hidden_if_empty":false},
-            {"key":"endpoint","value":"https://notify.example/old","future_attribute":"keep-endpoint"},
-            {"key":"future_control","value":"keep","future_attribute":"keep-control"}
-          ]}}
-        }"#;
-        let mut cfg = decode_server_config_blob(seed).expect("target KVS seed should decode");
-        cfg.0
-            .get_mut(NOTIFY_WEBHOOK_SUB_SYS)
-            .and_then(|targets| targets.get_mut("primary"))
-            .expect("primary webhook target should exist")
-            .insert(rustfs_config::WEBHOOK_ENDPOINT.to_string(), "https://notify.example/new".to_string());
-
-        let encoded = encode_server_config_blob(&cfg, Some(seed)).expect("target KVS update should encode");
-        let value: Value = serde_json::from_slice(&encoded).expect("encoded config should be valid json");
-        let entries = value["notify"]["webhook"]["primary"]
-            .as_array()
-            .expect("target KVS shape should be preserved");
-        let endpoint = entries
-            .iter()
-            .find(|entry| entry["key"].as_str() == Some(rustfs_config::WEBHOOK_ENDPOINT))
-            .expect("endpoint entry should remain");
-        let future = entries
-            .iter()
-            .find(|entry| entry["key"].as_str() == Some("future_control"))
-            .expect("unknown target entry should remain");
-
-        assert_eq!(endpoint["value"].as_str(), Some("https://notify.example/new"));
-        assert_eq!(endpoint["future_attribute"].as_str(), Some("keep-endpoint"));
-        assert_eq!(future["value"].as_str(), Some("keep"));
-        assert_eq!(future["future_attribute"].as_str(), Some("keep-control"));
-    }
-
-    #[test]
-    fn target_default_alias_is_canonicalized_without_losing_unknown_fields() {
-        let seed = br#"{
-          "version":"33",
-          "storageclass":{"standard":"","rrs":""},
-          "notify":{"webhook":{
-            "_":{"enable":false,"endpoint":"https://notify.example/alias","future_alias":"keep"},
-            "default":{"enable":true,"endpoint":"https://notify.example/default","future_default":"keep"}
-          }}
-        }"#;
-        let cfg = decode_server_config_blob(seed).expect("dual default aliases should decode");
-        let expected_endpoint = cfg
-            .get_value(NOTIFY_WEBHOOK_SUB_SYS, DEFAULT_DELIMITER)
-            .expect("default webhook target should exist")
-            .get(rustfs_config::WEBHOOK_ENDPOINT);
-
-        let encoded = encode_server_config_blob(&cfg, Some(seed)).expect("default alias should canonicalize");
-        let value: Value = serde_json::from_slice(&encoded).expect("encoded config should be valid json");
-        let webhook = value["notify"]["webhook"].as_object().expect("webhook section");
-
-        assert!(webhook.get(DEFAULT_DELIMITER).is_none());
-        assert_eq!(webhook["default"]["endpoint"].as_str(), Some(expected_endpoint.as_str()));
-        assert_eq!(webhook["default"]["future_alias"].as_str(), Some("keep"));
-        assert_eq!(webhook["default"]["future_default"].as_str(), Some("keep"));
-    }
-
    #[test]
    fn test_scanner_config_changes_are_semantically_significant() {
        let baseline = Config::new();
@@ -4625,7 +4124,6 @@ mod tests {

    /// What reads of the config object currently return.
    enum RecoveryReadState {
-        Missing,
        Blob(Vec<u8>),
        QuorumError,
    }
@@ -4638,7 +4136,6 @@ mod tests {
        heal_calls: AtomicUsize,
        write_calls: AtomicUsize,
        last_put_no_lock: AtomicBool,
-        last_put_preconditions: Mutex<Option<HTTPPreconditions>>,
        revision: AtomicUsize,
        drive_counts: Vec<usize>,
        lock_manager: Arc<rustfs_lock::GlobalLockManager>,
@@ -4653,7 +4150,6 @@ mod tests {
                heal_calls: AtomicUsize::new(0),
                write_calls: AtomicUsize::new(0),
                last_put_no_lock: AtomicBool::new(false),
-                last_put_preconditions: Mutex::new(None),
                revision: AtomicUsize::new(1),
                drive_counts: vec![2],
                lock_manager: Arc::new(rustfs_lock::GlobalLockManager::new()),
@@ -4710,7 +4206,6 @@ mod tests {
            _opts: &ObjectOptions,
        ) -> Result<GetObjectReader> {
            let data = match &*self.state.lock().expect("state lock poisoned") {
-                RecoveryReadState::Missing => return Err(Error::ConfigNotFound),
                RecoveryReadState::Blob(data) => data.clone(),
                RecoveryReadState::QuorumError => return Err(Error::ErasureReadQuorum),
            };
@@ -4718,9 +4213,6 @@ mod tests {
                size: data.len() as i64,
                actual_size: data.len() as i64,
                etag: Some(format!("config-{}", self.revision.load(Ordering::SeqCst))),
-                data_dir: Some(uuid::Uuid::from_u128(
-                    u128::try_from(self.revision.load(Ordering::SeqCst)).expect("test revision should fit in u128"),
-                )),
                ..Default::default()
            };
            Ok(GetObjectReader {
@@ -4739,19 +4231,15 @@ mod tests {
            opts: &ObjectOptions,
        ) -> Result<ObjectInfo> {
            let current_etag = format!("config-{}", self.revision.load(Ordering::SeqCst));
-            let object_exists = matches!(&*self.state.lock().expect("state lock poisoned"), RecoveryReadState::Blob(_));
            if let Some(preconditions) = &opts.http_preconditions
-                && (preconditions
-                    .if_match_value()
-                    .is_some_and(|etag| !object_exists || etag != current_etag)
-                    || (object_exists && preconditions.if_none_match_value() == Some("*")))
+                && (preconditions.if_match_value().is_some_and(|etag| etag != current_etag)
+                    || preconditions.if_none_match_value() == Some("*"))
            {
                return Err(Error::PreconditionFailed);
            }
            let mut body = Vec::new();
            data.stream.read_to_end(&mut body).await?;
            self.last_put_no_lock.store(opts.no_lock, Ordering::SeqCst);
-            *self.last_put_preconditions.lock().expect("preconditions lock poisoned") = opts.http_preconditions.clone();
            self.write_calls.fetch_add(1, Ordering::SeqCst);
            *self.state.lock().expect("state lock poisoned") = RecoveryReadState::Blob(body.clone());
            let revision = self.revision.fetch_add(1, Ordering::SeqCst) + 1;
@@ -4759,7 +4247,6 @@ mod tests {
                size: i64::try_from(body.len()).expect("test config should fit in i64"),
                actual_size: i64::try_from(body.len()).expect("test config should fit in i64"),
                etag: Some(format!("config-{revision}")),
-                data_dir: Some(uuid::Uuid::from_u128(u128::try_from(revision).expect("test revision should fit in u128"))),
                ..Default::default()
            })
        }
@@ -4797,18 +4284,10 @@ mod tests {
            .expect("scanner-only config change should be persisted");

        assert_eq!(store.write_calls.load(Ordering::SeqCst), 1);
-        assert!(!store.last_put_no_lock.load(Ordering::SeqCst));
-        let preconditions = store
-            .last_put_preconditions
-            .lock()
-            .expect("preconditions lock poisoned")
-            .clone()
-            .expect("existing config update must be conditional");
-        assert_eq!(preconditions.if_match_value(), Some("config-1"));
-        assert_eq!(preconditions.if_none_match_value(), None);
+        assert!(store.last_put_no_lock.load(Ordering::SeqCst));
        assert_eq!(
            store.lock_resources.lock().expect("lock resources mutex poisoned").as_slice(),
-            &[server_config_transaction_lock_path()]
+            &[server_config_path()]
        );
        let decoded = read_config_without_migrate(store)
            .await
@@ -4822,73 +4301,6 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn server_config_snapshot_save_returns_committed_generation() {
-        let baseline = encode_server_config_blob(&Config::new(), None).expect("baseline config should encode");
-        let store = Arc::new(RecoveryMockStore::new(RecoveryReadState::Blob(baseline), None));
-        let snapshot = read_server_config_snapshot(store.clone())
-            .await
-            .expect("server config snapshot");
-
-        let result = save_server_config_snapshot_with_generation(store, &config_with_scanner_cycle("61"), &snapshot)
-            .await
-            .expect("conditional config save");
-
-        assert!(result.persisted());
-        assert_eq!(result.generation(), Some(uuid::Uuid::from_u128(2)));
-    }
-
-    #[tokio::test]
-    async fn missing_server_config_is_created_with_if_none_match() {
-        let store = Arc::new(RecoveryMockStore::new(RecoveryReadState::Missing, None));
-        let cfg = config_with_scanner_cycle("61");
-
-        save_server_config(store.clone(), &cfg)
-            .await
-            .expect("missing config should be created conditionally");
-
-        assert_eq!(store.write_calls.load(Ordering::SeqCst), 1);
-        assert!(!store.last_put_no_lock.load(Ordering::SeqCst));
-        let preconditions = store
-            .last_put_preconditions
-            .lock()
-            .expect("preconditions lock poisoned")
-            .clone()
-            .expect("missing config create must be conditional");
-        assert_eq!(preconditions.if_match_value(), None);
-        assert_eq!(preconditions.if_none_match_value(), Some("*"));
-        let persisted = read_config_without_migrate(store)
-            .await
-            .expect("created config should reload");
-        assert_eq!(
-            persisted
-                .get_value(SCANNER_SUB_SYS, DEFAULT_DELIMITER)
-                .expect("persisted scanner config")
-                .get(SCANNER_CYCLE),
-            "61"
-        );
-    }
-
-    #[tokio::test]
-    async fn missing_config_initialization_recheck_preserves_concurrent_config() {
-        let existing = config_with_scanner_cycle("73");
-        let baseline = encode_server_config_blob(&existing, None).expect("existing config should encode");
-        let store = Arc::new(RecoveryMockStore::new(RecoveryReadState::Blob(baseline), None));
-
-        let observed = new_and_save_server_config(store.clone())
-            .await
-            .expect("initialization recheck should return the config created by another writer");
-
-        assert_eq!(store.write_calls.load(Ordering::SeqCst), 0);
-        assert_eq!(
-            observed
-                .get_value(SCANNER_SUB_SYS, DEFAULT_DELIMITER)
-                .expect("concurrent scanner config")
-                .get(SCANNER_CYCLE),
-            "73"
-        );
-    }
-
    #[tokio::test]
    async fn stale_server_config_snapshot_cannot_overwrite_newer_update() {
        let baseline = encode_server_config_blob(&Config::new(), None).expect("baseline config should encode");
@@ -4945,7 +4357,7 @@ mod tests {
        let lock = rustfs_lock::NamespaceLock::new("server-config-lease-loss".to_string(), client.clone());
        let guard = lock
            .lock_guard(
-                rustfs_lock::ObjectKey::new(crate::disk::RUSTFS_META_BUCKET, server_config_transaction_lock_path()),
+                rustfs_lock::ObjectKey::new(crate::disk::RUSTFS_META_BUCKET, server_config_path()),
                "server-config-lease-loss",
                std::time::Duration::from_secs(1),
                std::time::Duration::from_millis(120),
@@ -4960,7 +4372,6 @@ mod tests {
            raw: Some(baseline.clone()),
            seed: None,
            etag: Some("config-0".to_string()),
-            generation: Some(uuid::Uuid::from_u128(1)),
            _local_guard: local_guard,
            _guard: guard,
        };
@@ -37,9 +37,7 @@ use crate::{
    runtime::instance::{InstanceContext, bootstrap_ctx},
    runtime::sources as runtime_sources,
    set_disk::{PreparedGetObjectMetadata, SetDisks},
-    store::init_format::{
-        check_format_erasure_values, load_format_erasure_all, save_format_file, select_format_erasure_in_quorum,
-    },
+    store::init_format::{check_format_erasure_values, get_format_erasure_in_quorum, load_format_erasure_all, save_format_file},
 };
 use futures::{
    future::join_all,
@@ -949,7 +947,7 @@ impl crate::storage_api_contracts::heal::HealOperations for Sets {

    #[tracing::instrument(skip(self))]
    async fn heal_format(&self, dry_run: bool) -> Result<(HealResultItem, Option<Error>)> {
-        let (disks, init_errs) = init_storage_disks_with_errors(
+        let (disks, _) = init_storage_disks_with_errors(
            &self.endpoints.endpoints,
            &DiskOption {
                cleanup: false,
@@ -957,36 +955,15 @@ impl crate::storage_api_contracts::heal::HealOperations for Sets {
            },
        )
        .await;
-        let (formats, mut errs) = load_format_erasure_all(&disks, true).await;
-        for (err, init_err) in errs.iter_mut().zip(init_errs) {
-            if init_err.is_some() {
-                *err = init_err;
-            }
-        }
-        if errs.iter().any(|err| {
-            matches!(
-                err,
-                Some(DiskError::InconsistentDisk | DiskError::CorruptedFormat | DiskError::CorruptedBackend)
-            )
-        }) {
-            return Ok((HealResultItem::default(), Some(StorageError::CorruptedFormat)));
-        }
+        let (formats, errs) = load_format_erasure_all(&disks, true).await;
        if let Err(err) = check_format_erasure_values(&formats, self.set_drive_count) {
            info!("failed to check formats erasure values: {}", err);
            return Ok((HealResultItem::default(), Some(err)));
        }
-        let (ref_format, quorum_members) = match select_format_erasure_in_quorum(&formats, 0) {
-            Ok((format, members)) if format.shared_identity() == self.format.shared_identity() => (format, members),
-            Ok(_) => return Ok((HealResultItem::default(), Some(StorageError::CorruptedFormat))),
+        let ref_format = match get_format_erasure_in_quorum(&formats) {
+            Ok(format) => format,
            Err(err) => return Ok((HealResultItem::default(), Some(err))),
        };
-        if formats
-            .iter()
-            .zip(quorum_members)
-            .any(|(format, member)| format.is_some() && !member)
-        {
-            return Ok((HealResultItem::default(), Some(StorageError::CorruptedFormat)));
-        }
        let mut res = HealResultItem {
            heal_item_type: HealItemType::Metadata.to_string(),
            detail: "disk-format".to_string(),
@@ -1008,6 +985,11 @@ impl crate::storage_api_contracts::heal::HealOperations for Sets {
            return Ok((res, Some(StorageError::NoHealRequired)));
        }

+        // if !self.format.eq(&ref_format) {
+        //     info!("format ({:?}) not eq ref_format ({:?})", self.format, ref_format);
+        //     return Ok((res, Some(Error::new(DiskError::CorruptedFormat))));
+        // }
+
        let (new_format_sets, _) = new_heal_format_sets(&ref_format, self.set_count, self.set_drive_count, &formats, &errs);
        if !dry_run {
            let mut tmp_new_formats = vec![None; self.set_count * self.set_drive_count];
@@ -1316,7 +1298,7 @@ mod tests {
        assert_eq!(result, (Some(3), Some(1), Some(0)));
    }

-    async fn two_set_test_sets() -> (Vec<tempfile::TempDir>, Arc<Sets>) {
+    async fn multipart_listing_test_sets() -> (Vec<tempfile::TempDir>, Arc<Sets>) {
        let format = FormatV3::new(2, 2);
        let mut temp_dirs = Vec::new();
        let mut all_endpoints = Vec::new();
@@ -1357,8 +1339,8 @@ mod tests {
                    Arc::new(RwLock::new(disks)),
                    2,
                    1,
-                    set_index,
                    0,
+                    set_index,
                    endpoints,
                    format.clone(),
                    vec![Arc::new(LocalClient::new()), Arc::new(LocalClient::new())],
@@ -1391,114 +1373,11 @@ mod tests {
        (temp_dirs, sets)
    }

-    #[tokio::test]
-    async fn set_format_heal_accepts_quorum_from_a_nonzero_set() {
-        let (_temp_dirs, sets) = two_set_test_sets().await;
-
-        let (result, err) = sets.disk_set[1]
-            .heal_format(false)
-            .await
-            .expect("the second erasure set should load its own format quorum");
-
-        assert!(matches!(err, Some(StorageError::NoHealRequired)), "unexpected heal result: {err:?}");
-        assert_eq!(result.disk_count, 2);
-        assert_eq!(result.set_count, 1);
-    }
-
-    #[tokio::test]
-    async fn format_heal_rejects_foreign_majorities_at_set_and_pool_scopes() {
-        let (_temp_dirs, _canonical_format, sets) = setup_heal_format_sets(2, true).await;
-        let set_disks = set_level_heal_view(&sets).await;
-
-        let (_, set_err) = set_disks
-            .heal_format(false)
-            .await
-            .expect("set format heal should report a typed mismatch");
-        assert!(
-            matches!(set_err, Some(StorageError::CorruptedFormat)),
-            "foreign set majority must not replace the cached format: {set_err:?}"
-        );
-
-        let (_, pool_err) = sets
-            .heal_format(false)
-            .await
-            .expect("pool format heal should report a typed mismatch");
-        assert!(
-            matches!(pool_err, Some(StorageError::CorruptedFormat)),
-            "foreign pool majority must not replace the cached format: {pool_err:?}"
-        );
-    }
-
-    #[tokio::test]
-    async fn pool_format_heal_rejects_a_wrong_slot_minority() {
-        let (_temp_dirs, canonical_format, sets) = setup_heal_format_sets(3, false).await;
-        let mut poisoned_format = canonical_format.clone();
-        poisoned_format.erasure.this = canonical_format.erasure.sets[0][0];
-        replace_heal_test_format(&sets, 2, &poisoned_format).await;
-        let probe_err = new_disk(
-            &sets.endpoints.endpoints.as_ref()[2],
-            &DiskOption {
-                cleanup: false,
-                health_check: false,
-            },
-        )
-        .await
-        .expect_err("a wrong-slot local format must fail disk initialization");
-        assert_eq!(probe_err, DiskError::InconsistentDisk);
-
-        let (_, pool_err) = sets
-            .heal_format(false)
-            .await
-            .expect("pool format heal should report a typed slot mismatch");
-        assert!(
-            matches!(pool_err, Some(StorageError::CorruptedFormat)),
-            "a wrong-slot minority must not be reported as no-heal-required: {pool_err:?}"
-        );
-        assert_eq!(
-            read_heal_test_format(&sets, 2).await,
-            poisoned_format,
-            "format heal must not overwrite a wrong-slot disk"
-        );
-    }
-
-    #[tokio::test]
-    async fn format_heal_rejects_a_foreign_minority_at_set_and_pool_scopes() {
-        let (_temp_dirs, canonical_format, sets) = setup_heal_format_sets(3, false).await;
-        let mut poisoned_format = canonical_format.clone();
-        poisoned_format.id = Uuid::new_v4();
-        poisoned_format.erasure.this = poisoned_format.erasure.sets[0][2];
-        replace_heal_test_format(&sets, 2, &poisoned_format).await;
-        let set_disks = set_level_heal_view(&sets).await;
-
-        let (_, set_err) = set_disks
-            .heal_format(false)
-            .await
-            .expect("set format heal should report a typed identity mismatch");
-        assert!(
-            matches!(set_err, Some(StorageError::CorruptedFormat)),
-            "a foreign minority must not be reported as no-heal-required: {set_err:?}"
-        );
-
-        let (_, pool_err) = sets
-            .heal_format(false)
-            .await
-            .expect("pool format heal should report a typed identity mismatch");
-        assert!(
-            matches!(pool_err, Some(StorageError::CorruptedFormat)),
-            "a foreign minority must not be reported as no-heal-required: {pool_err:?}"
-        );
-        assert_eq!(
-            read_heal_test_format(&sets, 2).await,
-            poisoned_format,
-            "format heal must not overwrite a foreign disk"
-        );
-    }
-
    #[tokio::test(flavor = "multi_thread")]
    #[serial]
    async fn list_multipart_uploads_merges_all_sets_without_pagination_loss() {
        let _setup_type_guard = SetupTypeGuard::switch_to(SetupType::Erasure).await;
-        let (_temp_dirs, sets) = two_set_test_sets().await;
+        let (_temp_dirs, sets) = multipart_listing_test_sets().await;
        let bucket = format!("multipart-list-{}", Uuid::new_v4().simple());
        sets.make_bucket(&bucket, &MakeBucketOptions::default())
            .await
@@ -1737,15 +1616,11 @@ mod tests {
    // formatting the first `num_formatted` of them against a shared reference
    // format and leaving the rest unformatted. Returns the live TempDir handles
    // (must be kept alive), the reference format, and the assembled `Sets`.
-    // `disk_set` is intentionally empty: these tests only exercise paths that
-    // return before pool-level healing delegates into a set.
-    async fn setup_heal_format_sets(num_formatted: usize, foreign_identity: bool) -> (Vec<tempfile::TempDir>, FormatV3, Sets) {
+    // `disk_set` is intentionally empty: these tests only drive `heal_format`
+    // with `dry_run == true`, which never touches `disk_set`.
+    async fn setup_heal_format_sets(num_formatted: usize) -> (Vec<tempfile::TempDir>, FormatV3, Sets) {
        const SET_DRIVE_COUNT: usize = 3;
        let ref_format = FormatV3::new(1, SET_DRIVE_COUNT);
-        let mut stored_format = ref_format.clone();
-        if foreign_identity {
-            stored_format.id = Uuid::new_v4();
-        }

        let mut dirs = Vec::with_capacity(SET_DRIVE_COUNT);
        let mut endpoints = Vec::with_capacity(SET_DRIVE_COUNT);
@@ -1770,8 +1645,8 @@ mod tests {
            )
            .await
            .expect("disk should be created");
-            let mut disk_format = stored_format.clone();
-            disk_format.erasure.this = stored_format.erasure.sets[0][i];
+            let mut disk_format = ref_format.clone();
+            disk_format.erasure.this = ref_format.erasure.sets[0][i];
            save_format_file(&Some(disk), &Some(disk_format))
                .await
                .expect("format should be saved");
@@ -1802,60 +1677,6 @@ mod tests {
        (dirs, ref_format, sets)
    }

-    async fn set_level_heal_view(sets: &Sets) -> Arc<SetDisks> {
-        let endpoints = sets.endpoints.endpoints.as_ref().clone();
-        let mut disks = Vec::with_capacity(endpoints.len());
-        for endpoint in &endpoints {
-            disks.push(Some(
-                new_disk(
-                    endpoint,
-                    &DiskOption {
-                        cleanup: false,
-                        health_check: false,
-                    },
-                )
-                .await
-                .expect("fresh set-level disk handle should open"),
-            ));
-        }
-
-        SetDisks::new(
-            "test-owner".to_string(),
-            Arc::new(RwLock::new(disks)),
-            endpoints.len(),
-            1,
-            0,
-            0,
-            endpoints,
-            sets.format.clone(),
-            Vec::new(),
-        )
-        .await
-    }
-
-    async fn replace_heal_test_format(sets: &Sets, disk_index: usize, format: &FormatV3) {
-        let disk = new_disk(
-            &sets.endpoints.endpoints.as_ref()[disk_index],
-            &DiskOption {
-                cleanup: false,
-                health_check: false,
-            },
-        )
-        .await
-        .expect("heal test disk should open");
-        save_format_file(&Some(disk.clone()), &Some(format.clone()))
-            .await
-            .expect("poisoned test format should be written");
-    }
-
-    async fn read_heal_test_format(sets: &Sets, disk_index: usize) -> FormatV3 {
-        let path = std::path::Path::new(&sets.endpoints.endpoints.as_ref()[disk_index].get_file_path())
-            .join(crate::disk::RUSTFS_META_BUCKET)
-            .join(crate::disk::FORMAT_CONFIG_FILE);
-        let data = tokio::fs::read(path).await.expect("test format should be readable");
-        FormatV3::try_from(data.as_slice()).expect("test format should parse")
-    }
-
    // Regression for #956 (NoHealRequired path): with every disk already
    // formatted, `heal_format` reports exactly one drive record per disk
    // (N = set_count * set_drive_count), each carrying a real endpoint. Before
@@ -1864,7 +1685,7 @@ mod tests {
    #[tokio::test]
    #[serial]
    async fn heal_format_no_heal_required_reports_one_record_per_disk() {
-        let (_dirs, _ref_format, sets) = setup_heal_format_sets(3, false).await;
+        let (_dirs, _ref_format, sets) = setup_heal_format_sets(3).await;

        let (res, err) = sets.heal_format(true).await.expect("heal_format should succeed");
        // All disks formatted -> NoHealRequired early return, still returns `res`.
@@ -1894,7 +1715,7 @@ mod tests {
    #[serial]
    async fn heal_format_heal_path_reports_one_record_per_disk_aligned() {
        // Disks 0 and 1 formatted (quorum), disk 2 unformatted.
-        let (_dirs, _ref_format, sets) = setup_heal_format_sets(2, false).await;
+        let (_dirs, _ref_format, sets) = setup_heal_format_sets(2).await;

        let (res, err) = sets.heal_format(true).await.expect("heal_format should succeed");
        // Unformatted disk present -> heal path, not NoHealRequired.
@@ -1049,10 +1049,6 @@ impl LocalDiskWrapper {
        Ok(())
    }

-    pub(crate) async fn set_disk_id_state(&self, id: Option<Uuid>) {
-        *self.disk_id.write().await = id;
-    }
-
    /// Get the current disk ID
    pub async fn get_current_disk_id(&self) -> Option<Uuid> {
        *self.disk_id.read().await
@@ -1369,14 +1365,6 @@ impl DiskAPI for LocalDiskWrapper {
        .await
    }

-    async fn renew_snapshot_lease(&self, volume: &str, path: &str, token: SnapshotLeaseToken) -> Result<SnapshotLeaseToken> {
-        self.track_disk_health(
-            || async { self.disk.renew_snapshot_lease(volume, path, token).await },
-            get_max_timeout_duration(),
-        )
-        .await
-    }
-
    async fn delete_data_dir(&self, volume: &str, path: &str, opts: DeleteOptions) -> Result<DataDirDeleteStatus> {
        self.track_disk_health(
            || async { self.disk.delete_data_dir(volume, path, opts).await },
@@ -79,18 +79,6 @@ impl SnapshotLeaseToken {
    pub fn new() -> Self {
        Self(Uuid::new_v4())
    }
-
-    pub fn from_slice(bytes: &[u8]) -> Result<Self> {
-        let uuid = Uuid::from_slice(bytes).map_err(|_| Error::other("invalid snapshot lease token"))?;
-        if uuid.is_nil() {
-            return Err(Error::other("invalid snapshot lease token"));
-        }
-        Ok(Self(uuid))
-    }
-
-    pub fn as_bytes(&self) -> &[u8; 16] {
-        self.0.as_bytes()
-    }
 }

 impl Default for SnapshotLeaseToken {
@@ -132,18 +120,6 @@ pub enum Disk {
    Remote(Box<RemoteDisk>),
 }

-impl Disk {
-    pub(crate) async fn set_disk_id_state(&self, id: Option<Uuid>) -> Result<()> {
-        match self {
-            Disk::Local(local_disk) => {
-                local_disk.set_disk_id_state(id).await;
-                Ok(())
-            }
-            Disk::Remote(remote_disk) => remote_disk.set_disk_id(id).await,
-        }
-    }
-}
-
 #[async_trait::async_trait]
 impl DiskAPI for Disk {
    fn to_string(&self) -> String {
@@ -308,13 +284,6 @@ impl DiskAPI for Disk {
        }
    }

-    async fn renew_snapshot_lease(&self, volume: &str, path: &str, token: SnapshotLeaseToken) -> Result<SnapshotLeaseToken> {
-        match self {
-            Disk::Local(local_disk) => local_disk.renew_snapshot_lease(volume, path, token).await,
-            Disk::Remote(remote_disk) => remote_disk.renew_snapshot_lease(volume, path, token).await,
-        }
-    }
-
    async fn delete_data_dir(&self, volume: &str, path: &str, opts: DeleteOptions) -> Result<DataDirDeleteStatus> {
        match self {
            Disk::Local(local_disk) => local_disk.delete_data_dir(volume, path, opts).await,
@@ -725,9 +694,6 @@ pub trait DiskAPI: Debug + Send + Sync + 'static {
    async fn release_snapshot_lease(&self, _volume: &str, _path: &str, _token: SnapshotLeaseToken) -> Result<()> {
        Err(Error::other("snapshot leases are not supported by this disk"))
    }
-    async fn renew_snapshot_lease(&self, _volume: &str, _path: &str, _token: SnapshotLeaseToken) -> Result<SnapshotLeaseToken> {
-        Err(Error::other("snapshot leases are not supported by this disk"))
-    }
    async fn delete_data_dir(&self, volume: &str, path: &str, opts: DeleteOptions) -> Result<DataDirDeleteStatus> {
        self.delete(volume, path, opts).await?;
        Ok(DataDirDeleteStatus::Deleted)
@@ -1564,72 +1530,6 @@ mod tests {
        let _ = fs::remove_dir_all(&test_dir).await;
    }

-    #[tokio::test]
-    #[serial_test::serial]
-    async fn local_disk_id_state_does_not_publish_to_the_process_registry() {
-        let local_dir = tempfile::tempdir().expect("local disk tempdir should be created");
-        let mut endpoint =
-            Endpoint::try_from(local_dir.path().to_str().expect("tempdir path should be utf8")).expect("endpoint should parse");
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(0);
-        let local_disk = LocalDisk::new(&endpoint, false).await.expect("local disk should initialize");
-        let disk = Disk::Local(Box::new(LocalDiskWrapper::new(Arc::new(local_disk), false)));
-        let disk_id = Uuid::new_v4();
-
-        disk.set_disk_id_state(Some(disk_id))
-            .await
-            .expect("local wrapper state should accept a disk ID");
-
-        let Disk::Local(local_disk) = &disk else {
-            panic!("test disk should remain local");
-        };
-        assert_eq!(local_disk.get_current_disk_id().await, Some(disk_id));
-        assert!(
-            !crate::runtime::global::current_ctx()
-                .local_disk_id_map()
-                .read()
-                .await
-                .contains_key(&disk_id),
-            "state-only startup publication must not update the process disk-ID registry"
-        );
-
-        disk.set_disk_id_state(None)
-            .await
-            .expect("local wrapper state should clear a disk ID");
-        assert_eq!(local_disk.get_current_disk_id().await, None);
-    }
-
-    #[tokio::test]
-    async fn remote_disk_id_state_delegates_some_and_none() {
-        let mut endpoint = Endpoint::try_from("http://remote-server:9000/data").expect("remote endpoint should parse");
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(0);
-        let remote_disk = RemoteDisk::new(
-            &endpoint,
-            &DiskOption {
-                cleanup: false,
-                health_check: false,
-            },
-            Arc::new(crate::cluster::rpc::TcpHttpInternodeDataTransport),
-        )
-        .await
-        .expect("remote disk should initialize");
-        let disk = Disk::Remote(Box::new(remote_disk));
-        let disk_id = Uuid::new_v4();
-
-        disk.set_disk_id_state(Some(disk_id))
-            .await
-            .expect("remote state should accept a disk ID");
-        assert_eq!(disk.get_disk_id().await.expect("remote disk ID should be readable"), Some(disk_id));
-
-        disk.set_disk_id_state(None)
-            .await
-            .expect("remote state should clear a disk ID");
-        assert_eq!(disk.get_disk_id().await.expect("remote disk ID should be readable"), None);
-    }
-
    #[tokio::test]
    async fn reset_health_for_store_init_retry_delegates_to_disk_variants() {
        let local_dir = tempfile::tempdir().unwrap();
@@ -25,7 +25,7 @@ use std::{
    sync::{Arc, LazyLock, Weak},
 };
 use tokio::fs;
-use tokio::sync::{OwnedSemaphorePermit, RwLock, Semaphore, SemaphorePermit};
+use tokio::sync::{OwnedSemaphorePermit, Semaphore, SemaphorePermit};
 use tracing::warn;

 /// Check path length according to OS limits.
@@ -123,8 +123,6 @@ const TEST_GLOBAL_FILE_SYNCS: usize = 64;

 static FILE_SYNC_PERMITS: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(global_file_sync_limit()));
 static DISK_FILE_SYNC_LIMITERS: LazyLock<Mutex<HashMap<PathBuf, Weak<Semaphore>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
-static DISK_VOLUME_MUTATION_LOCKS: LazyLock<Mutex<HashMap<PathBuf, Weak<RwLock<()>>>>> =
-    LazyLock::new(|| Mutex::new(HashMap::new()));

 fn default_global_file_sync_limit(cpu_count: usize, max_blocking_threads: usize) -> usize {
    let cpu_scaled = cpu_count
@@ -159,24 +157,6 @@ pub(crate) fn disk_file_sync_limiter(root: &Path) -> Arc<Semaphore> {
    limiter
 }

-/// Serialize a bucket's local metadata commits with physical bucket removal.
-///
-/// The key includes the canonical disk root, so independently reconnected
-/// [`LocalDisk`](super::local::LocalDisk) instances share the same lock while
-/// disconnected disks do not keep the registry alive.
-pub(crate) fn disk_volume_mutation_lock(root: &Path, volume: &str) -> Arc<RwLock<()>> {
-    let key = root.join(volume);
-    let mut locks = DISK_VOLUME_MUTATION_LOCKS.lock();
-    locks.retain(|_, lock| lock.strong_count() > 0);
-    if let Some(lock) = locks.get(&key).and_then(Weak::upgrade) {
-        return lock;
-    }
-
-    let lock = Arc::new(RwLock::new(()));
-    locks.insert(key, Arc::downgrade(&lock));
-    lock
-}
-
 /// Always acquire the per-disk permit before the process-wide permit. Keeping
 /// this order uniform prevents one slow disk from reserving global capacity
 /// while it waits for its own concurrency slot.
@@ -592,14 +572,15 @@ async fn reliable_rename_inner(
    base_dir: impl AsRef<Path>,
    warn_on_missing_source: bool,
 ) -> io::Result<()> {
-    let parent_guard = match dst_file_path.as_ref().parent() {
-        Some(parent) => Some(mkdir_all_below_existing_base(parent, base_dir.as_ref()).await?),
-        None => None,
-    };
+    if let Some(parent) = dst_file_path.as_ref().parent()
+        && !file_exists(parent)
+    {
+        reliable_mkdir_all(parent, base_dir.as_ref()).await?;
+    }

    let mut i = 0;
    loop {
-        if let Err(e) = rename_into_existing_parent(src_file_path.as_ref(), dst_file_path.as_ref(), parent_guard.as_ref()) {
+        if let Err(e) = super::fs::rename_std(src_file_path.as_ref(), dst_file_path.as_ref()) {
            if should_retry_rename(&e, i) {
                i += 1;
                continue;
@@ -616,159 +597,6 @@ async fn reliable_rename_inner(
    Ok(())
 }

-#[cfg(unix)]
-fn rename_into_existing_parent(
-    src_file_path: &Path,
-    dst_file_path: &Path,
-    parent_guard: Option<&ExistingBaseDirectoryGuard>,
-) -> io::Result<()> {
-    use rustix::fs::{Mode, OFlags, open, renameat};
-
-    let Some(parent_guard) = parent_guard else {
-        return super::fs::rename_std(src_file_path, dst_file_path);
-    };
-    let src_parent = src_file_path
-        .parent()
-        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "rename source must have a parent directory"))?;
-    let src_name = src_file_path
-        .file_name()
-        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "rename source must have a file name"))?;
-    let dst_name = dst_file_path
-        .file_name()
-        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "rename destination must have a file name"))?;
-    let src_parent = open(
-        src_parent,
-        OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC,
-        Mode::empty(),
-    )
-    .map_err(io::Error::from)?;
-    let dst_parent = parent_guard
-        .last()
-        .ok_or_else(|| io::Error::other("rename destination parent guard is empty"))?;
-
-    renameat(&src_parent, src_name, dst_parent, dst_name).map_err(io::Error::from)
-}
-
-#[cfg(not(unix))]
-fn rename_into_existing_parent(
-    src_file_path: &Path,
-    dst_file_path: &Path,
-    _parent_guard: Option<&ExistingBaseDirectoryGuard>,
-) -> io::Result<()> {
-    super::fs::rename_std(src_file_path, dst_file_path)
-}
-
-async fn mkdir_all_below_existing_base(dir_path: &Path, base_dir: &Path) -> io::Result<ExistingBaseDirectoryGuard> {
-    let dir_path = dir_path.to_path_buf();
-    let base_dir = base_dir.to_path_buf();
-
-    tokio::task::spawn_blocking(move || mkdir_all_below_existing_base_std(&dir_path, &base_dir)).await?
-}
-
-#[cfg(windows)]
-pub(crate) type ExistingBaseDirectoryGuard = Vec<winapi_util::Handle>;
-
-#[cfg(unix)]
-pub(crate) type ExistingBaseDirectoryGuard = Vec<std::os::fd::OwnedFd>;
-
-#[cfg(all(not(unix), not(windows)))]
-pub(crate) type ExistingBaseDirectoryGuard = ();
-
-#[cfg(windows)]
-fn lock_windows_directory(path: &Path) -> io::Result<winapi_util::Handle> {
-    use std::os::windows::fs::OpenOptionsExt;
-
-    const FILE_ATTRIBUTE_DIRECTORY: u64 = 0x10;
-    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x400;
-    const FILE_FLAG_BACKUP_SEMANTICS: u32 = 0x0200_0000;
-    const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
-    const FILE_SHARE_READ: u32 = 0x1;
-
-    let file = std::fs::OpenOptions::new()
-        .read(true)
-        .share_mode(FILE_SHARE_READ)
-        .custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT)
-        .open(path)?;
-    let handle = winapi_util::Handle::from_file(file);
-    let info = winapi_util::file::information(&handle)?;
-    if info.file_attributes() & FILE_ATTRIBUTE_DIRECTORY == 0
-        || info.file_attributes() & u64::from(FILE_ATTRIBUTE_REPARSE_POINT) != 0
-    {
-        return Err(io::Error::from(io::ErrorKind::NotADirectory));
-    }
-    Ok(handle)
-}
-
-pub(crate) fn mkdir_all_below_existing_base_std(dir_path: &Path, base_dir: &Path) -> io::Result<ExistingBaseDirectoryGuard> {
-    let relative = dir_path
-        .strip_prefix(base_dir)
-        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "rename destination must remain below its base directory"))?;
-    for component in relative.components() {
-        if !matches!(component, Component::Normal(_) | Component::CurDir) {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "rename destination contains an invalid path component",
-            ));
-        }
-    }
-
-    #[cfg(unix)]
-    {
-        use rustix::fs::{Mode, OFlags, mkdirat, open, openat};
-        use rustix::io::Errno;
-
-        let flags = OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC;
-        let mode = Mode::RWXU | Mode::RWXG | Mode::RWXO;
-        let mut parents = vec![open(base_dir, flags, Mode::empty()).map_err(io::Error::from)?];
-
-        for component in relative.components() {
-            let Component::Normal(component) = component else {
-                continue;
-            };
-            let parent = parents
-                .last()
-                .expect("base directory guard should contain the base directory");
-            match mkdirat(parent, component, mode) {
-                Ok(()) => {}
-                Err(Errno::EXIST) => {}
-                Err(err) => return Err(err.into()),
-            }
-            parents.push(openat(parent, component, flags, Mode::empty()).map_err(io::Error::from)?);
-        }
-
-        Ok(parents)
-    }
-
-    #[cfg(windows)]
-    {
-        let mut handles = vec![lock_windows_directory(base_dir)?];
-        let mut current = base_dir.to_path_buf();
-        for component in relative.components() {
-            let Component::Normal(component) = component else {
-                continue;
-            };
-            current.push(component);
-            match std::fs::create_dir(&current) {
-                Ok(()) => {}
-                Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {}
-                Err(err) => return Err(err),
-            }
-            handles.push(lock_windows_directory(&current)?);
-        }
-
-        Ok(handles)
-    }
-
-    #[cfg(all(not(unix), not(windows)))]
-    {
-        let _ = relative;
-        Err(io::Error::new(
-            io::ErrorKind::Unsupported,
-            "safe recursive directory creation is unavailable on this platform",
-        ))
-    }
-}
-
 fn warn_reliable_rename_failure(src_file_path: &Path, dst_file_path: &Path, base_dir: &Path, err: &io::Error) {
    warn!(
        "reliable_rename failed. src_file_path: {:?}, dst_file_path: {:?}, base_dir: {:?}, err: {:?}",
@@ -899,20 +727,6 @@ mod tests {
        Arc::new(Semaphore::new(MAX_PARALLEL_FILE_SYNCS))
    }

-    #[tokio::test]
-    async fn disk_volume_mutation_lock_is_shared_per_root_and_volume() {
-        let temp_dir = tempdir().expect("create temp dir");
-        let first = disk_volume_mutation_lock(temp_dir.path(), "bucket");
-        let second = disk_volume_mutation_lock(temp_dir.path(), "bucket");
-        let other = disk_volume_mutation_lock(temp_dir.path(), "other-bucket");
-
-        assert!(Arc::ptr_eq(&first, &second), "reconnected disks must share a bucket mutation lock");
-        assert!(!Arc::ptr_eq(&first, &other), "different buckets must not serialize each other");
-
-        let _write_guard = first.write().await;
-        assert!(second.try_read().is_err(), "a bucket delete lock must exclude local commits");
-    }
-
    #[derive(Clone, Default)]
    struct CapturedLogs {
        buffer: Arc<Mutex<Vec<u8>>>,
@@ -957,26 +771,9 @@ mod tests {
        }
    }

-    /// Holds a `warn_capture()` capture alive: the thread-local subscriber, plus
-    /// the pin that keeps tracing's process-global callsite-interest cache from
-    /// being decided by some other test's thread.
-    struct WarnCaptureGuard {
-        _subscriber: tracing::subscriber::DefaultGuard,
-        _callsite_pin: tracing::Dispatch,
-    }
-
    /// Capture WARN-level output on the current thread; tokio tests here run on
    /// the current-thread runtime, so the guard covers the whole test body.
-    ///
-    /// The callsite pin matters because `warn_reliable_rename_failure` is a
-    /// single production callsite shared with tests that call `rename_all`
-    /// *without* installing a subscriber — `rename_all_missing_source_returns_file_not_found`
-    /// is one. Whichever thread reaches it first fixes its `Interest`
-    /// process-wide, so without the pin that sibling can cache
-    /// `Interest::never()` and the WARN never fires here at all, leaving the
-    /// "must keep the WARN" assertions staring at empty output. See
-    /// [`crate::test_tracing::pin_callsite_interest_for_test`].
-    fn warn_capture() -> (CapturedLogs, WarnCaptureGuard) {
+    fn warn_capture() -> (CapturedLogs, tracing::subscriber::DefaultGuard) {
        let logs = CapturedLogs::default();
        let subscriber = tracing_subscriber::fmt()
            .with_max_level(tracing::Level::WARN)
@@ -984,10 +781,7 @@ mod tests {
            .with_ansi(false)
            .without_time()
            .finish();
-        let guard = WarnCaptureGuard {
-            _subscriber: tracing::subscriber::set_default(subscriber),
-            _callsite_pin: crate::test_tracing::pin_callsite_interest_for_test(),
-        };
+        let guard = tracing::subscriber::set_default(subscriber);
        (logs, guard)
    }

@@ -1174,112 +968,6 @@ mod tests {
        assert_eq!(std::fs::read(dst.join("nested").join("part.1")).expect("read moved part"), b"payload");
    }

-    #[tokio::test]
-    async fn rename_all_does_not_recreate_missing_base_directory() {
-        let temp_dir = tempdir().expect("create temp dir");
-        let base = temp_dir.path().join("bucket");
-        std::fs::create_dir(&base).expect("create destination base");
-        let src = temp_dir.path().join("staged-object");
-        std::fs::write(&src, b"payload").expect("write staged object");
-        let dst = base.join("object").join("xl.meta");
-        std::fs::remove_dir(&base).expect("delete destination base before commit");
-
-        let err = rename_all(&src, &dst, &base)
-            .await
-            .expect_err("rename must not recreate a deleted destination base");
-
-        assert!(matches!(err, DiskError::FileNotFound));
-        assert!(src.exists(), "failed commit must preserve the staged source");
-        assert!(!base.exists(), "failed commit must not recreate the deleted bucket");
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn rename_all_rejects_a_replaced_base_with_an_existing_parent() {
-        use std::os::unix::fs::symlink;
-
-        let temp_dir = tempdir().expect("create temp dir");
-        let base = temp_dir.path().join("bucket");
-        let outside = temp_dir.path().join("outside");
-        std::fs::create_dir(&base).expect("create destination base");
-        std::fs::create_dir_all(outside.join("object")).expect("create outside destination parent");
-        let src = temp_dir.path().join("staged-object");
-        std::fs::write(&src, b"payload").expect("write staged object");
-        let dst = base.join("object").join("xl.meta");
-
-        std::fs::remove_dir(&base).expect("remove destination base before replacement");
-        symlink(&outside, &base).expect("replace destination base with a symlink");
-
-        rename_all(&src, &dst, &base)
-            .await
-            .expect_err("rename must reject an existing destination parent below a replaced base");
-
-        assert!(src.exists(), "rejected rename must preserve the staged source");
-        assert!(
-            !outside.join("object/xl.meta").exists(),
-            "rename must not publish through the replacement symlink"
-        );
-    }
-
-    #[cfg(windows)]
-    #[test]
-    fn windows_parent_guard_blocks_base_and_intermediate_replacement() {
-        let temp_dir = tempdir().expect("create temp dir");
-        let base = temp_dir.path().join("bucket");
-        std::fs::create_dir(&base).expect("create destination base");
-        let parent = base.join("object").join("nested");
-        let guard = mkdir_all_below_existing_base_std(&parent, &base).expect("create and lock destination parents");
-
-        std::fs::rename(&base, temp_dir.path().join("replacement-base"))
-            .expect_err("the locked base must not be replaceable before commit");
-        std::fs::rename(base.join("object"), base.join("replacement-object"))
-            .expect_err("a locked intermediate directory must not be replaceable before commit");
-
-        drop(guard);
-        std::fs::rename(base.join("object"), base.join("replacement-object"))
-            .expect("replacement should succeed after the commit guard is released");
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn rename_parent_creation_rejects_symlinked_base() {
-        use std::os::unix::fs::symlink;
-
-        let temp_dir = tempdir().expect("create temp dir");
-        let outside = temp_dir.path().join("outside");
-        std::fs::create_dir(&outside).expect("create outside directory");
-        let base = temp_dir.path().join("bucket");
-        symlink(&outside, &base).expect("create symlinked base");
-
-        mkdir_all_below_existing_base(&base.join("object"), &base)
-            .await
-            .expect_err("symlinked base must be rejected");
-
-        assert!(!outside.join("object").exists(), "parent creation must remain confined to the base");
-    }
-
-    #[cfg(unix)]
-    #[tokio::test]
-    async fn rename_parent_creation_rejects_symlink_below_base() {
-        use std::os::unix::fs::symlink;
-
-        let temp_dir = tempdir().expect("create temp dir");
-        let base = temp_dir.path().join("bucket");
-        let outside = temp_dir.path().join("outside");
-        std::fs::create_dir(&base).expect("create destination base");
-        std::fs::create_dir(&outside).expect("create outside directory");
-        symlink(&outside, base.join("linked")).expect("create symlink below base");
-
-        mkdir_all_below_existing_base(&base.join("linked/object"), &base)
-            .await
-            .expect_err("symlink below base must be rejected");
-
-        assert!(
-            !outside.join("object").exists(),
-            "parent creation must not follow a symlink outside the base"
-        );
-    }
-
    #[tokio::test]
    async fn fsync_dir_succeeds_on_directory() {
        let temp_dir = tempdir().expect("create temp dir");
@@ -103,7 +103,7 @@ where
    /// or `out` is larger than one shard. On error `out`'s contents are
    /// unspecified but never contain bytes that failed the hash check — the copy
    /// happens only after verification.
-    #[hotpath::measure(impl_type = "BitrotReader")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {
        let want = out.len();
        self.begin_read(want)?;
@@ -303,7 +303,7 @@ where

    /// Write a (hash+data) block. Returns the number of data bytes written.
    /// Returns an error if called after a short write or if data exceeds shard_size.
-    #[hotpath::measure(label = "BitrotWriter::write", impl_type = "BitrotWriter")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure(label = "BitrotWriter::write"))]
    pub async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        if buf.is_empty() {
            return Ok(0);
@@ -455,7 +455,7 @@ pub fn bitrot_shard_file_size(size: usize, shard_size: usize, algo: HashAlgorith
 /// stores those as whole-file bitrot with no interleaved hash, so the size guard
 /// on the next line would reject a genuinely healthy part. Reading legacy V1
 /// whole-file-bitrot objects would need a separate verification path.
-#[hotpath::measure]
+#[cfg_attr(feature = "hotpath", hotpath::measure)]
 pub async fn bitrot_verify<R: AsyncRead + Unpin + Send>(
    mut r: R,
    want_size: usize,
@@ -691,7 +691,7 @@ impl<R> ParallelReader<R>
 where
    R: crate::erasure::coding::ShardSource,
 {
-    #[hotpath::measure(impl_type = "ParallelReader")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn read(&mut self) -> (Vec<Option<Vec<u8>>>, Vec<Option<Error>>) {
        // On the reconstruction-verifying GET path, read every live shard reader
        // in lockstep so all readers advance one block per stripe and stay
@@ -1505,7 +1505,7 @@ where
 }

 impl Erasure {
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn decode<W, R>(
        &self,
        writer: &mut W,
@@ -1645,28 +1645,15 @@ impl Erasure {
            }
            Err(e) => {
                record_get_stage_duration_if_enabled(GET_OBJECT_PATH_LEGACY_DUPLEX, GET_STAGE_EMIT, emit_stage_start);
-                let reason = classify_io_error(&e);
-                if reason == GetObjectFailureReason::DownstreamClosed {
-                    debug!(
-                        block_offset,
-                        block_length,
-                        bytes_written = *written,
-                        stage = GET_STAGE_EMIT,
-                        reason = reason.as_str(),
-                        error = ?e,
-                        "Erasure decode stopped after downstream closed"
-                    );
-                } else {
-                    error!(
-                        block_offset,
-                        block_length,
-                        bytes_written = *written,
-                        stage = GET_STAGE_EMIT,
-                        reason = reason.as_str(),
-                        error = ?e,
-                        "Erasure decode failed to emit reconstructed data"
-                    );
-                }
+                error!(
+                    block_offset,
+                    block_length,
+                    bytes_written = *written,
+                    stage = GET_STAGE_EMIT,
+                    reason = classify_io_error(&e).as_str(),
+                    error = ?e,
+                    "Erasure decode failed to emit reconstructed data"
+                );
                *ret_err = Some(e);
                return StripeFlow::Stop;
            }
@@ -1958,7 +1945,7 @@ mod tests {
    use std::io::Cursor;
    use std::pin::Pin;
    use std::sync::{
-        Arc, Mutex,
+        Arc,
        atomic::{AtomicUsize, Ordering},
    };
    use std::task::{Context, Poll};
@@ -2133,59 +2120,6 @@ mod tests {
        }
    }

-    struct DownstreamClosedWriter;
-
-    impl AsyncWrite for DownstreamClosedWriter {
-        fn poll_write(self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &[u8]) -> Poll<io::Result<usize>> {
-            Poll::Ready(Err(crate::diagnostics::get::mark_get_object_downstream_closed(io::Error::new(
-                ErrorKind::BrokenPipe,
-                "injected downstream close",
-            ))))
-        }
-
-        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    #[derive(Clone, Default)]
-    struct CapturedLogs(Arc<Mutex<Vec<u8>>>);
-
-    struct CapturedLogWriter(Arc<Mutex<Vec<u8>>>);
-
-    impl CapturedLogs {
-        fn contents(&self) -> String {
-            String::from_utf8(self.0.lock().expect("captured logs mutex should not be poisoned").clone())
-                .expect("captured logs should be valid UTF-8")
-        }
-    }
-
-    impl std::io::Write for CapturedLogWriter {
-        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-            self.0
-                .lock()
-                .expect("captured logs mutex should not be poisoned")
-                .extend_from_slice(buf);
-            Ok(buf.len())
-        }
-
-        fn flush(&mut self) -> std::io::Result<()> {
-            Ok(())
-        }
-    }
-
-    impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for CapturedLogs {
-        type Writer = CapturedLogWriter;
-
-        fn make_writer(&'a self) -> Self::Writer {
-            CapturedLogWriter(Arc::clone(&self.0))
-        }
-    }
-
    #[test]
    fn parallel_reader_constructor_variants_preserve_read_cost_and_verification_flags() {
        let erasure = Erasure::new(2, 1, 64);
@@ -2281,47 +2215,6 @@ mod tests {
        assert_eq!(err.to_string(), "injected emit failure");
    }

-    #[tokio::test(flavor = "current_thread")]
-    async fn erasure_decode_logs_reconstructed_downstream_close_at_debug() {
-        let logs = CapturedLogs::default();
-        let subscriber = tracing_subscriber::fmt()
-            .with_max_level(tracing::Level::DEBUG)
-            .with_writer(logs.clone())
-            .with_ansi(false)
-            .without_time()
-            .finish();
-        let _guard = tracing::subscriber::set_default(subscriber);
-
-        let erasure = Erasure::new(2, 1, 64);
-        let data: Vec<u8> = (0..64).collect();
-        let shard_size = erasure.shard_size();
-        let encoded = erasure.encode_data(&data).expect("test data should encode");
-        let readers = vec![
-            None,
-            Some(BitrotReader::new(
-                Cursor::new(encoded[1].to_vec()),
-                shard_size,
-                HashAlgorithm::None,
-                false,
-            )),
-            Some(BitrotReader::new(
-                Cursor::new(encoded[2].to_vec()),
-                shard_size,
-                HashAlgorithm::None,
-                false,
-            )),
-        ];
-
-        let mut writer = DownstreamClosedWriter;
-        let (written, err) = erasure.decode(&mut writer, readers, 0, data.len(), data.len()).await;
-
-        assert_eq!(written, 0);
-        assert_eq!(err.expect("downstream close must still terminate the GET").kind(), ErrorKind::BrokenPipe);
-        let captured = logs.contents();
-        assert!(captured.contains("Erasure decode stopped after downstream closed"));
-        assert!(!captured.contains("Erasure decode failed to emit reconstructed data"));
-    }
-
    #[tokio::test]
    async fn test_erasure_decode_rejects_reader_count_and_range_overflow() {
        let erasure = Erasure::new(2, 1, 64);
@@ -28,11 +28,8 @@ use std::vec;
 use tokio::io::AsyncRead;
 use tokio::runtime::RuntimeFlavor;
 use tokio::sync::mpsc;
-use tokio::task::{JoinError, JoinHandle};
 use tracing::error;

-/// Queue-capacity input for encoded blocks awaiting shard writers; it is not a
-/// per-PUT or process-RSS memory limit.
 const ENV_RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES: &str = "RUSTFS_ERASURE_ENCODE_MAX_INFLIGHT_BYTES";
 const ENV_RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS: &str = "RUSTFS_ERASURE_ENCODE_BATCH_BLOCKS";
 const ENV_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST: &str = "RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST";
@@ -90,33 +87,6 @@ fn use_bytesmut_ingest() -> bool {
        rustfs_utils::get_env_bool(ENV_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST, DEFAULT_RUSTFS_ERASURE_ENCODE_BYTESMUT_INGEST)
    })
 }
-
-/// Keeps the encoder producer scoped to its parent future. Tokio detaches a
-/// task when its `JoinHandle` is dropped, so the producer must be aborted when
-/// an upload is cancelled before the encode pipeline finishes.
-struct AbortOnDropTask<T>(JoinHandle<T>);
-
-impl<T> AbortOnDropTask<T> {
-    fn new(task: JoinHandle<T>) -> Self {
-        Self(task)
-    }
-
-    async fn abort_and_wait(&mut self) {
-        self.0.abort();
-        let _ = (&mut self.0).await;
-    }
-
-    async fn join(&mut self) -> Result<T, JoinError> {
-        (&mut self.0).await
-    }
-}
-
-impl<T> Drop for AbortOnDropTask<T> {
-    fn drop(&mut self) {
-        self.0.abort();
-    }
-}
-
 /// Read up to `limit` bytes into `buf`'s uninitialized spare capacity, appending after its
 /// current length, and distinguish a clean EOF from a short read.
 ///
@@ -163,65 +133,22 @@ fn queued_block_bytes(block: &[Bytes]) -> usize {
    block.iter().map(Bytes::len).sum()
 }

-/// Owns an encoded queue entry's gauge contribution until its consumer takes it.
-struct QueuedInflightBytes {
-    bytes: usize,
-}
-
-impl QueuedInflightBytes {
-    fn new(bytes: usize) -> Self {
-        rustfs_io_metrics::add_ec_encode_inflight_bytes(bytes);
-        Self { bytes }
+async fn drain_queued_inflight_bytes(rx: &mut mpsc::Receiver<Vec<Bytes>>) {
+    while let Some(block) = rx.recv().await {
+        rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_block_bytes(&block));
    }
-
-    fn settle(&mut self) {
-        let bytes = std::mem::take(&mut self.bytes);
-        if bytes != 0 {
-            rustfs_io_metrics::remove_ec_encode_inflight_bytes(bytes);
-        }
-    }
-}
-
-impl Drop for QueuedInflightBytes {
-    fn drop(&mut self) {
-        self.settle();
-    }
-}
-
-/// Couples an encoded block with its queue gauge contribution. Keeping the
-/// guard in the queue entry also covers Tokio sends that complete through a
-/// permit after the receiver has closed.
-struct InflightEntry<T> {
-    entry: T,
-    accounting: QueuedInflightBytes,
-}
-
-impl<T> InflightEntry<T> {
-    fn new(entry: T, bytes: usize) -> Self {
-        Self {
-            entry,
-            accounting: QueuedInflightBytes::new(bytes),
-        }
-    }
-
-    fn into_inner(mut self) -> T {
-        self.accounting.settle();
-        self.entry
-    }
-}
-
-async fn send_queued<T>(
-    sender: &mpsc::Sender<InflightEntry<T>>,
-    entry: T,
-    bytes: usize,
-) -> Result<(), mpsc::error::SendError<InflightEntry<T>>> {
-    sender.send(InflightEntry::new(entry, bytes)).await
 }

 fn queued_batch_bytes(batch: &[Vec<Bytes>]) -> usize {
    batch.iter().map(|block| queued_block_bytes(block)).sum()
 }

+async fn drain_queued_batched_inflight_bytes(rx: &mut mpsc::Receiver<Vec<Vec<Bytes>>>) {
+    while let Some(batch) = rx.recv().await {
+        rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_batch_bytes(&batch));
+    }
+}
+
 fn dominant_error_summary_label(summary: &WriteQuorumFailureSummary) -> &'static str {
    summary.dominant_error_label
 }
@@ -577,7 +504,7 @@ impl Erasure {
        Ok((reader, total))
    }

-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn encode<R>(
        self: Arc<Self>,
        reader: R,
@@ -613,14 +540,13 @@ impl Erasure {
            ));
        }

-        // Bound queued encoded blocks by a queue budget; this does not bound
-        // reader, encoder, writer, allocator, or process-RSS memory.
+        // Bound queued encoded blocks by memory budget to avoid per-request spikes.
        let expanded_block_bytes = self.shard_size().saturating_mul(self.total_shard_count());
        let max_inflight_bytes = erasure_encode_max_inflight_bytes();
        let inflight_blocks = encode_channel_capacity(expanded_block_bytes, max_inflight_bytes);
-        let (tx, mut rx) = mpsc::channel::<InflightEntry<Vec<Bytes>>>(inflight_blocks);
+        let (tx, mut rx) = mpsc::channel::<Vec<Bytes>>(inflight_blocks);

-        let mut task = AbortOnDropTask::new(tokio::spawn(async move {
+        let task = tokio::spawn(async move {
            let block_size = self.block_size;
            let mut total = 0;
            if use_bytesmut_ingest {
@@ -641,8 +567,10 @@ impl Erasure {
                            let res = self.clone().encode_block_bytes_mut(encode_buf, n).await?;
                            buf = BytesMut::with_capacity(ingest_capacity);
                            let queued_bytes = queued_block_bytes(&res);
+                            rustfs_io_metrics::add_ec_encode_inflight_bytes(queued_bytes);
                            let send_wait_stage_start = stage_timer_if_enabled();
-                            if let Err(err) = send_queued(&tx, res, queued_bytes).await {
+                            if let Err(err) = tx.send(res).await {
+                                rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_bytes);
                                return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
                            }
                            record_internal_stage_if_enabled("erasure_encode_send_wait", send_wait_stage_start);
@@ -670,8 +598,10 @@ impl Erasure {
                            let (res, returned_buf) = self.clone().encode_block(encode_buf, n).await?;
                            buf = returned_buf;
                            let queued_bytes = queued_block_bytes(&res);
+                            rustfs_io_metrics::add_ec_encode_inflight_bytes(queued_bytes);
                            let send_wait_stage_start = stage_timer_if_enabled();
-                            if let Err(err) = send_queued(&tx, res, queued_bytes).await {
+                            if let Err(err) = tx.send(res).await {
+                                rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_bytes);
                                return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
                            }
                            record_internal_stage_if_enabled("erasure_encode_send_wait", send_wait_stage_start);
@@ -696,7 +626,7 @@ impl Erasure {
            }

            Ok((reader, total))
-        }));
+        });

        let mut writers = MultiWriter::new(writers, quorum);

@@ -708,10 +638,11 @@ impl Erasure {
                break;
            };
            record_internal_stage_if_enabled("erasure_encode_recv_wait", recv_wait_stage_start);
-            let block = block.into_inner();
            if block.is_empty() {
                break;
            }
+            let queued_bytes = queued_block_bytes(&block);
+            rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_bytes);
            let write_stage_start = stage_timer_if_enabled();
            if let Err(err) = writers.write(block).await {
                write_err = Some(err);
@@ -721,8 +652,9 @@ impl Erasure {
        }

        if let Some(err) = write_err {
-            task.abort_and_wait().await;
-            drop(rx);
+            task.abort();
+            let _ = task.await;
+            drain_queued_inflight_bytes(&mut rx).await;
            let shutdown_stage_start = stage_timer_if_enabled();
            if let Err(shutdown_err) = writers.shutdown().await {
                error!("failed to shutdown erasure writers after write error: {:?}", shutdown_err);
@@ -731,14 +663,14 @@ impl Erasure {
            return Err(err);
        }

-        let (reader, total) = task.join().await??;
+        let (reader, total) = task.await??;
        let shutdown_stage_start = stage_timer_if_enabled();
        writers.shutdown().await?;
        record_internal_stage_if_enabled("erasure_encode_shutdown", shutdown_stage_start);
        Ok((reader, total))
    }

-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn encode_batched<R>(
        self: Arc<Self>,
        mut reader: R,
@@ -760,9 +692,9 @@ impl Erasure {
        let inflight_blocks = encode_channel_capacity(expanded_block_bytes, max_inflight_bytes);
        let batch_blocks = encode_batch_block_count().min(inflight_blocks);
        let channel_capacity = inflight_blocks.div_ceil(batch_blocks).max(1);
-        let (tx, mut rx) = mpsc::channel::<InflightEntry<Vec<Vec<Bytes>>>>(channel_capacity);
+        let (tx, mut rx) = mpsc::channel::<Vec<Vec<Bytes>>>(channel_capacity);

-        let mut task = AbortOnDropTask::new(tokio::spawn(async move {
+        let task = tokio::spawn(async move {
            let block_size = self.block_size;
            let mut total = 0;
            let mut buf = vec![0u8; block_size];
@@ -781,8 +713,10 @@ impl Erasure {
                        pending_batch.push(res);

                        if pending_batch.len() >= batch_blocks {
+                            rustfs_io_metrics::add_ec_encode_inflight_bytes(pending_batch_bytes);
                            let send_wait_stage_start = stage_timer_if_enabled();
-                            if let Err(err) = send_queued(&tx, pending_batch, pending_batch_bytes).await {
+                            if let Err(err) = tx.send(pending_batch).await {
+                                rustfs_io_metrics::remove_ec_encode_inflight_bytes(pending_batch_bytes);
                                return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
                            }
                            record_internal_stage_if_enabled("erasure_encode_batched_send_wait", send_wait_stage_start);
@@ -808,15 +742,17 @@ impl Erasure {
            }

            if !pending_batch.is_empty() {
+                rustfs_io_metrics::add_ec_encode_inflight_bytes(pending_batch_bytes);
                let send_wait_stage_start = stage_timer_if_enabled();
-                if let Err(err) = send_queued(&tx, pending_batch, pending_batch_bytes).await {
+                if let Err(err) = tx.send(pending_batch).await {
+                    rustfs_io_metrics::remove_ec_encode_inflight_bytes(pending_batch_bytes);
                    return Err(std::io::Error::other(format!("Failed to send encoded data : {err}")));
                }
                record_internal_stage_if_enabled("erasure_encode_batched_send_wait", send_wait_stage_start);
            }

            Ok((reader, total))
-        }));
+        });

        let mut writers = MultiWriter::new(writers, quorum);
        let mut write_err = None;
@@ -827,7 +763,7 @@ impl Erasure {
                break;
            };
            record_internal_stage_if_enabled("erasure_encode_batched_recv_wait", recv_wait_stage_start);
-            let batch = batch.into_inner();
+            rustfs_io_metrics::remove_ec_encode_inflight_bytes(queued_batch_bytes(&batch));
            let write_stage_start = stage_timer_if_enabled();
            for block in batch {
                if let Err(err) = writers.write(block).await {
@@ -842,8 +778,9 @@ impl Erasure {
        }

        if let Some(err) = write_err {
-            task.abort_and_wait().await;
-            drop(rx);
+            task.abort();
+            let _ = task.await;
+            drain_queued_batched_inflight_bytes(&mut rx).await;
            let shutdown_stage_start = stage_timer_if_enabled();
            if let Err(shutdown_err) = writers.shutdown().await {
                error!("failed to shutdown erasure writers after write error: {:?}", shutdown_err);
@@ -852,7 +789,7 @@ impl Erasure {
            return Err(err);
        }

-        let (reader, total) = task.join().await??;
+        let (reader, total) = task.await??;
        let shutdown_stage_start = stage_timer_if_enabled();
        writers.shutdown().await?;
        record_internal_stage_if_enabled("erasure_encode_batched_shutdown", shutdown_stage_start);
@@ -861,7 +798,7 @@ impl Erasure {

    /// Fast path for small inline objects: skip tokio::spawn + mpsc channel.
    /// Reads all data, encodes directly, writes shards sequentially.
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn encode_inline_small<R>(
        self: Arc<Self>,
        reader: R,
@@ -876,7 +813,7 @@ impl Erasure {

    /// Fast path for single-block non-inline objects: avoids the producer/consumer
    /// pipeline in `encode()` while keeping the same writer/quorum/shutdown semantics.
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub async fn encode_single_block_non_inline<R>(
        self: Arc<Self>,
        reader: R,
@@ -902,104 +839,7 @@ mod tests {
    use std::sync::{Arc, Mutex};
    use std::task::{Context, Poll};
    use std::time::Duration;
-    use tokio::io::{AsyncWrite, AsyncWriteExt, ReadBuf};
-    use tokio::sync::oneshot;
-
-    struct PendingReader {
-        entered: Option<oneshot::Sender<()>>,
-        dropped: Option<oneshot::Sender<()>>,
-    }
-
-    impl PendingReader {
-        fn new() -> (Self, oneshot::Receiver<()>, oneshot::Receiver<()>) {
-            let (entered_tx, entered_rx) = oneshot::channel();
-            let (dropped_tx, dropped_rx) = oneshot::channel();
-            (
-                Self {
-                    entered: Some(entered_tx),
-                    dropped: Some(dropped_tx),
-                },
-                entered_rx,
-                dropped_rx,
-            )
-        }
-    }
-
-    impl AsyncRead for PendingReader {
-        fn poll_read(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
-            if let Some(entered) = self.entered.take() {
-                let _ = entered.send(());
-            }
-            Poll::Pending
-        }
-    }
-
-    impl Drop for PendingReader {
-        fn drop(&mut self) {
-            if let Some(dropped) = self.dropped.take() {
-                let _ = dropped.send(());
-            }
-        }
-    }
-
-    struct BlocksThenPendingReader {
-        blocks_remaining: usize,
-        block: Vec<u8>,
-        blocked: Option<oneshot::Sender<()>>,
-        dropped: Option<oneshot::Sender<()>>,
-        final_block: Option<oneshot::Sender<()>>,
-    }
-
-    impl BlocksThenPendingReader {
-        fn new(
-            blocks_remaining: usize,
-            block_size: usize,
-        ) -> (Self, oneshot::Receiver<()>, oneshot::Receiver<()>, oneshot::Receiver<()>) {
-            let (blocked_tx, blocked_rx) = oneshot::channel();
-            let (dropped_tx, dropped_rx) = oneshot::channel();
-            let (final_block_tx, final_block_rx) = oneshot::channel();
-            (
-                Self {
-                    blocks_remaining,
-                    block: vec![0x5a; block_size],
-                    blocked: Some(blocked_tx),
-                    dropped: Some(dropped_tx),
-                    final_block: Some(final_block_tx),
-                },
-                blocked_rx,
-                dropped_rx,
-                final_block_rx,
-            )
-        }
-    }
-
-    impl AsyncRead for BlocksThenPendingReader {
-        fn poll_read(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
-            if self.blocks_remaining == 0 {
-                if let Some(blocked) = self.blocked.take() {
-                    let _ = blocked.send(());
-                }
-                return Poll::Pending;
-            }
-
-            if self.blocks_remaining == 1
-                && let Some(final_block) = self.final_block.take()
-            {
-                let _ = final_block.send(());
-            }
-            self.blocks_remaining -= 1;
-            buf.put_slice(&self.block);
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    impl Drop for BlocksThenPendingReader {
-        fn drop(&mut self) {
-            if let Some(dropped) = self.dropped.take() {
-                let _ = dropped.send(());
-            }
-        }
-    }
+    use tokio::io::{AsyncWrite, AsyncWriteExt};

    fn erasure_with_zero_block_size() -> Erasure {
        let mut erasure = Erasure::default();
@@ -1057,54 +897,6 @@ mod tests {
        }
    }

-    struct FailAfterReaderBlocksWriter {
-        reader_blocked: oneshot::Receiver<()>,
-        writes: Arc<std::sync::atomic::AtomicUsize>,
-    }
-
-    impl AsyncWrite for FailAfterReaderBlocksWriter {
-        fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, _buf: &[u8]) -> Poll<std::io::Result<usize>> {
-            match Pin::new(&mut self.reader_blocked).poll(cx) {
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(_) => {
-                    self.writes.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-                    Poll::Ready(Err(std::io::Error::other("injected write failure after producer blocks")))
-                }
-            }
-        }
-
-        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    struct StallOnWriteWithSignal {
-        entered: Option<oneshot::Sender<()>>,
-        writes: Arc<std::sync::atomic::AtomicUsize>,
-    }
-
-    impl AsyncWrite for StallOnWriteWithSignal {
-        fn poll_write(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, _buf: &[u8]) -> Poll<std::io::Result<usize>> {
-            self.writes.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-            if let Some(entered) = self.entered.take() {
-                let _ = entered.send(());
-            }
-            Poll::Pending
-        }
-
-        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-    }
-
    #[derive(Clone, Default)]
    struct ShortWriteWriter;

@@ -1254,202 +1046,6 @@ mod tests {
        BitrotWriterWrapper::new(CustomWriter::new_tokio_writer(writer), shard_size, HashAlgorithm::None)
    }

-    #[derive(Clone, Copy)]
-    enum EncodePipeline {
-        Vec,
-        BytesMut,
-        Batched,
-    }
-
-    async fn aborting_encode_drops_blocked_producer(pipeline: EncodePipeline) {
-        const BLOCK_SIZE: usize = 16;
-
-        let gauge_baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
-        let committed = Arc::new(Mutex::new(Vec::new()));
-        let mut writers = vec![Some(bitrot_writer(DeferredCommitWriter::new(committed.clone()), BLOCK_SIZE))];
-        let (reader, entered, dropped) = PendingReader::new();
-        let erasure = Arc::new(Erasure::new(1, 0, BLOCK_SIZE));
-
-        let encode = match pipeline {
-            EncodePipeline::Vec => {
-                tokio::spawn(async move { erasure.encode_with_ingest_mode(reader, &mut writers, 1, false).await })
-            }
-            EncodePipeline::BytesMut => {
-                tokio::spawn(async move { erasure.encode_with_ingest_mode(reader, &mut writers, 1, true).await })
-            }
-            EncodePipeline::Batched => tokio::spawn(async move { erasure.encode_batched(reader, &mut writers, 1).await }),
-        };
-
-        tokio::time::timeout(Duration::from_secs(1), entered)
-            .await
-            .expect("producer should enter the blocked reader before cancellation")
-            .expect("blocked reader should signal entry");
-        encode.abort();
-        assert!(matches!(encode.await, Err(err) if err.is_cancelled()), "encode task should be cancelled");
-        tokio::time::timeout(Duration::from_secs(1), dropped)
-            .await
-            .expect("cancelling encode should drop the producer reader")
-            .expect("blocked reader should signal producer drop");
-        assert!(
-            committed.lock().expect("committed buffer should be lockable").is_empty(),
-            "cancelling before the first encoded block must not make data visible"
-        );
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            gauge_baseline,
-            "cancelling the encode pipeline must preserve the inflight queue gauge"
-        );
-    }
-
-    async fn writer_error_aborts_blocked_producer(pipeline: EncodePipeline) {
-        const BLOCK_SIZE: usize = 16;
-
-        let gauge_baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
-        let blocks_before_pending = match pipeline {
-            EncodePipeline::Batched => encode_batch_block_count(),
-            EncodePipeline::Vec | EncodePipeline::BytesMut => 1,
-        };
-        let (reader, reader_blocked, reader_dropped, _final_block) =
-            BlocksThenPendingReader::new(blocks_before_pending, BLOCK_SIZE);
-        let writes = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let mut writers = vec![Some(bitrot_writer(
-            FailAfterReaderBlocksWriter {
-                reader_blocked,
-                writes: writes.clone(),
-            },
-            BLOCK_SIZE,
-        ))];
-        let erasure = Arc::new(Erasure::new(1, 0, BLOCK_SIZE));
-
-        let result = match pipeline {
-            EncodePipeline::Vec => erasure.encode_with_ingest_mode(reader, &mut writers, 1, false).await,
-            EncodePipeline::BytesMut => erasure.encode_with_ingest_mode(reader, &mut writers, 1, true).await,
-            EncodePipeline::Batched => erasure.encode_batched(reader, &mut writers, 1).await,
-        };
-
-        let err = match result {
-            Ok(_) => panic!("writer quorum failure should fail the encode pipeline"),
-            Err(err) => err,
-        };
-        assert!(err.to_string().contains("Failed to write data"));
-        tokio::time::timeout(Duration::from_secs(1), reader_dropped)
-            .await
-            .expect("writer failure should abort the blocked producer")
-            .expect("blocked producer should signal reader drop");
-        assert_eq!(
-            writes.load(std::sync::atomic::Ordering::SeqCst),
-            1,
-            "writer failure must stop the pipeline before any additional shard write"
-        );
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            gauge_baseline,
-            "writer failure must settle all queued and pending encoded bytes"
-        );
-    }
-
-    async fn aborting_full_queue_settles_pending_send() {
-        const BLOCK_SIZE: usize = 16;
-
-        let gauge_baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
-        let erasure = Arc::new(Erasure::new(1, 0, BLOCK_SIZE));
-        let inflight_blocks = encode_channel_capacity(
-            erasure.shard_size().saturating_mul(erasure.total_shard_count()),
-            erasure_encode_max_inflight_bytes(),
-        );
-        let (reader, _reader_blocked, reader_dropped, final_block) =
-            BlocksThenPendingReader::new(inflight_blocks + 2, BLOCK_SIZE);
-        let (writer_entered_tx, writer_entered) = oneshot::channel();
-        let writes = Arc::new(std::sync::atomic::AtomicUsize::new(0));
-        let mut writers = vec![Some(bitrot_writer(
-            StallOnWriteWithSignal {
-                entered: Some(writer_entered_tx),
-                writes: writes.clone(),
-            },
-            BLOCK_SIZE,
-        ))];
-        let erasure_for_task = erasure.clone();
-        let encode = tokio::spawn(async move { erasure_for_task.encode_with_ingest_mode(reader, &mut writers, 1, false).await });
-
-        tokio::time::timeout(Duration::from_secs(1), writer_entered)
-            .await
-            .expect("consumer should start the first writer call")
-            .expect("stalling writer should signal entry");
-        tokio::time::timeout(Duration::from_secs(1), final_block)
-            .await
-            .expect("producer should supply the block whose send fills the queue")
-            .expect("reader should signal final block");
-
-        let expected_queued_bytes =
-            u64::try_from((inflight_blocks + 1) * BLOCK_SIZE).expect("queued byte count should fit the gauge");
-        tokio::time::timeout(Duration::from_secs(1), async {
-            while rustfs_io_metrics::current_ec_encode_inflight_bytes() < gauge_baseline + expected_queued_bytes {
-                tokio::task::yield_now().await;
-            }
-        })
-        .await
-        .expect("producer should account for the pending send after the queue fills");
-
-        encode.abort();
-        assert!(matches!(encode.await, Err(err) if err.is_cancelled()), "encode task should be cancelled");
-        tokio::time::timeout(Duration::from_secs(1), reader_dropped)
-            .await
-            .expect("cancelling a full queue should abort its producer")
-            .expect("full-queue producer should signal reader drop");
-        assert_eq!(
-            writes.load(std::sync::atomic::Ordering::SeqCst),
-            1,
-            "cancellation must not resume the stalled writer"
-        );
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            gauge_baseline,
-            "cancelling a full queue must settle queued and pending bytes"
-        );
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn cancelling_vec_encode_drops_blocked_producer() {
-        aborting_encode_drops_blocked_producer(EncodePipeline::Vec).await;
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn cancelling_bytesmut_encode_drops_blocked_producer() {
-        aborting_encode_drops_blocked_producer(EncodePipeline::BytesMut).await;
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn cancelling_batched_encode_drops_blocked_producer() {
-        aborting_encode_drops_blocked_producer(EncodePipeline::Batched).await;
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn vec_writer_error_aborts_blocked_producer() {
-        writer_error_aborts_blocked_producer(EncodePipeline::Vec).await;
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn bytesmut_writer_error_aborts_blocked_producer() {
-        writer_error_aborts_blocked_producer(EncodePipeline::BytesMut).await;
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn batched_writer_error_aborts_blocked_producer() {
-        writer_error_aborts_blocked_producer(EncodePipeline::Batched).await;
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn cancelling_full_queue_settles_pending_send() {
-        aborting_full_queue_settles_pending_send().await;
-    }
-
    #[tokio::test]
    async fn helper_writers_cover_flush_and_shutdown_paths() {
        let mut failing_write = FailingWriteWriter;
@@ -1733,99 +1329,25 @@ mod tests {
    }

    #[tokio::test]
-    #[serial_test::serial]
-    async fn queued_inflight_bytes_are_settled_on_all_queue_exit_paths() {
-        let baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
-        let (tx, rx) = mpsc::channel(1);
-        let queued = vec![Bytes::from_static(b"queued")];
-        let queued_bytes = queued_block_bytes(&queued);
+    async fn drain_queued_inflight_bytes_consumes_pending_blocks() {
+        let (tx, mut rx) = mpsc::channel(2);
+        tx.send(vec![Bytes::from_static(b"queued")]).await.unwrap();
+        drop(tx);

-        send_queued(&tx, queued, queued_bytes)
-            .await
-            .expect("first queue entry should fit");
+        drain_queued_inflight_bytes(&mut rx).await;

-        let blocked = vec![Bytes::from_static(b"blocked")];
-        let blocked_bytes = queued_block_bytes(&blocked);
-        {
-            let pending_send = send_queued(&tx, blocked, blocked_bytes);
-            tokio::pin!(pending_send);
-            assert!(
-                futures::poll!(pending_send.as_mut()).is_pending(),
-                "full queue must suspend producer send"
-            );
-        }
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            baseline + u64::try_from(queued_bytes).expect("queue bytes fit the gauge"),
-            "dropping a pending producer send must compensate its bytes"
-        );
-
-        drop(rx);
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            baseline,
-            "dropping the receiver must settle every buffered entry"
-        );
-
-        let rejected = vec![Bytes::from_static(b"rejected")];
-        let rejected_bytes = queued_block_bytes(&rejected);
-        assert!(
-            send_queued(&tx, rejected, rejected_bytes).await.is_err(),
-            "closed receiver must reject a new send"
-        );
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            baseline,
-            "failed sends must compensate their bytes"
-        );
+        assert!(rx.recv().await.is_none());
    }

    #[tokio::test]
-    #[serial_test::serial]
-    async fn queued_batch_entry_settles_bytes_before_handoff() {
-        let baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
-        let (tx, rx) = mpsc::channel(2);
-        let mut rx = rx;
-        let batch = vec![vec![Bytes::from_static(b"queued")], vec![Bytes::from_static(b"batch")]];
-        let batch_bytes = queued_batch_bytes(&batch);
+    async fn drain_queued_batched_inflight_bytes_consumes_pending_batches() {
+        let (tx, mut rx) = mpsc::channel(2);
+        tx.send(vec![vec![Bytes::from_static(b"queued")]]).await.unwrap();
+        drop(tx);

-        send_queued(&tx, batch, batch_bytes).await.expect("batch should be queued");
-        let batch = rx.recv().await.expect("queued batch should be received").into_inner();
-        assert_eq!(batch_bytes, queued_batch_bytes(&batch));
+        drain_queued_batched_inflight_bytes(&mut rx).await;

-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            baseline,
-            "receiving a batch must settle all contained block bytes before shard writes"
-        );
-    }
-
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn queued_entry_settles_when_a_closed_receiver_accepts_an_outstanding_permit() {
-        let baseline = rustfs_io_metrics::current_ec_encode_inflight_bytes();
-        let (tx, mut rx) = mpsc::channel(1);
-        let permit = tx
-            .clone()
-            .reserve_owned()
-            .await
-            .expect("open receiver should reserve queue capacity");
-        rx.close();
-        assert!(
-            matches!(rx.try_recv(), Err(mpsc::error::TryRecvError::Empty)),
-            "an outstanding permit must leave the closed queue observably empty"
-        );
-
-        let block = vec![Bytes::from_static(b"late-permit")];
-        let block_bytes = queued_block_bytes(&block);
-        permit.send(InflightEntry::new(block, block_bytes));
-        drop(rx);
-
-        assert_eq!(
-            rustfs_io_metrics::current_ec_encode_inflight_bytes(),
-            baseline,
-            "a queue entry sent through an outstanding permit must settle when Tokio drops it"
-        );
+        assert!(rx.recv().await.is_none());
    }

    #[tokio::test]
@@ -640,7 +640,7 @@ impl Erasure {
    /// # Returns
    /// A vector of encoded shards as `Bytes`.
    #[tracing::instrument(level = "debug", skip_all, fields(data_len=data.len()))]
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub fn encode_data(&self, data: &[u8]) -> io::Result<Vec<Bytes>> {
        let shard_size_fn = if self.uses_legacy {
            calc_shard_size_legacy
@@ -688,7 +688,7 @@ impl Erasure {

    /// Encode owned data, avoiding a copy when the caller already has a heap buffer.
    /// Falls back to copying into a new buffer if zero-copy conversion fails.
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub fn encode_data_owned(&self, data: Vec<u8>) -> io::Result<Vec<Bytes>> {
        let shard_size_fn = if self.uses_legacy {
            calc_shard_size_legacy
@@ -752,7 +752,7 @@ impl Erasure {
    /// block), the `resize(need_total_size)` below stays within capacity for every
    /// `data_len <= block_size` — both shard-size formulas are monotone in
    /// `data_len` — so this function never reallocates the buffer.
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub fn encode_data_bytes_mut(&self, mut data_buffer: BytesMut, data_len: usize) -> io::Result<Vec<Bytes>> {
        let shard_size_fn = if self.uses_legacy {
            calc_shard_size_legacy
@@ -805,7 +805,7 @@ impl Erasure {
    ///
    /// # Returns
    /// Ok if reconstruction succeeds, error otherwise.
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub fn decode_data(&self, shards: &mut [Option<Vec<u8>>]) -> io::Result<()> {
        if self.parity_shards > 0 {
            if self.uses_legacy {
@@ -825,7 +825,7 @@ impl Erasure {
    }

    /// Decode and reconstruct missing data shards, then regenerate parity shards.
-    #[hotpath::measure(impl_type = "Erasure")]
+    #[cfg_attr(feature = "hotpath", hotpath::measure)]
    pub fn decode_data_and_parity(&self, shards: &mut [Option<Vec<u8>>]) -> io::Result<()> {
        if self.parity_shards > 0 {
            if self.uses_legacy {
@@ -19,8 +19,6 @@ use crate::diagnostics::get::{
    GET_STAGE_READER_MMAP_PATH_RESOLVE, GET_STAGE_READER_OPEN_MMAP_COPY_FALLBACK, GET_STAGE_READER_OPEN_MMAP_COPY_SUCCESS,
    GET_STAGE_READER_OPEN_STREAM, GET_STAGE_READER_STREAM_FIRST_READ, record_get_stage_duration_if_enabled,
 };
-#[cfg(feature = "hotpath")]
-use crate::disk::FileWriter;
 use crate::disk::{self, DiskAPI as _, DiskStore, FileReader, MmapCopyStageMetrics, error::DiskError};
 use crate::erasure::coding::{BitrotReader, BitrotWriterWrapper, CustomWriter};
 use bytes::Bytes;
@@ -38,11 +36,6 @@ use std::time::Instant;
 use tokio::io::{AsyncRead, ReadBuf};
 use tracing::debug;

-#[cfg(all(test, feature = "hotpath"))]
-tokio::task_local! {
-    static FORCE_MMAP_COPY_FAILURE_FOR_TEST: ();
-}
-
 /// A shard source for the bitrot reader.
 ///
 /// `InMemory` keeps the `Bytes` concrete instead of erasing it behind
@@ -367,21 +360,10 @@ async fn open_disk_reader(
            mmap_copy_stage: GET_STAGE_READER_MMAP_COPY_BUFFER,
            direct_read_copy_stage: GET_STAGE_READER_MMAP_DIRECT_READ_COPY,
        });
-        let mmap_result = {
-            #[cfg(all(test, feature = "hotpath"))]
-            if FORCE_MMAP_COPY_FAILURE_FOR_TEST.try_with(|_| ()).is_ok() {
-                Err(DiskError::other("forced mmap-copy failure for test"))
-            } else {
-                disk.read_file_mmap_copy_with_metrics(bucket, path, offset, length, mmap_metrics)
-                    .await
-            }
-            #[cfg(not(all(test, feature = "hotpath")))]
-            {
-                disk.read_file_mmap_copy_with_metrics(bucket, path, offset, length, mmap_metrics)
-                    .await
-            }
-        };
-        match mmap_result {
+        match disk
+            .read_file_mmap_copy_with_metrics(bucket, path, offset, length, mmap_metrics)
+            .await
+        {
            Ok(bytes) => {
                let duration_ms = zero_copy_start.elapsed().as_secs_f64() * 1000.0;

@@ -416,11 +398,7 @@ async fn open_disk_reader(
                }

                return match stream_result {
-                    Ok(reader) => {
-                        #[cfg(feature = "hotpath")]
-                        let reader = instrument_raw_shard_reader(reader, disk.is_local());
-                        Ok(wrap_first_read_metrics(reader, metrics_path))
-                    }
+                    Ok(reader) => Ok(wrap_first_read_metrics(reader, metrics_path)),
                    Err(_) => Err(err),
                };
            }
@@ -429,8 +407,6 @@ async fn open_disk_reader(

    let stream_start = stage_metrics_enabled.then(Instant::now);
    let reader = disk.read_file_stream(bucket, path, offset, length).await?;
-    #[cfg(feature = "hotpath")]
-    let reader = instrument_raw_shard_reader(reader, disk.is_local());
    if let Some(metrics_path) = metrics_path {
        record_get_stage_duration_if_enabled(metrics_path, GET_STAGE_READER_OPEN_STREAM, stream_start);
    }
@@ -451,37 +427,6 @@ fn wrap_first_read_metrics(reader: FileReader, metrics_path: Option<&'static str
    ShardReader::Stream(reader)
 }

-// The labels are deliberately fixed: object keys, disk paths, and remote hosts
-// are all high-cardinality or sensitive and belong nowhere in a profiling report.
-#[cfg(feature = "hotpath")]
-const RAW_SHARD_READ_LOCAL_LABEL: &str = "EC raw shard read local";
-#[cfg(feature = "hotpath")]
-const RAW_SHARD_READ_REMOTE_LABEL: &str = "EC raw shard read remote";
-#[cfg(feature = "hotpath")]
-const RAW_SHARD_WRITE_LOCAL_LABEL: &str = "EC raw shard write local";
-#[cfg(feature = "hotpath")]
-const RAW_SHARD_WRITE_REMOTE_LABEL: &str = "EC raw shard write remote";
-
-#[cfg(feature = "hotpath")]
-fn instrument_raw_shard_reader(reader: FileReader, is_local: bool) -> FileReader {
-    // `io!` aggregates by call site, so the local and remote branches must remain distinct.
-    if is_local {
-        Box::new(hotpath::io!(reader, label = RAW_SHARD_READ_LOCAL_LABEL))
-    } else {
-        Box::new(hotpath::io!(reader, label = RAW_SHARD_READ_REMOTE_LABEL))
-    }
-}
-
-#[cfg(feature = "hotpath")]
-fn instrument_raw_shard_writer(writer: FileWriter, is_local: bool) -> FileWriter {
-    // `io!` aggregates by call site, so the local and remote branches must remain distinct.
-    if is_local {
-        Box::new(hotpath::io!(writer, label = RAW_SHARD_WRITE_LOCAL_LABEL))
-    } else {
-        Box::new(hotpath::io!(writer, label = RAW_SHARD_WRITE_REMOTE_LABEL))
-    }
-}
-
 fn bitrot_encoded_range(offset: usize, length: usize, shard_size: usize, checksum_algo: HashAlgorithm) -> (usize, usize) {
    (
        offset.div_ceil(shard_size) * checksum_algo.size() + offset,
@@ -741,8 +686,6 @@ pub async fn create_bitrot_writer(
        };

        let file = disk.create_file("", volume, path, length).await?;
-        #[cfg(feature = "hotpath")]
-        let file = instrument_raw_shard_writer(file, disk.is_local());
        CustomWriter::new_tokio_writer(file)
    } else {
        return Err(DiskError::DiskNotFound);
@@ -755,182 +698,6 @@ pub async fn create_bitrot_writer(
 mod tests {
    use super::*;

-    #[cfg(feature = "hotpath")]
-    use crate::cluster::rpc::RemoteDisk;
-    #[cfg(feature = "hotpath")]
-    use crate::cluster::rpc::internode_data_transport::{
-        InternodeDataTransport, InternodeDataTransportCapabilities, ReadStreamRequest, WalkDirStreamRequest, WriteStreamRequest,
-    };
-    #[cfg(feature = "hotpath")]
-    use crate::disk::{Disk, DiskOption, error::Result};
-
-    #[cfg(feature = "hotpath")]
-    #[derive(Debug, Clone, Default)]
-    struct TestRemoteDataTransport {
-        bytes: Arc<Mutex<Vec<u8>>>,
-    }
-
-    #[cfg(feature = "hotpath")]
-    impl TestRemoteDataTransport {
-        fn bytes(&self) -> Vec<u8> {
-            self.bytes
-                .lock()
-                .expect("test remote transport bytes lock should not be poisoned")
-                .clone()
-        }
-    }
-
-    #[cfg(feature = "hotpath")]
-    #[derive(Debug)]
-    struct TestRemoteWriter {
-        bytes: Arc<Mutex<Vec<u8>>>,
-    }
-
-    #[cfg(feature = "hotpath")]
-    impl tokio::io::AsyncWrite for TestRemoteWriter {
-        fn poll_write(self: Pin<&mut Self>, _cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
-            self.bytes
-                .lock()
-                .expect("test remote transport bytes lock should not be poisoned")
-                .extend_from_slice(buf);
-            Poll::Ready(Ok(buf.len()))
-        }
-
-        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    #[cfg(feature = "hotpath")]
-    #[async_trait::async_trait]
-    impl InternodeDataTransport for TestRemoteDataTransport {
-        async fn open_read(&self, _request: ReadStreamRequest) -> Result<FileReader> {
-            Ok(Box::new(Cursor::new(self.bytes())))
-        }
-
-        async fn open_write(&self, _request: WriteStreamRequest) -> Result<FileWriter> {
-            Ok(Box::new(TestRemoteWriter {
-                bytes: Arc::clone(&self.bytes),
-            }))
-        }
-
-        async fn open_walk_dir(&self, _request: WalkDirStreamRequest) -> Result<FileReader> {
-            panic!("open_walk_dir must not be used by the raw shard I/O test")
-        }
-
-        fn name(&self) -> &'static str {
-            "bitrot-test-remote"
-        }
-
-        fn capabilities(&self) -> InternodeDataTransportCapabilities {
-            InternodeDataTransportCapabilities::tcp_http()
-        }
-    }
-
-    async fn local_test_disk() -> (DiskStore, tempfile::TempDir) {
-        use crate::disk::endpoint::Endpoint;
-        use crate::disk::{DiskOption, new_disk};
-
-        let dir = tempfile::tempdir().expect("tempdir should be created");
-        let mut endpoint =
-            Endpoint::try_from(dir.path().to_str().expect("tempdir path should be utf8")).expect("endpoint should parse");
-        endpoint.set_pool_index(0);
-        endpoint.set_set_index(0);
-        endpoint.set_disk_index(0);
-        let disk = new_disk(
-            &endpoint,
-            &DiskOption {
-                cleanup: false,
-                health_check: false,
-            },
-        )
-        .await
-        .expect("local disk should be created");
-
-        (disk, dir)
-    }
-
-    #[cfg(feature = "hotpath")]
-    async fn remote_test_disk() -> (DiskStore, TestRemoteDataTransport) {
-        use crate::disk::endpoint::Endpoint;
-
-        let endpoint = Endpoint {
-            url: url::Url::parse("http://remote-node:9000/data/rustfs0").expect("test remote endpoint should parse"),
-            is_local: false,
-            pool_idx: 0,
-            set_idx: 0,
-            disk_idx: 0,
-        };
-        let transport = TestRemoteDataTransport::default();
-        let remote = RemoteDisk::new(
-            &endpoint,
-            &DiskOption {
-                cleanup: false,
-                health_check: false,
-            },
-            Arc::new(transport.clone()),
-        )
-        .await
-        .expect("test remote disk should be created");
-
-        (Arc::new(Disk::Remote(Box::new(remote))), transport)
-    }
-
-    async fn round_trip_disk_bitrot(disk: &DiskStore, bucket: &str, path: &str, payload: &[u8], shard_size: usize) -> Vec<u8> {
-        disk.make_volume(bucket).await.expect("volume should be created");
-        let mut writer = create_bitrot_writer(
-            false,
-            Some(disk),
-            bucket,
-            path,
-            i64::try_from(payload.len()).expect("test payload length should fit i64"),
-            shard_size,
-            HashAlgorithm::None,
-        )
-        .await
-        .expect("disk bitrot writer should open the raw shard file");
-        for chunk in payload.chunks(shard_size) {
-            writer
-                .write(chunk)
-                .await
-                .expect("disk bitrot writer should preserve each shard block");
-        }
-        writer.shutdown().await.expect("disk bitrot writer should close cleanly");
-
-        let mut reader = create_bitrot_reader(
-            None,
-            Some(disk),
-            bucket,
-            path,
-            0,
-            payload.len(),
-            shard_size,
-            HashAlgorithm::None,
-            false,
-            false,
-        )
-        .await
-        .expect("disk bitrot reader should open the raw shard file")
-        .expect("disk bitrot reader should exist");
-        let mut actual = Vec::with_capacity(payload.len());
-        while actual.len() < payload.len() {
-            let remaining = payload.len() - actual.len();
-            let mut chunk = vec![0; remaining.min(shard_size)];
-            let read = reader
-                .read(&mut chunk)
-                .await
-                .expect("disk bitrot reader should return the complete shard body");
-            assert!(read > 0, "disk bitrot reader must not end before the expected shard body is complete");
-            actual.extend_from_slice(&chunk[..read]);
-        }
-
-        actual
-    }
-
    #[test]
    fn object_mmap_read_enabled_accepts_legacy_zero_copy_alias() {
        temp_env::with_vars(
@@ -957,165 +724,6 @@ mod tests {
        );
    }

-    #[cfg(feature = "hotpath")]
-    #[test]
-    fn raw_shard_io_wrappers_report_fixed_labels_and_preserve_bytes() {
-        const CHILD_ENV: &str = "RUSTFS_HOTPATH_RAW_SHARD_IO_TEST_CHILD";
-        if std::env::var_os(CHILD_ENV).is_none() {
-            let status = std::process::Command::new(std::env::current_exe().expect("test executable path should be available"))
-                .arg("--exact")
-                .arg("io_support::bitrot::tests::raw_shard_io_wrappers_report_fixed_labels_and_preserve_bytes")
-                .arg("--nocapture")
-                .env(CHILD_ENV, "1")
-                .status()
-                .expect("isolated HotPath I/O test process should start");
-            assert!(status.success(), "isolated HotPath I/O test process should pass");
-            return;
-        }
-
-        tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("test runtime should be created")
-            .block_on(raw_shard_io_wrappers_report_fixed_labels_and_preserve_bytes_in_isolated_process());
-    }
-
-    #[cfg(feature = "hotpath")]
-    async fn raw_shard_io_wrappers_report_fixed_labels_and_preserve_bytes_in_isolated_process() {
-        use hotpath::{Format, HotpathGuardBuilder, Section};
-        use tokio::io::AsyncReadExt;
-
-        let report_dir = tempfile::tempdir().expect("report tempdir should be created");
-        let report_path = report_dir.path().join("hotpath-io.json");
-        let guard = HotpathGuardBuilder::new("raw_shard_io_test")
-            .format(Format::Json)
-            .output_path(&report_path)
-            .sections(vec![Section::Io])
-            .build();
-
-        let (disk, _dir) = local_test_disk().await;
-        let bucket = "test-bucket";
-        let path = "obj/hotpath-part.1";
-        let payload = b"local shard bytes";
-        let shard_size = 4;
-        let local_read = round_trip_disk_bitrot(&disk, bucket, path, payload, shard_size).await;
-        assert_eq!(local_read, payload, "local raw shard I/O instrumentation must not alter stored bytes");
-
-        let fallback_path = "obj/hotpath-mmap-fallback-part.1";
-        let fallback_payload = b"mmap fallback shard bytes";
-        disk.write_all("test-bucket", fallback_path, Bytes::from_static(fallback_payload))
-            .await
-            .expect("fallback shard file should be written");
-        let mut fallback_reader = FORCE_MMAP_COPY_FAILURE_FOR_TEST
-            .scope((), open_disk_reader(&disk, bucket, fallback_path, 0, fallback_payload.len(), true, None))
-            .await
-            .expect("mmap-copy failure should fall back to a raw shard stream");
-        assert!(
-            matches!(fallback_reader, ShardReader::Stream(_)),
-            "forced mmap-copy failure must use the streaming fallback"
-        );
-        let mut fallback_read = Vec::new();
-        fallback_reader
-            .read_to_end(&mut fallback_read)
-            .await
-            .expect("mmap-copy fallback stream should preserve bytes");
-        assert_eq!(fallback_read, fallback_payload);
-
-        let (remote_disk, remote_transport) = remote_test_disk().await;
-        let remote_payload = b"remote shard bytes";
-        let mut remote_writer = create_bitrot_writer(
-            false,
-            Some(&remote_disk),
-            bucket,
-            "obj/hotpath-remote-part.1",
-            i64::try_from(remote_payload.len()).expect("remote payload length should fit i64"),
-            shard_size,
-            HashAlgorithm::None,
-        )
-        .await
-        .expect("remote bitrot writer should use the production raw writer path");
-        for chunk in remote_payload.chunks(shard_size) {
-            remote_writer
-                .write(chunk)
-                .await
-                .expect("remote bitrot writer should preserve bytes");
-        }
-        remote_writer
-            .shutdown()
-            .await
-            .expect("remote bitrot writer should close cleanly");
-        assert_eq!(remote_transport.bytes(), remote_payload);
-
-        let mut reader = create_bitrot_reader(
-            None,
-            Some(&remote_disk),
-            bucket,
-            "obj/hotpath-remote-part.1",
-            0,
-            remote_payload.len(),
-            shard_size,
-            HashAlgorithm::None,
-            false,
-            true,
-        )
-        .await
-        .expect("remote bitrot reader should use the production raw reader path")
-        .expect("remote bitrot reader should exist");
-        let mut remote_read = Vec::with_capacity(remote_payload.len());
-        while remote_read.len() < remote_payload.len() {
-            let remaining = remote_payload.len() - remote_read.len();
-            let mut chunk = vec![0; remaining.min(shard_size)];
-            let read = reader
-                .read(&mut chunk)
-                .await
-                .expect("remote bitrot reader should preserve bytes");
-            assert!(read > 0, "remote bitrot reader must not end before the expected shard body is complete");
-            remote_read.extend_from_slice(&chunk[..read]);
-        }
-        assert_eq!(remote_read, remote_payload);
-
-        drop(guard);
-        let report = std::fs::read_to_string(&report_path).expect("HotPath I/O report should be written");
-        let report: serde_json::Value = serde_json::from_str(&report).expect("HotPath I/O report should be valid JSON");
-        let entries = report["io"]["data"]
-            .as_array()
-            .expect("HotPath I/O report should include data rows");
-        let io_bytes = |label: &str, direction: &str| {
-            let byte_count: u64 = entries
-                .iter()
-                .filter(|entry| entry["label"].as_str().is_some_and(|entry_label| entry_label == label))
-                .filter_map(|entry| entry[direction]["bytes"].as_u64())
-                .sum();
-            assert!(byte_count > 0, "report must include fixed label {label}");
-            byte_count
-        };
-        let payload_len = u64::try_from(payload.len()).expect("test payload length should fit u64");
-        assert_eq!(
-            io_bytes(RAW_SHARD_READ_LOCAL_LABEL, "read"),
-            payload_len + u64::try_from(fallback_payload.len()).expect("fallback payload length should fit u64")
-        );
-        assert_eq!(io_bytes(RAW_SHARD_WRITE_LOCAL_LABEL, "write"), payload_len);
-        assert_eq!(
-            io_bytes(RAW_SHARD_READ_REMOTE_LABEL, "read"),
-            u64::try_from(remote_payload.len()).expect("remote payload length should fit u64")
-        );
-        assert_eq!(
-            io_bytes(RAW_SHARD_WRITE_REMOTE_LABEL, "write"),
-            u64::try_from(remote_payload.len()).expect("remote payload length should fit u64")
-        );
-        for label in [
-            RAW_SHARD_READ_LOCAL_LABEL,
-            RAW_SHARD_READ_REMOTE_LABEL,
-            RAW_SHARD_WRITE_LOCAL_LABEL,
-            RAW_SHARD_WRITE_REMOTE_LABEL,
-        ] {
-            assert!(
-                !label.contains(['/', ':', '?', '@']),
-                "raw shard I/O labels must not carry a path, host, query, or credential delimiter: {label}"
-            );
-        }
-    }
-
    #[test]
    fn object_mmap_read_max_length_defaults_and_env_override() {
        temp_env::with_var(ENV_OBJECT_MMAP_READ_MAX_LENGTH, None::<&str>, || {
@@ -1133,9 +741,25 @@ mod tests {
    // be materialized in memory by the mmap-copy path; over-cap reads stream.
    #[tokio::test]
    async fn open_disk_reader_streams_when_length_exceeds_mmap_cap() {
+        use crate::disk::endpoint::Endpoint;
+        use crate::disk::{DiskOption, new_disk};
        use tokio::io::AsyncReadExt;

-        let (disk, _dir) = local_test_disk().await;
+        let dir = tempfile::tempdir().expect("tempdir should be created");
+        let mut endpoint =
+            Endpoint::try_from(dir.path().to_str().expect("tempdir path should be utf8")).expect("endpoint should parse");
+        endpoint.set_pool_index(0);
+        endpoint.set_set_index(0);
+        endpoint.set_disk_index(0);
+        let disk = new_disk(
+            &endpoint,
+            &DiskOption {
+                cleanup: false,
+                health_check: false,
+            },
+        )
+        .await
+        .expect("local disk should be created");

        let payload = vec![7u8; 4096];
        disk.make_volume("test-bucket").await.expect("volume should be created");
@@ -1190,17 +814,6 @@ mod tests {
        .await;
    }

-    #[tokio::test]
-    async fn disk_bitrot_reader_and_writer_preserve_full_shard_body() {
-        let (disk, _dir) = local_test_disk().await;
-        let bucket = "test-bucket";
-        let path = "obj/wrapped-part.1";
-        let payload = b"wrapped shard body";
-        let actual = round_trip_disk_bitrot(&disk, bucket, path, payload, 4).await;
-
-        assert_eq!(actual, payload, "raw shard I/O instrumentation must not alter stored bytes");
-    }
-
    #[tokio::test]
    async fn test_create_bitrot_reader_with_inline_data() {
        let test_data = b"hello world test data";
@@ -203,7 +203,7 @@ fn get_all_sets<T: AsRef<str>>(set_drive_count: usize, is_ellipses: bool, args:
    for args in set_args.iter() {
        for arg in args {
            if unique_args.contains(arg) {
-                return Err(Error::other("input arguments contain a duplicate endpoint after ellipsis expansion"));
+                return Err(Error::other(format!("Input args {arg} has duplicate ellipses")));
            }
            unique_args.insert(arg);
        }
@@ -924,15 +924,4 @@ mod test {
            }
        }
    }
-
-    #[test]
-    fn layout_errors_do_not_echo_url_credentials() {
-        for volumes in [
-            vec!["http://:duplicate-secret@server/path", "http://:duplicate-secret@server/path"],
-            vec!["http://:ellipsis...secret@server/path"],
-        ] {
-            let err = DisksLayout::from_volumes(&volumes).unwrap_err();
-            assert!(!err.to_string().contains("secret"), "layout error leaked endpoint credentials: {err}");
-        }
-    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
overtrue	30c6f8a9ce	fix(data-usage): make empty checks exhaustive	2026-07-29 16:11:42 +08:00
overtrue	c77c9875c6	fix(data-usage): preserve nonempty replication stats	2026-07-29 15:17:50 +08:00