ci: correct the companion-workflow comments

The ci-docs-only header claimed the ruleset already requires "Quick Checks"; it does not, and this PR deliberately leaves it that way. Say what is true today and why the job is mirrored ahead of the ruleset change. Also move the byte-identical requirement onto ci.yml's quick-checks job, which is the more likely edit site, instead of pointing at a comment that was not there.
ci: stop running expensive jobs that cannot inform the result
2026-08-01 11:02:14 +00:00 · 2026-08-01 10:49:34 +08:00 · 2026-08-01 10:41:35 +08:00
75 changed files with 581 additions and 6200 deletions
@@ -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,7 +86,6 @@ 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
@@ -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: |
@@ -39,12 +39,7 @@ on:
      - '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 +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."
@@ -80,30 +74,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:
-          cache-all-crates: true
-          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
@@ -121,28 +96,16 @@ 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
@@ -150,8 +113,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
@@ -164,28 +125,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
@@ -173,7 +164,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 +171,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 +245,6 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Setup Rust environment
@@ -268,17 +253,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 +702,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 }}"
@@ -774,7 +746,7 @@ jobs:
          echo "🐳 Docker Images:"
          if [[ "$BUILD_TYPE" == "preview" ]]; then
            echo "⏭️  Preview tags do not publish Docker images"
-          elif [[ "$INPUT_BUILD_DOCKER" == "false" ]]; then
+          elif [[ "${{ 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"
@@ -788,7 +760,6 @@ jobs:
    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')
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    permissions:
      contents: write
    outputs:
@@ -798,7 +769,6 @@ jobs:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
        with:
-          persist-credentials: false
          fetch-depth: 0

      - name: Create GitHub Release
@@ -849,15 +819,12 @@ jobs:
    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')
    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
@@ -943,7 +910,6 @@ jobs:
    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')
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    steps:
      - name: Update latest.json
        env:
@@ -1003,7 +969,6 @@ jobs:
    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')
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    permissions:
      contents: write
    steps:
@@ -1,231 +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'
-
-      # --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.
-      # 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
-
-      - 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
-
-  # 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
@@ -23,8 +23,8 @@
 # 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
+# required too (rustfs/backlog#1599). It is not required yet, so today this job
+# is inert; adding it first is what lets that ruleset change land without
 # stranding docs-only PRs on a check nobody reports.
 #
 # Keep the paths list below in sync with the pull_request paths-ignore list
@@ -53,7 +53,6 @@ on:
      - ".github/workflows/build.yml"
      - ".github/workflows/docker.yml"
      - ".github/workflows/audit.yml"
-      - "flake.lock"

 permissions:
  contents: read
@@ -79,8 +78,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
@@ -114,12 +111,6 @@ 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
    runs-on: ubuntu-latest
@@ -127,8 +118,6 @@ jobs:
    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,11 +89,8 @@ 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

@@ -114,8 +108,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 +141,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,14 +173,8 @@ 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:
@@ -221,8 +183,33 @@ jobs:
          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
+          # Evidence sampler for issue #5394: the post-mortem pgrep below runs
+          # only after `timeout` has already TERM'd the whole cargo process
+          # group, so it cannot name a wedged process. Sample system and
+          # process state every 60s instead; the last samples before the
+          # timeout show what was stuck (rustc, linker, build script, memory
+          # pressure, ...). The log rides along in the existing artifact.
+          (
+            while true; do
+              {
+                echo "=== $(date --utc --iso-8601=seconds)"
+                echo "--- load";  cat /proc/loadavg
+                echo "--- psi";   grep -H . /proc/pressure/* 2>/dev/null || true
+                echo "--- mem";   free -m
+                echo "--- disk";  df -h / /home/runner 2>/dev/null || df -h /
+                echo "--- top-rss"
+                ps -eo pid,ppid,stat,etime,rss,pcpu,args --sort=-rss | head -15
+                echo "--- build/test processes"
+                ps -eo pid,ppid,stat,etime,rss,pcpu,args | grep -E '[c]argo|[r]ustc|[n]extest|[c]ollect2|rust-ll[d]|[b]uild-script|deps[/]' || true
+                echo "--- d-state (uninterruptible IO)"
+                ps -eo pid,stat,etime,args | awk 'NR > 1 && $2 ~ /D/' || true
+                echo
+              } >> artifacts/test-and-lint/sampler.log 2>&1 || true
+              sleep 60
+            done
+          ) &
+          sampler_pid=$!
+          trap 'kill "${sampler_pid}" 2>/dev/null || true' 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 \
@@ -294,48 +281,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 +294,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 +301,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 +331,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 +338,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 +358,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 +373,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 +393,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,16 +400,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-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
@@ -496,7 +423,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,16 +430,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-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
@@ -535,7 +459,6 @@ jobs:
    # 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 +469,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 +506,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 +516,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 +524,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 +600,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 +643,6 @@ jobs:
    steps:
      - name: Checkout repository
        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          persist-credentials: false

      - name: Clean up previous test run
        run: |
@@ -797,8 +697,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
@@ -871,8 +769,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
@@ -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:
@@ -85,7 +85,6 @@ jobs:
       github.event.workflow_run.head_branch != 'main' &&
       !contains(github.event.workflow_run.head_branch, '-preview'))
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    outputs:
      should_build: ${{ steps.check.outputs.should_build }}
      should_push: ${{ steps.check.outputs.should_push }}
@@ -98,18 +97,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 +202,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 +212,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
@@ -306,8 +298,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 +333,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 +412,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 +439,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 +493,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,7 +32,6 @@ permissions:
 jobs:
  build-helm-package:
    runs-on: ubuntu-latest
-    timeout-minutes: 30
    if: |
      (github.event_name == 'workflow_dispatch' && !contains(github.event.inputs.version, '-preview')) ||
      (
@@ -50,26 +49,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 +73,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 +101,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 +108,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 +123,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:
@@ -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:
@@ -9523,7 +9523,6 @@ dependencies = [
 "moka",
 "rand 0.10.2",
 "reqwest",
- "rustfs-s3-types",
 "rustfs-security-governance",
 "rustfs-utils",
 "rustify",
@@ -10028,7 +10027,6 @@ dependencies = [
 "rustfs-data-usage",
 "rustfs-ecstore",
 "rustfs-filemeta",
- "rustfs-lock",
 "rustfs-storage-api",
 "rustfs-utils",
 "s3s",
@@ -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,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())
@@ -382,6 +382,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 +408,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 +1276,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 +1347,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);
@@ -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(())
@@ -6641,49 +6641,6 @@ impl LocalDisk {
        let xl_path = object_dir.join(STORAGE_FORMAT_FILE);
        restore_delete_rollback_after_error(object_dir, &xl_path, Some(rollback_dir), volume, object, stage, err).await
    }
-
-    /// Execute every deferred data-dir deletion pending on `volume` right now,
-    /// even while snapshot leases are still held. Bucket deletion requires it:
-    /// a streaming reader defers the physical cleanup of an already-deleted
-    /// version, and a non-force `delete_volume` would otherwise fail closed
-    /// with `VolumeNotEmpty` on those remnants even though the bucket is
-    /// logically empty. The still-active readers keep their open descriptors;
-    /// only path-based reopens observe the removal.
-    async fn settle_pending_snapshot_deletes(&self, volume: &str) {
-        let pending: Vec<(SnapshotLeaseKey, DeleteOptions)> = {
-            let mut registry = self.snapshot_leases.lock().await;
-            registry
-                .entries
-                .iter_mut()
-                .filter(|(key, entry)| key.volume == volume && !entry.deleting && entry.pending_delete.is_some())
-                .map(|(key, entry)| {
-                    entry.deleting = true;
-                    (key.clone(), entry.pending_delete.clone().expect("filtered on Some"))
-                })
-                .collect()
-        };
-
-        for (key, opts) in pending {
-            let result = self.delete_unleased(&key.volume, &key.path, &opts).await;
-            let mut registry = self.snapshot_leases.lock().await;
-            match result {
-                Ok(()) => {
-                    registry.entries.remove(&key);
-                }
-                Err(err) => {
-                    if let Some(entry) = registry.entries.get_mut(&key) {
-                        entry.deleting = false;
-                    }
-                    warn!(
-                        volume = %key.volume,
-                        path = %key.path,
-                        error = %err,
-                        "failed to settle deferred data-dir deletion before volume removal"
-                    );
-                }
-            }
-        }
-    }
 }

 #[async_trait::async_trait]
@@ -9165,14 +9122,6 @@ impl DiskAPI for LocalDisk {
        let p = self.get_bucket_path(volume)?;
        let _volume_mutation_guard = os::disk_volume_mutation_lock(&self.root, volume).write_owned().await;

-        // A streaming reader's snapshot lease defers the physical cleanup of
-        // data dirs whose version delete already committed. Those remnants are
-        // logically deleted, so run the parked cleanups now instead of letting
-        // the non-force removal below fail closed on them (the s3-tests SSE-C
-        // teardown races exactly this way: DeleteObjects, then DeleteBucket
-        // while an abandoned GET body still pins the lease).
-        self.settle_pending_snapshot_deletes(volume).await;
-
        // Non-force removes empty directory remnants children-first with
        // non-recursive rmdir calls. A file that exists during the scan, or
        // appears before its parent is removed, fails closed with
@@ -16032,74 +15981,6 @@ mod test {
        assert!(matches!(disk.read_all(volume, &first_part).await, Err(DiskError::FileNotFound)));
    }

-    #[tokio::test]
-    async fn delete_volume_settles_lease_deferred_cleanup() {
-        use tempfile::tempdir;
-
-        let root_dir = tempdir().expect("temp dir should be created");
-        let endpoint = Endpoint::try_from(root_dir.path().to_string_lossy().as_ref()).expect("endpoint should parse");
-        let disk = LocalDisk::new(&endpoint, false).await.expect("local disk should be created");
-        let volume = "snapshot-lease-bucket-delete";
-        let object = "multipart_enc";
-        let version_id = Uuid::new_v4();
-        let data_dir = Uuid::new_v4();
-        let rollback_dir = Uuid::new_v4();
-        let data_path = path_join_buf(&[object, &data_dir.to_string()]);
-        let part = path_join_buf(&[&data_path, "part.1"]);
-        ensure_test_volume(&disk, volume).await;
-        disk.write_all(volume, &part, Bytes::from_static(b"payload"))
-            .await
-            .expect("shard should be written");
-        let fi = test_file_info(object, version_id, Some(data_dir), None);
-        disk.write_all(volume, &path_join_buf(&[object, STORAGE_FORMAT_FILE]), test_meta(fi.clone()).into())
-            .await
-            .expect("metadata should be written");
-
-        // An abandoned streaming GET pins the data dir with a snapshot lease.
-        let snapshot = disk
-            .acquire_snapshot_lease(volume, &data_path)
-            .await
-            .expect("snapshot lease should be acquired");
-        disk.delete_version(
-            volume,
-            object,
-            fi.clone(),
-            false,
-            DeleteOptions {
-                old_data_dir: Some(rollback_dir),
-                ..Default::default()
-            },
-        )
-        .await
-        .expect("version delete should commit metadata");
-        disk.delete(
-            volume,
-            &format!("{object}/{rollback_dir}"),
-            DeleteOptions {
-                recursive: true,
-                immediate: true,
-                ..Default::default()
-            },
-        )
-        .await
-        .expect("version delete should schedule physical cleanup");
-
-        // The bucket is logically empty; a non-force volume delete must settle
-        // the deferred data-dir cleanup instead of failing with VolumeNotEmpty.
-        disk.delete_volume(volume, false)
-            .await
-            .expect("bucket delete must not observe lease-deferred remnants");
-        assert!(matches!(
-            disk.read_all(volume, &part).await,
-            Err(DiskError::FileNotFound | DiskError::VolumeNotFound)
-        ));
-
-        // The late lease release finds nothing pending and stays idempotent.
-        disk.release_snapshot_lease(volume, &data_path, snapshot)
-            .await
-            .expect("releasing the lease after bucket deletion should be a no-op");
-    }
-
    #[tokio::test]
    async fn version_delete_cleanup_intent_survives_local_disk_restart() {
        use tempfile::tempdir;
@@ -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);
@@ -22,8 +22,6 @@ use rustfs_config::{
    ENV_STARTUP_TOPOLOGY_WAIT_MODE, ENV_STARTUP_TOPOLOGY_WAIT_TIMEOUT, ENV_UNSAFE_BYPASS_DISK_CHECK,
 };
 use rustfs_utils::{XHost, check_local_server_addr, get_env_opt_str, get_host_ip, is_local_host};
-#[cfg(test)]
-use std::sync::{LazyLock, Mutex};
 use std::{
    collections::{BTreeMap, BTreeSet, HashMap, HashSet, hash_map::Entry},
    future::Future,
@@ -600,58 +598,6 @@ const DNS_RETRY_JITTER_PERCENT: u64 = 20;
 /// wait does not flood the log with one line per backoff tick.
 const TOPOLOGY_WARN_THROTTLE: Duration = Duration::from_secs(30);

-#[cfg(test)]
-static FORCED_LOCAL_HOST_RESOLUTION_TIMEOUTS: LazyLock<Mutex<HashSet<String>>> = LazyLock::new(|| Mutex::new(HashSet::new()));
-
-#[cfg(test)]
-struct LocalHostResolutionTimeoutGuard {
-    hosts: Vec<String>,
-}
-
-#[cfg(test)]
-impl Drop for LocalHostResolutionTimeoutGuard {
-    fn drop(&mut self) {
-        let mut forced_hosts = FORCED_LOCAL_HOST_RESOLUTION_TIMEOUTS
-            .lock()
-            .expect("local-host test resolver mutex poisoned");
-        for host in &self.hosts {
-            forced_hosts.remove(host);
-        }
-    }
-}
-
-#[cfg(test)]
-fn force_local_host_resolution_timeout_for_test(hosts: &[&str]) -> LocalHostResolutionTimeoutGuard {
-    let hosts = hosts.iter().map(|host| (*host).to_string()).collect::<Vec<_>>();
-    let mut forced_hosts = FORCED_LOCAL_HOST_RESOLUTION_TIMEOUTS
-        .lock()
-        .expect("local-host test resolver mutex poisoned");
-    forced_hosts.extend(hosts.iter().cloned());
-    LocalHostResolutionTimeoutGuard { hosts }
-}
-
-#[cfg(test)]
-fn local_host_resolution_timeout_forced(host: &Host<&str>) -> bool {
-    let host = match host {
-        Host::Domain(domain) => (*domain).to_string(),
-        Host::Ipv4(ip) => ip.to_string(),
-        Host::Ipv6(ip) => ip.to_string(),
-    };
-    FORCED_LOCAL_HOST_RESOLUTION_TIMEOUTS
-        .lock()
-        .expect("local-host test resolver mutex poisoned")
-        .contains(&host)
-}
-
-fn endpoint_is_local_host(host: Host<&str>, port: u16, local_port: u16) -> Result<bool> {
-    #[cfg(test)]
-    if local_host_resolution_timeout_forced(&host) {
-        return Err(Error::new(ErrorKind::TimedOut, "resolver timeout"));
-    }
-
-    is_local_host(host, port, local_port)
-}
-
 struct DnsRetryDeadline {
    started: Instant,
    timeout: Duration,
@@ -748,7 +694,7 @@ async fn resolve_local_host_with_retry(
    retry_dns_operation(
        || {
            let host = host.clone();
-            async move { endpoint_is_local_host(host, port, local_port) }
+            async move { is_local_host(host, port, local_port) }
        },
        async_sleep,
        dns_retry_deadline,
@@ -2285,9 +2231,6 @@ mod test {
    #[serial]
    #[tokio::test]
    async fn create_server_endpoints_bounds_kubernetes_alias_dns_fallback() {
-        let _resolution_timeout =
-            force_local_host_resolution_timeout_for_test(&["unrelated-0.example.invalid", "unrelated-1.example.invalid"]);
-
        async_with_vars(
            [
                (ENV_LOCAL_ENDPOINT_HOST, None),
@@ -4861,7 +4861,10 @@ async fn poll_merge_head(rx: &CancellationToken, in_channels: &mut [Receiver<Met

 async fn send_or_cancel(rx: &CancellationToken, out_channel: &Sender<MetaCacheEntry>, entry: MetaCacheEntry) -> Result<bool> {
    tokio::select! {
-        result = out_channel.send(entry) => Ok(result.is_ok()),
+        result = out_channel.send(entry) => {
+            result.map_err(Error::other)?;
+            Ok(true)
+        }
        _ = rx.cancelled() => Ok(false),
    }
 }
@@ -9855,28 +9858,6 @@ mod test {
        assert_eq!(results, vec!["obj-a", "obj-b"]);
    }

-    #[tokio::test]
-    async fn merge_entry_channels_treats_dropped_output_receiver_as_completion() {
-        let (tx_a, rx_a) = mpsc::channel(4);
-        let (tx_b, rx_b) = mpsc::channel(4);
-        let (out_tx, out_rx) = mpsc::channel(1);
-
-        tx_a.send(test_meta_entry("obj-a")).await.unwrap();
-        tx_b.send(test_meta_entry("obj-b")).await.unwrap();
-        drop(tx_a);
-        drop(tx_b);
-        drop(out_rx);
-
-        let result = timeout(
-            Duration::from_secs(1),
-            merge_entry_channels(CancellationToken::new(), vec![rx_a, rx_b], out_tx, 1),
-        )
-        .await
-        .expect("merge should stop promptly when its consumer disconnects");
-
-        assert!(result.is_ok(), "consumer disconnect must not surface as a merge worker error");
-    }
-
    #[test]
    fn walk_ascending_versions_contract_reverses_newest_first_metadata() {
        // Documents the invariant the walk `versions_sort` handling relies on:
@@ -41,7 +41,7 @@ use rustfs_policy::policy::Args;
 use rustfs_policy::policy::opa;
 use rustfs_policy::policy::{Policy, PolicyDoc, iam_policy_claim_name_sa, policy_needs_existing_object_tag_for_args};
 use serde_json::Value;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use time::OffsetDateTime;
@@ -61,45 +61,10 @@ const VERIFIED_FEDERATED_POLICY_CLAIM: &str = "x-rustfs-internal-federated-polic
 const FEDERATED_POLICY_BOUNDARY_CLAIM: &str = "x-rustfs-internal-federated-boundary";
 pub(crate) const SITE_REPLICATOR_CLAIM: &str = "site-replicator";

-#[derive(Clone)]
-enum PolicyPluginState {
-    Disabled,
-    Initializing,
-    Ready(opa::AuthZPlugin),
-    Failed,
-}
+static POLICY_PLUGIN_CLIENT: OnceLock<Arc<RwLock<Option<rustfs_policy::policy::opa::AuthZPlugin>>>> = OnceLock::new();

-static POLICY_PLUGIN_STATE: OnceLock<Arc<RwLock<PolicyPluginState>>> = OnceLock::new();
-
-fn get_policy_plugin_state() -> Arc<RwLock<PolicyPluginState>> {
-    POLICY_PLUGIN_STATE
-        .get_or_init(|| {
-            let configured = opa::is_configured();
-            let state = Arc::new(RwLock::new(if configured {
-                PolicyPluginState::Initializing
-            } else {
-                PolicyPluginState::Disabled
-            }));
-            if configured {
-                let state = Arc::clone(&state);
-                tokio::spawn(async move {
-                    let next_state = match opa::lookup_config().await {
-                        Ok(conf) if conf.enable() => {
-                            info!("OPA plugin enabled");
-                            PolicyPluginState::Ready(opa::AuthZPlugin::new(conf))
-                        }
-                        Ok(_) => PolicyPluginState::Failed,
-                        Err(e) => {
-                            error!("Error loading OPA configuration err:{}", e);
-                            PolicyPluginState::Failed
-                        }
-                    };
-                    *state.write().await = next_state;
-                });
-            }
-            state
-        })
-        .clone()
+fn get_policy_plugin_client() -> Arc<RwLock<Option<rustfs_policy::policy::opa::AuthZPlugin>>> {
+    POLICY_PLUGIN_CLIENT.get_or_init(|| Arc::new(RwLock::new(None))).clone()
 }

 pub struct IamSys<T> {
@@ -208,7 +173,19 @@ impl<T: Store> IamSys<T> {
    /// # Returns
    /// A new instance of IamSys
    pub fn new(store: Arc<IamCache<T>>) -> Self {
-        get_policy_plugin_state();
+        tokio::spawn(async move {
+            match opa::lookup_config().await {
+                Ok(conf) => {
+                    if conf.enable() {
+                        Self::set_policy_plugin_client(opa::AuthZPlugin::new(conf)).await;
+                        info!("OPA plugin enabled");
+                    }
+                }
+                Err(e) => {
+                    error!("Error loading OPA configuration err:{}", e);
+                }
+            };
+        });

        Self {
            store,
@@ -229,22 +206,15 @@ impl<T: Store> IamSys<T> {
    }

    pub async fn set_policy_plugin_client(client: rustfs_policy::policy::opa::AuthZPlugin) {
-        let policy_plugin_state = get_policy_plugin_state();
-        let mut guard = policy_plugin_state.write().await;
-        *guard = PolicyPluginState::Ready(client);
+        let policy_plugin_client = get_policy_plugin_client();
+        let mut guard = policy_plugin_client.write().await;
+        *guard = Some(client);
    }

    pub async fn get_policy_plugin_client() -> Option<rustfs_policy::policy::opa::AuthZPlugin> {
-        let policy_plugin_state = get_policy_plugin_state();
-        let guard = policy_plugin_state.read().await;
-        match &*guard {
-            PolicyPluginState::Ready(client) => Some(client.clone()),
-            PolicyPluginState::Disabled | PolicyPluginState::Initializing | PolicyPluginState::Failed => None,
-        }
-    }
-
-    async fn policy_plugin_state() -> PolicyPluginState {
-        get_policy_plugin_state().read().await.clone()
+        let policy_plugin_client = get_policy_plugin_client();
+        let guard = policy_plugin_client.read().await;
+        guard.clone()
    }

    pub async fn load_group(&self, name: &str) -> Result<()> {
@@ -1090,20 +1060,11 @@ impl<T: Store> IamSys<T> {
            };
        }

-        match Self::policy_plugin_state().await {
-            PolicyPluginState::Ready(_) => {
-                return PreparedIamAuth {
-                    needs_existing_object_tag: false,
-                    mode: PreparedIamMode::Opa,
-                };
-            }
-            PolicyPluginState::Initializing | PolicyPluginState::Failed => {
-                return PreparedIamAuth {
-                    needs_existing_object_tag: false,
-                    mode: PreparedIamMode::Deny,
-                };
-            }
-            PolicyPluginState::Disabled => {}
+        if Self::get_policy_plugin_client().await.is_some() {
+            return PreparedIamAuth {
+                needs_existing_object_tag: false,
+                mode: PreparedIamMode::Opa,
+            };
        }

        let Ok((is_svc, parent_user)) = self.is_service_account(args.account).await else {
@@ -1202,22 +1163,7 @@ impl<T: Store> IamSys<T> {
            };
        }

-        let (resolved_policies, combined_policy) = self.store.merge_policies(&policies.join(",")).await;
-        if args.deny_only {
-            let resolved_policy_names: HashSet<&str> = resolved_policies
-                .split(',')
-                .filter(|policy_name| !policy_name.trim().is_empty())
-                .collect();
-            if policies
-                .iter()
-                .any(|policy_name| !resolved_policy_names.contains(policy_name.as_str()))
-            {
-                return PreparedIamAuth {
-                    needs_existing_object_tag: false,
-                    mode: PreparedIamMode::Deny,
-                };
-            }
-        }
+        let combined_policy = self.get_combined_policy(&policies).await;
        PreparedIamAuth {
            needs_existing_object_tag: policy_needs_existing_object_tag_for_args(&combined_policy, args).await,
            mode: PreparedIamMode::Regular { combined_policy },
@@ -1757,7 +1703,7 @@ mod tests {
    fn deprecated_list_polices_api_is_available() {
        let _ = IamSys::<StsTestMockStore>::list_polices;
    }
-    use rustfs_policy::policy::action::{Action, AdminAction, S3Action, StsAction};
+    use rustfs_policy::policy::action::{Action, AdminAction, S3Action};
    use rustfs_policy::policy::policy_uses_existing_object_tag_conditions;
    use serde_json::Value;
    use std::{
@@ -3363,155 +3309,6 @@ mod tests {
        assert!(!iam_sys.eval_prepared(&prepared, &args).await);
    }

-    #[tokio::test]
-    async fn regular_deny_only_rejects_unresolved_mapped_policy() {
-        let iam_sys = test_iam_sys().await;
-        let user = "regular-unresolved-policy";
-        let identity = UserIdentity::from(Credentials {
-            access_key: user.to_string(),
-            secret_key: "longenoughsecret".to_string(),
-            status: ACCOUNT_ON.to_string(),
-            ..Default::default()
-        });
-        iam_sys.store.cache.with_write_lock(|cache| {
-            let now = OffsetDateTime::now_utc();
-            cache.add_or_update_user(user, &identity, now);
-            cache.add_or_update_user_policy(user, &MappedPolicy::new("readwrite,missing-policy"), now);
-        });
-
-        let groups = None;
-        let claims = HashMap::new();
-        let conditions = HashMap::new();
-        let args = Args {
-            account: user,
-            groups: &groups,
-            action: Action::StsAction(StsAction::AssumeRoleAction),
-            bucket: "",
-            conditions: &conditions,
-            is_owner: false,
-            object: "",
-            claims: &claims,
-            deny_only: true,
-        };
-
-        let prepared = iam_sys.prepare_regular_auth(&args).await;
-        assert!(matches!(prepared.mode, PreparedIamMode::Deny));
-        assert!(
-            !iam_sys.eval_prepared(&prepared, &args).await,
-            "deny-only evaluation must fail closed when a mapped policy document is unresolved"
-        );
-    }
-
-    #[tokio::test]
-    async fn regular_full_evaluation_keeps_resolved_part_of_partial_mapping() {
-        let iam_sys = test_iam_sys().await;
-        let user = "regular-partial-policy";
-        let identity = UserIdentity::from(Credentials {
-            access_key: user.to_string(),
-            secret_key: "longenoughsecret".to_string(),
-            status: ACCOUNT_ON.to_string(),
-            ..Default::default()
-        });
-        iam_sys.store.cache.with_write_lock(|cache| {
-            let now = OffsetDateTime::now_utc();
-            cache.add_or_update_user(user, &identity, now);
-            cache.add_or_update_user_policy(user, &MappedPolicy::new("readwrite,missing-policy"), now);
-        });
-
-        let groups = None;
-        let claims = HashMap::new();
-        let conditions = HashMap::new();
-        let args = Args {
-            account: user,
-            groups: &groups,
-            action: Action::S3Action(S3Action::GetObjectAction),
-            bucket: "bucket",
-            conditions: &conditions,
-            is_owner: false,
-            object: "object",
-            claims: &claims,
-            deny_only: false,
-        };
-
-        let prepared = iam_sys.prepare_regular_auth(&args).await;
-        assert!(matches!(prepared.mode, PreparedIamMode::Regular { .. }));
-        assert!(
-            iam_sys.eval_prepared(&prepared, &args).await,
-            "full evaluation must preserve the historical partial-resolution behavior"
-        );
-    }
-
-    #[tokio::test]
-    async fn regular_deny_only_honors_group_derived_explicit_deny() {
-        let iam_sys = test_iam_sys().await;
-        let deny_policy =
-            Policy::parse_config(br#"{"Version":"2012-10-17","Statement":[{"Effect":"Deny","Action":["sts:AssumeRole"]}]}"#)
-                .expect("group deny policy should parse");
-        let now = OffsetDateTime::now_utc();
-        iam_sys
-            .store
-            .cache
-            .add_or_update_policy_doc("deny-assume-role", &PolicyDoc::new(deny_policy), now);
-        iam_sys
-            .store
-            .cache
-            .add_or_update_group_policy("testgroup", &MappedPolicy::new("deny-assume-role"), now);
-
-        let groups = Some(vec!["testgroup".to_string()]);
-        let claims = HashMap::new();
-        let conditions = HashMap::new();
-        let args = Args {
-            account: "sts-fallback-test-parent",
-            groups: &groups,
-            action: Action::StsAction(StsAction::AssumeRoleAction),
-            bucket: "",
-            conditions: &conditions,
-            is_owner: false,
-            object: "",
-            claims: &claims,
-            deny_only: true,
-        };
-
-        let prepared = iam_sys.prepare_regular_auth(&args).await;
-        assert!(matches!(prepared.mode, PreparedIamMode::Regular { .. }));
-        assert!(
-            !iam_sys.eval_prepared(&prepared, &args).await,
-            "group-derived explicit Deny must remain authoritative"
-        );
-    }
-
-    #[tokio::test]
-    async fn regular_deny_only_rejects_unresolved_group_mapping() {
-        let iam_sys = test_iam_sys().await;
-        iam_sys.store.cache.add_or_update_group_policy(
-            "testgroup",
-            &MappedPolicy::new("readwrite,missing-policy"),
-            OffsetDateTime::now_utc(),
-        );
-
-        let groups = Some(vec!["testgroup".to_string()]);
-        let claims = HashMap::new();
-        let conditions = HashMap::new();
-        let args = Args {
-            account: "sts-fallback-test-parent",
-            groups: &groups,
-            action: Action::StsAction(StsAction::AssumeRoleAction),
-            bucket: "",
-            conditions: &conditions,
-            is_owner: false,
-            object: "",
-            claims: &claims,
-            deny_only: true,
-        };
-
-        let prepared = iam_sys.prepare_regular_auth(&args).await;
-        assert!(matches!(prepared.mode, PreparedIamMode::Deny));
-        assert!(
-            !iam_sys.eval_prepared(&prepared, &args).await,
-            "deny-only evaluation must fail closed for an unresolved group-derived mapping"
-        );
-    }
-
    #[tokio::test]
    async fn test_sts_claim_policy_ignores_unsafe_and_missing_policy_names() {
        let store = StsTestMockStore::new(true);
@@ -64,10 +64,6 @@ md-5 = { workspace = true }
 arc-swap = { workspace = true }
 rustfs-utils = { workspace = true }
 rustfs-security-governance = { workspace = true }
-# `EventName` for KMS audit records. A leaf crate with no rustfs dependencies,
-# so the audit sink can live outside this crate without a second, drifting
-# copy of the event vocabulary.
-rustfs-s3-types = { workspace = true }

 # HTTP client for Vault
 reqwest = { workspace = true }
@@ -1,423 +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.
-
-//! Audit contract for KMS management operations.
-//!
-//! [`KmsManager`](crate::manager::KmsManager) builds a [`KmsAuditRecord`] for
-//! every management operation it serves and hands it to the installed
-//! [`KmsAuditSink`]. No sink is installed by default, so a deployment that
-//! does not consume KMS audit records pays nothing beyond the `Option` check.
-//!
-//! The record is deliberately a KMS-side type rather than an audit-crate
-//! entry: keeping the dependency edge out of this crate lets the server map
-//! records onto its existing audit pipeline (and its delivery semantics)
-//! without KMS having to know that pipeline exists.
-//!
-//! # Redaction
-//!
-//! A record has no field that can hold key material, and every value that
-//! originates from a caller passes through [`redact_encryption_context`]
-//! before it is stored. Adding a field here means re-checking that invariant.
-
-use crate::error::KmsError;
-use crate::types::OperationContext;
-use rustfs_s3_types::EventName;
-use sha2::{Digest, Sha256};
-use std::collections::{BTreeMap, HashMap};
-use std::time::Duration;
-use uuid::Uuid;
-
-/// Encryption-context keys that describe *where* an object lives rather than
-/// anything secret about it. Their values are recorded verbatim; every other
-/// key is reduced to a digest.
-const ENCRYPTION_CONTEXT_ALLOWLIST: [&str; 5] = ["bucket", "object", "object_key", "algorithm", "sse_type"];
-
-/// Prefix marking a value that was replaced by a digest of itself.
-const DIGEST_PREFIX: &str = "sha256:";
-
-/// Hex characters of the digest that are kept. Enough to correlate repeated
-/// values across records without being reversible in practice.
-const DIGEST_LEN: usize = 16;
-
-/// A KMS management operation that produces an audit record.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum KmsAuditOperation {
-    /// Creation of a new master key.
-    CreateKey,
-    /// Metadata lookup for a single key.
-    DescribeKey,
-    /// Enumeration of keys.
-    ListKeys,
-    /// Scheduling a key for deletion after the pending window.
-    ScheduleKeyDeletion,
-    /// Cancelling a previously scheduled deletion.
-    CancelKeyDeletion,
-    /// Returning a disabled key to service.
-    EnableKey,
-    /// Taking a key out of service without destroying it.
-    DisableKey,
-    /// Rotating a key to a new version.
-    RotateKey,
-    /// Irreversible removal of key material once the pending window expired.
-    DeleteKey,
-}
-
-impl KmsAuditOperation {
-    /// Stable operation name for audit consumers.
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            KmsAuditOperation::CreateKey => "CreateKey",
-            KmsAuditOperation::DescribeKey => "DescribeKey",
-            KmsAuditOperation::ListKeys => "ListKeys",
-            KmsAuditOperation::ScheduleKeyDeletion => "ScheduleKeyDeletion",
-            KmsAuditOperation::CancelKeyDeletion => "CancelKeyDeletion",
-            KmsAuditOperation::EnableKey => "EnableKey",
-            KmsAuditOperation::DisableKey => "DisableKey",
-            KmsAuditOperation::RotateKey => "RotateKey",
-            KmsAuditOperation::DeleteKey => "DeleteKey",
-        }
-    }
-
-    /// Notification/audit event name carried by records for this operation.
-    pub fn event_name(&self) -> EventName {
-        match self {
-            KmsAuditOperation::CreateKey => EventName::KmsKeyCreated,
-            KmsAuditOperation::DescribeKey | KmsAuditOperation::ListKeys => EventName::KmsKeyAccessed,
-            KmsAuditOperation::ScheduleKeyDeletion => EventName::KmsKeyDeletionScheduled,
-            KmsAuditOperation::CancelKeyDeletion => EventName::KmsKeyDeletionCancelled,
-            KmsAuditOperation::EnableKey => EventName::KmsKeyEnabled,
-            KmsAuditOperation::DisableKey => EventName::KmsKeyDisabled,
-            KmsAuditOperation::RotateKey => EventName::KmsKeyRotated,
-            KmsAuditOperation::DeleteKey => EventName::KmsKeyDeleted,
-        }
-    }
-}
-
-/// Whether the audited operation completed.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum KmsAuditOutcome {
-    /// The operation completed and its effect is durable.
-    Success,
-    /// The operation failed; `error_class` carries the reason category.
-    Failure,
-}
-
-impl KmsAuditOutcome {
-    /// Stable outcome name for audit consumers.
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            KmsAuditOutcome::Success => "success",
-            KmsAuditOutcome::Failure => "failure",
-        }
-    }
-}
-
-/// Coarse, stable classification of a failed KMS operation.
-///
-/// Audit consumers alert on these, so the strings are a wire contract: add
-/// new classes rather than renaming existing ones.
-pub fn error_class(error: &KmsError) -> &'static str {
-    match error {
-        KmsError::ConfigurationError { .. } => "configuration",
-        KmsError::KeyNotFound { .. } => "key_not_found",
-        KmsError::InvalidKey { .. } => "invalid_key",
-        KmsError::CryptographicError { .. } => "cryptographic",
-        KmsError::BackendError { .. } => "backend",
-        KmsError::AccessDenied { .. } => "access_denied",
-        KmsError::KeyAlreadyExists { .. } => "key_already_exists",
-        KmsError::InvalidOperation { .. } => "invalid_operation",
-        KmsError::InternalError { .. } => "internal",
-        KmsError::SerializationError { .. } => "serialization",
-        KmsError::IoError { .. } => "io",
-        KmsError::CacheError { .. } => "cache",
-        KmsError::ValidationError { .. } => "validation",
-        KmsError::UnsupportedAlgorithm { .. } => "unsupported_algorithm",
-        KmsError::InvalidKeySize { .. } => "invalid_key_size",
-        KmsError::ContextMismatch { .. } => "context_mismatch",
-        KmsError::OperationTimedOut { .. } => "timeout",
-        KmsError::OperationCancelled { .. } => "cancelled",
-        KmsError::MaterialMissing { .. } => "material_missing",
-        KmsError::MaterialCorrupt { .. } => "material_corrupt",
-        KmsError::MaterialAuthenticationFailed { .. } => "material_authentication_failed",
-        KmsError::UnsupportedFormatVersion { .. } => "unsupported_format_version",
-        KmsError::KeyVersionNotFound { .. } => "key_version_not_found",
-        KmsError::Backup(_) => "backup",
-        KmsError::UnsupportedCapability { .. } => "unsupported_capability",
-        KmsError::CredentialsUnavailable { .. } => "credentials_unavailable",
-    }
-}
-
-/// One audited KMS management operation.
-///
-/// Everything an audit consumer needs to answer "who did what to which key,
-/// against which backend, and did it work" — and nothing that could carry key
-/// material. See the module docs for the redaction rules.
-///
-/// Tenant attribution is intentionally absent: multi-tenancy is not modelled
-/// yet, and an invented tenant value is worse than a missing one. It will
-/// arrive as an entry in [`Self::context`] once tenancy lands.
-#[derive(Debug, Clone)]
-pub struct KmsAuditRecord {
-    /// Correlates every record emitted for one logical request.
-    pub operation_id: Uuid,
-    /// The audited operation.
-    pub operation: KmsAuditOperation,
-    /// Event name published to audit consumers.
-    pub event: EventName,
-    /// Authenticated identity that requested the operation, or
-    /// [`OperationContext::INTERNAL_PRINCIPAL`] for server-initiated work.
-    pub principal: String,
-    /// Client address, when the caller supplied one.
-    pub source_ip: Option<String>,
-    /// Client user agent, when the caller supplied one.
-    pub user_agent: Option<String>,
-    /// Key the operation acted on. `None` for operations that span keys, such
-    /// as listing.
-    pub key_id: Option<String>,
-    /// Key version the operation resolved to, when the result identifies one.
-    /// Operations on a key as a whole leave this unset.
-    pub key_version: Option<u32>,
-    /// Whether the operation succeeded.
-    pub outcome: KmsAuditOutcome,
-    /// Failure category; `None` on success. See [`error_class`].
-    pub error_class: Option<&'static str>,
-    /// Backend that served the operation, e.g. `local` or `vault-transit`.
-    pub backend: &'static str,
-    /// Wall-clock time spent in the audited operation.
-    pub latency: Duration,
-    /// Retries performed above the audit point. `None` means the number is
-    /// not observable here: backend-internal retries are accounted for by the
-    /// `rustfs_kms_backend_operation_attempts` metric instead of being
-    /// duplicated (and possibly contradicted) in the audit trail.
-    pub retry_count: Option<u32>,
-    /// Server-supplied correlation values carried by the operation context.
-    /// Also the reserved slot for tenant attribution.
-    pub context: BTreeMap<String, String>,
-    /// Caller-supplied encryption context, after [`redact_encryption_context`].
-    pub encryption_context: BTreeMap<String, String>,
-}
-
-impl KmsAuditRecord {
-    /// Start a record for `operation` performed under `context`.
-    ///
-    /// The outcome defaults to failure so that a record which somehow escapes
-    /// without [`Self::with_result`] under-reports success rather than
-    /// inventing it.
-    pub fn new(operation: KmsAuditOperation, context: &OperationContext, backend: &'static str) -> Self {
-        Self {
-            operation_id: context.operation_id,
-            operation,
-            event: operation.event_name(),
-            principal: context.principal.clone(),
-            source_ip: context.source_ip.clone(),
-            user_agent: context.user_agent.clone(),
-            key_id: None,
-            key_version: None,
-            outcome: KmsAuditOutcome::Failure,
-            error_class: None,
-            backend,
-            latency: Duration::ZERO,
-            retry_count: None,
-            context: context
-                .additional_context
-                .iter()
-                .map(|(k, v)| (k.clone(), v.clone()))
-                .collect(),
-            encryption_context: BTreeMap::new(),
-        }
-    }
-
-    /// Attach the key the operation acted on.
-    pub fn with_key_id(mut self, key_id: Option<impl Into<String>>) -> Self {
-        self.key_id = key_id.map(Into::into);
-        self
-    }
-
-    /// Attach the key version the operation resolved to.
-    pub fn with_key_version(mut self, key_version: Option<u32>) -> Self {
-        self.key_version = key_version;
-        self
-    }
-
-    /// Attach the measured duration of the operation.
-    pub fn with_latency(mut self, latency: Duration) -> Self {
-        self.latency = latency;
-        self
-    }
-
-    /// Derive outcome and error class from the operation result.
-    pub fn with_result<T>(mut self, result: &crate::error::Result<T>) -> Self {
-        match result {
-            Ok(_) => {
-                self.outcome = KmsAuditOutcome::Success;
-                self.error_class = None;
-            }
-            Err(error) => {
-                self.outcome = KmsAuditOutcome::Failure;
-                self.error_class = Some(error_class(error));
-            }
-        }
-        self
-    }
-
-    /// Attach the caller-supplied encryption context, redacted.
-    ///
-    /// Redaction happens here rather than at the call site so no caller can
-    /// place a raw context value into a record by accident.
-    pub fn with_encryption_context(mut self, encryption_context: &HashMap<String, String>) -> Self {
-        self.encryption_context = redact_encryption_context(encryption_context);
-        self
-    }
-}
-
-/// Reduce a caller-supplied encryption context to something safe to persist.
-///
-/// Keys naming the object's location are kept verbatim because they are the
-/// reason the context is audited at all. Every other value is replaced by a
-/// truncated digest, which still correlates repeated values across records
-/// but does not reproduce whatever the caller put there.
-pub fn redact_encryption_context(encryption_context: &HashMap<String, String>) -> BTreeMap<String, String> {
-    encryption_context
-        .iter()
-        .map(|(key, value)| {
-            let recorded = if ENCRYPTION_CONTEXT_ALLOWLIST.contains(&key.as_str()) {
-                value.clone()
-            } else {
-                digest_value(value)
-            };
-            (key.clone(), recorded)
-        })
-        .collect()
-}
-
-fn digest_value(value: &str) -> String {
-    let digest = hex::encode(Sha256::digest(value.as_bytes()));
-    format!("{DIGEST_PREFIX}{}", &digest[..DIGEST_LEN])
-}
-
-/// Receives KMS audit records.
-///
-/// Implementations must not block: they are called on the task that served
-/// the KMS operation. Delivery failures are the sink's problem — the KMS
-/// operation has already completed by the time a record is emitted, and its
-/// result is never changed by what the sink does.
-pub trait KmsAuditSink: Send + Sync {
-    /// Handle one audit record.
-    fn emit(&self, record: KmsAuditRecord);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn every_operation_maps_to_a_kms_event() {
-        let operations = [
-            KmsAuditOperation::CreateKey,
-            KmsAuditOperation::DescribeKey,
-            KmsAuditOperation::ListKeys,
-            KmsAuditOperation::ScheduleKeyDeletion,
-            KmsAuditOperation::CancelKeyDeletion,
-            KmsAuditOperation::EnableKey,
-            KmsAuditOperation::DisableKey,
-            KmsAuditOperation::RotateKey,
-            KmsAuditOperation::DeleteKey,
-        ];
-
-        for operation in operations {
-            let event = operation.event_name();
-            assert!(event.is_kms(), "{} must map to a KMS event, got {event}", operation.as_str());
-        }
-    }
-
-    #[test]
-    fn record_defaults_to_failure_until_a_result_is_attached() {
-        let context = OperationContext::new("tester".to_string());
-        let record = KmsAuditRecord::new(KmsAuditOperation::CreateKey, &context, "local");
-
-        assert_eq!(record.outcome, KmsAuditOutcome::Failure);
-        assert!(record.error_class.is_none());
-
-        let ok: crate::error::Result<()> = Ok(());
-        assert_eq!(record.clone().with_result(&ok).outcome, KmsAuditOutcome::Success);
-
-        let denied: crate::error::Result<()> = Err(KmsError::access_denied("nope"));
-        let failed = record.with_result(&denied);
-        assert_eq!(failed.outcome, KmsAuditOutcome::Failure);
-        assert_eq!(failed.error_class, Some("access_denied"));
-    }
-
-    #[test]
-    fn record_carries_the_full_operation_context() {
-        let context = OperationContext::new("arn:aws:iam::user/alice".to_string())
-            .with_source_ip("10.0.0.7".to_string())
-            .with_user_agent("aws-cli/2".to_string())
-            .with_context("requestID".to_string(), "req-1".to_string());
-
-        let record = KmsAuditRecord::new(KmsAuditOperation::RotateKey, &context, "vault-transit")
-            .with_key_id(Some("key-1"))
-            .with_key_version(Some(3))
-            .with_latency(Duration::from_millis(12));
-
-        assert_eq!(record.operation_id, context.operation_id);
-        assert_eq!(record.principal, "arn:aws:iam::user/alice");
-        assert_eq!(record.source_ip.as_deref(), Some("10.0.0.7"));
-        assert_eq!(record.user_agent.as_deref(), Some("aws-cli/2"));
-        assert_eq!(record.key_id.as_deref(), Some("key-1"));
-        assert_eq!(record.key_version, Some(3));
-        assert_eq!(record.backend, "vault-transit");
-        assert_eq!(record.latency, Duration::from_millis(12));
-        assert_eq!(record.event, EventName::KmsKeyRotated);
-        assert_eq!(record.context.get("requestID").map(String::as_str), Some("req-1"));
-    }
-
-    #[test]
-    fn encryption_context_keeps_only_allowlisted_values_verbatim() {
-        let secret = "eyJhbGciOiJIUzI1NiJ9.super-secret-grant-token";
-        let context = HashMap::from([
-            ("bucket".to_string(), "photos".to_string()),
-            ("object_key".to_string(), "2026/cat.png".to_string()),
-            ("algorithm".to_string(), "AES256".to_string()),
-            ("grant_token".to_string(), secret.to_string()),
-            ("customer_reference".to_string(), "acct-4711".to_string()),
-        ]);
-
-        let redacted = redact_encryption_context(&context);
-
-        assert_eq!(redacted.get("bucket").map(String::as_str), Some("photos"));
-        assert_eq!(redacted.get("object_key").map(String::as_str), Some("2026/cat.png"));
-        assert_eq!(redacted.get("algorithm").map(String::as_str), Some("AES256"));
-
-        for key in ["grant_token", "customer_reference"] {
-            let value = redacted.get(key).expect("non-allowlisted key should be kept as a digest");
-            assert!(value.starts_with(DIGEST_PREFIX), "{key} should be digested, got {value}");
-        }
-
-        let rendered = format!("{redacted:?}");
-        assert!(!rendered.contains(secret), "redacted context must not reproduce the raw value");
-        assert!(!rendered.contains("acct-4711"), "redacted context must not reproduce the raw value");
-    }
-
-    #[test]
-    fn identical_values_digest_identically_across_records() {
-        // Correlation is the reason a digest is preferable to a fixed
-        // placeholder; assert it actually holds.
-        let first = redact_encryption_context(&HashMap::from([("tenant".to_string(), "alpha".to_string())]));
-        let second = redact_encryption_context(&HashMap::from([("tenant".to_string(), "alpha".to_string())]));
-        let other = redact_encryption_context(&HashMap::from([("tenant".to_string(), "beta".to_string())]));
-
-        assert_eq!(first.get("tenant"), second.get("tenant"));
-        assert_ne!(first.get("tenant"), other.get("tenant"));
-    }
-}
@@ -26,16 +26,16 @@ use std::sync::{Arc, Mutex};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};

-/// One scripted connection outcome.
-pub(crate) enum ScriptedResponse {
-    Http { status: u16, body: String },
-    Close,
+/// One canned HTTP response.
+pub(crate) struct ScriptedResponse {
+    status: u16,
+    body: String,
 }

 impl ScriptedResponse {
    /// A 200 response carrying `data` inside the standard Vault envelope.
    pub(crate) fn ok(data: serde_json::Value) -> Self {
-        Self::Http {
+        Self {
            status: 200,
            body: serde_json::json!({
                "request_id": "scripted",
@@ -50,16 +50,11 @@ impl ScriptedResponse {

    /// An error response in Vault's `{"errors": [...]}` format.
    pub(crate) fn error(status: u16, message: &str) -> Self {
-        Self::Http {
+        Self {
            status,
            body: serde_json::json!({ "errors": [message] }).to_string(),
        }
    }
-
-    /// Close the connection after consuming a request without sending an HTTP response.
-    pub(crate) fn close() -> Self {
-        Self::Close
-    }
 }

 /// A scripted stand-in Vault listening on a loopback port.
@@ -93,14 +88,14 @@ impl ScriptedVault {
                let response = responses
                    .next()
                    .unwrap_or_else(|| ScriptedResponse::error(599, "scripted vault: script exhausted"));
-                if let ScriptedResponse::Http { status, body } = response {
-                    let payload = format!(
-                        "HTTP/1.1 {status} Scripted\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{body}",
-                        body.len(),
-                    );
-                    let _ = stream.write_all(payload.as_bytes()).await;
-                    let _ = stream.shutdown().await;
-                }
+                let payload = format!(
+                    "HTTP/1.1 {} Scripted\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}",
+                    response.status,
+                    response.body.len(),
+                    response.body
+                );
+                let _ = stream.write_all(payload.as_bytes()).await;
+                let _ = stream.shutdown().await;
            }
        });

@@ -1512,8 +1512,6 @@ mod tests {
    use crate::backends::scripted_vault::{ScriptedResponse, ScriptedVault};
    use crate::config::{VaultAuthMethod, VaultConfig};

-    const SCRIPTED_RETRY_ATTEMPTS: u32 = 3;
-
    /// Vault + KMS config pair pointing at a scripted loopback Vault.
    fn scripted_configs(address: &str) -> (VaultConfig, KmsConfig) {
        let vault_config = VaultConfig {
@@ -1529,7 +1527,7 @@ mod tests {
        };
        let kms_config = KmsConfig {
            timeout: Duration::from_secs(5),
-            retry_attempts: SCRIPTED_RETRY_ATTEMPTS,
+            retry_attempts: 3,
            ..KmsConfig::default()
        };
        (vault_config, kms_config)
@@ -1598,31 +1596,6 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn wired_read_retries_closed_connections_within_budget() {
-        let (vault, client) = scripted_client(vec![ScriptedResponse::close(), ScriptedResponse::close()]).await;
-
-        let error = client
-            .get_key_data("wired-key")
-            .await
-            .expect_err("closed connections must exhaust the retry budget");
-        assert!(matches!(error, KmsError::BackendError { .. }), "got {error:?}");
-
-        let requests = vault.requests();
-        let expected_requests = usize::try_from(SCRIPTED_RETRY_ATTEMPTS).expect("retry attempts must fit usize");
-        assert_eq!(
-            requests.len(),
-            expected_requests,
-            "all budgeted retry attempts must reach Vault: {requests:?}"
-        );
-        assert!(
-            requests
-                .iter()
-                .all(|line| line == "GET /v1/secret/data/rustfs/kms/keys/wired-key"),
-            "all attempts must hit the same read endpoint: {requests:?}"
-        );
-    }
-
    #[tokio::test]
    async fn wired_read_does_not_retry_permission_errors() {
        let (vault, client) = scripted_client(vec![ScriptedResponse::error(403, "permission denied")]).await;
@@ -130,21 +130,6 @@ pub enum KmsBackend {
    Static,
 }

-impl KmsBackend {
-    /// Stable identifier for logs, metrics, and audit records.
-    ///
-    /// External consumers key off these values, so treat them as a wire
-    /// contract rather than a rendering detail.
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            KmsBackend::VaultKv2 => "vault-kv2",
-            KmsBackend::VaultTransit => "vault-transit",
-            KmsBackend::Local => "local",
-            KmsBackend::Static => "static",
-        }
-    }
-}
-
 /// Main KMS configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct KmsConfig {
@@ -22,14 +22,12 @@
 //! every node of a deployment concurrently — a key is only ever removed while
 //! its (re-read) record is an expired pending deletion or a tombstone.

-use crate::audit::{KmsAuditOperation, KmsAuditRecord, KmsAuditSink};
 use crate::backends::{ExpiredKeyRemoval, KmsBackend};
-use crate::error::Result;
-use crate::types::{KeyStatus, ListKeysRequest, OperationContext};
+use crate::types::{KeyStatus, ListKeysRequest};
 use async_trait::async_trait;
 use jiff::Zoned;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, info, warn};

@@ -70,8 +68,6 @@ pub(crate) struct DeletionWorker {
    default_key_id: Option<String>,
    reference_checker: Option<Arc<dyn DeletionReferenceChecker>>,
    interval: Duration,
-    backend_kind: &'static str,
-    audit_sink: Option<Arc<dyn KmsAuditSink>>,
 }

 impl DeletionWorker {
@@ -79,24 +75,15 @@ impl DeletionWorker {
        backend: Arc<dyn KmsBackend>,
        default_key_id: Option<String>,
        reference_checker: Option<Arc<dyn DeletionReferenceChecker>>,
-        backend_kind: &'static str,
    ) -> Self {
        Self {
            backend,
            default_key_id,
            reference_checker,
-            backend_kind,
-            audit_sink: None,
            interval: DEFAULT_SWEEP_INTERVAL,
        }
    }

-    /// Audit each irreversible key removal to `sink`.
-    pub(crate) fn with_audit_sink(mut self, sink: Option<Arc<dyn KmsAuditSink>>) -> Self {
-        self.audit_sink = sink;
-        self
-    }
-
    pub(crate) fn spawn(self, cancel: CancellationToken) -> tokio::task::JoinHandle<()> {
        tokio::spawn(async move { self.run(cancel).await })
    }
@@ -181,43 +168,15 @@ impl DeletionWorker {

        // The backend re-checks state and deadline under its own write
        // synchronization, so a cancellation racing this sweep wins there.
-        let started = Instant::now();
-        let outcome = self.backend.remove_expired_key(key_id, now).await;
-        match &outcome {
-            Ok(ExpiredKeyRemoval::Removed) => {
-                report.removed.push(key_id.to_string());
-                self.audit_removal(key_id, started, &outcome);
-            }
+        match self.backend.remove_expired_key(key_id, now).await {
+            Ok(ExpiredKeyRemoval::Removed) => report.removed.push(key_id.to_string()),
            Ok(ExpiredKeyRemoval::StateChanged | ExpiredKeyRemoval::NotExpired) => report.skipped += 1,
            Err(error) => {
                warn!(key_id, %error, "failed to remove expired KMS key; will retry next sweep");
                report.failed += 1;
-                self.audit_removal(key_id, started, &outcome);
            }
        }
    }
-
-    /// Record an attempted destruction of key material.
-    ///
-    /// Only attempts that reached the backend are audited: a key the sweep
-    /// declined to touch (not yet due, still referenced, state changed under
-    /// us) was never at risk, and recording it as a deletion event would
-    /// drown the real ones.
-    fn audit_removal(&self, key_id: &str, started: Instant, outcome: &Result<ExpiredKeyRemoval>) {
-        let Some(sink) = self.audit_sink.as_ref() else {
-            return;
-        };
-
-        // Removal runs on a background sweep, so there is no request
-        // principal to attribute it to.
-        let context = OperationContext::internal();
-        sink.emit(
-            KmsAuditRecord::new(KmsAuditOperation::DeleteKey, &context, self.backend_kind)
-                .with_key_id(Some(key_id))
-                .with_latency(started.elapsed())
-                .with_result(outcome),
-        );
-    }
 }

 #[cfg(test)]
@@ -257,7 +216,7 @@ mod tests {
    }

    fn worker(backend: Arc<LocalKmsBackend>) -> DeletionWorker {
-        DeletionWorker::new(backend, None, None, "local")
+        DeletionWorker::new(backend, None, None)
    }

    fn after_window() -> Zoned {
@@ -348,7 +307,7 @@ mod tests {
        schedule(&backend, &key_id).await;

        // Blocked while it is the configured default key.
-        let as_default = DeletionWorker::new(backend.clone(), Some(key_id.clone()), None, "local");
+        let as_default = DeletionWorker::new(backend.clone(), Some(key_id.clone()), None);
        let report = as_default.sweep(&after_window()).await;
        assert_eq!(report.blocked, vec![key_id.clone()]);
        assert!(report.removed.is_empty());
@@ -358,7 +317,6 @@ mod tests {
            backend.clone(),
            None,
            Some(Arc::new(StaticReferences(vec!["bucket:sse-bucket".to_string()]))),
-            "local",
        );
        let report = with_references.sweep(&after_window()).await;
        assert_eq!(report.blocked, vec![key_id.clone()]);
@@ -369,53 +327,11 @@ mod tests {
            .expect("blocked key must still exist");

        // Removed once nothing references it anymore.
-        let unreferenced = DeletionWorker::new(backend.clone(), None, Some(Arc::new(StaticReferences(Vec::new()))), "local");
+        let unreferenced = DeletionWorker::new(backend.clone(), None, Some(Arc::new(StaticReferences(Vec::new()))));
        let report = unreferenced.sweep(&after_window()).await;
        assert_eq!(report.removed, vec![key_id.clone()]);
    }

-    #[tokio::test]
-    async fn only_attempted_removals_are_audited() {
-        #[derive(Default)]
-        struct CapturingSink {
-            records: std::sync::Mutex<Vec<KmsAuditRecord>>,
-        }
-
-        impl KmsAuditSink for CapturingSink {
-            fn emit(&self, record: KmsAuditRecord) {
-                self.records.lock().expect("sink lock should not be poisoned").push(record);
-            }
-        }
-
-        let temp_dir = tempfile::tempdir().expect("temp dir");
-        let backend = local_backend(&temp_dir).await;
-        let key_id = create_key(&backend, "audited-removal").await;
-        schedule(&backend, &key_id).await;
-
-        let sink = Arc::new(CapturingSink::default());
-        let worker = DeletionWorker::new(backend.clone(), None, None, "local").with_audit_sink(Some(sink.clone()));
-
-        // A key that is not yet due was never at risk, so it produces no record.
-        worker.sweep(&Zoned::now()).await;
-        assert!(
-            sink.records.lock().expect("sink lock").is_empty(),
-            "a key the sweep declined to touch must not be audited as a deletion"
-        );
-
-        worker.sweep(&after_window()).await;
-
-        let records = sink.records.lock().expect("sink lock");
-        assert_eq!(records.len(), 1, "the removal should be audited exactly once");
-        let record = &records[0];
-        assert_eq!(record.operation, crate::audit::KmsAuditOperation::DeleteKey);
-        assert_eq!(record.event, rustfs_s3_types::EventName::KmsKeyDeleted);
-        assert_eq!(record.outcome, crate::audit::KmsAuditOutcome::Success);
-        assert_eq!(record.key_id.as_deref(), Some(key_id.as_str()));
-        assert_eq!(record.backend, "local");
-        // Background work has no request principal to attribute.
-        assert_eq!(record.principal, OperationContext::INTERNAL_PRINCIPAL);
-    }
-
    #[tokio::test]
    async fn deadline_survives_backend_restart_and_sweep_completes_it() {
        let temp_dir = tempfile::tempdir().expect("temp dir");
@@ -65,7 +65,6 @@

 // Core modules
 pub mod api_types;
-pub mod audit;
 pub mod backends;
 pub mod backup;
 mod cache;
@@ -75,7 +74,6 @@ mod encryption;
 mod error;
 pub mod manager;
 mod policy;
-pub mod probe;
 pub mod service;
 pub mod service_manager;
 mod time_serde;
@@ -88,13 +86,11 @@ pub use api_types::{
    StartKmsResponse, StopKmsResponse, TagKeyRequest, TagKeyResponse, UntagKeyRequest, UntagKeyResponse,
    UpdateKeyDescriptionRequest, UpdateKeyDescriptionResponse,
 };
-pub use audit::{KmsAuditOperation, KmsAuditOutcome, KmsAuditRecord, KmsAuditSink, redact_encryption_context};
 pub use config::*;
 pub use deletion_worker::DeletionReferenceChecker;
 pub use encryption::is_data_key_envelope;
 pub use error::{KmsError, KmsUnavailableError, Result};
 pub use manager::KmsManager;
-pub use probe::{ProbeFailureKind, ProbeResult, ProbeStatus};
 pub use service::{DataKey, ObjectEncryptionService};
 pub use service_manager::{
    KmsServiceManager, KmsServiceStatus, KmsStartOutcome, get_global_encryption_service, get_global_kms_service_manager,
@@ -14,7 +14,6 @@

 //! KMS manager for handling key operations and backend coordination

-use crate::audit::{KmsAuditOperation, KmsAuditRecord, KmsAuditSink};
 use crate::backends::KmsBackend;
 use crate::cache::KmsCache;
 use crate::config::KmsConfig;
@@ -22,10 +21,9 @@ use crate::error::Result;
 use crate::types::{
    CancelKeyDeletionRequest, CancelKeyDeletionResponse, CreateKeyRequest, CreateKeyResponse, DecryptRequest, DecryptResponse,
    DeleteKeyRequest, DeleteKeyResponse, DescribeKeyRequest, DescribeKeyResponse, EncryptRequest, EncryptResponse,
-    GenerateDataKeyRequest, GenerateDataKeyResponse, ListKeysRequest, ListKeysResponse, OperationContext,
+    GenerateDataKeyRequest, GenerateDataKeyResponse, ListKeysRequest, ListKeysResponse,
 };
 use std::sync::Arc;
-use std::time::Instant;
 use tokio::sync::RwLock;

 /// KMS Manager coordinates operations between backends and caching
@@ -35,8 +33,6 @@ pub struct KmsManager {
    cache: Arc<RwLock<KmsCache>>,
    default_key_id: Option<String>,
    enable_cache: bool,
-    backend_kind: &'static str,
-    audit_sink: Option<Arc<dyn KmsAuditSink>>,
 }

 impl KmsManager {
@@ -48,72 +44,16 @@ impl KmsManager {
            cache,
            default_key_id: config.default_key_id,
            enable_cache: config.enable_cache,
-            backend_kind: config.backend.as_str(),
-            audit_sink: None,
        }
    }

-    /// Send an audit record for every management operation to `sink`.
-    ///
-    /// Without a sink the manager builds no records at all, so a deployment
-    /// that does not consume KMS audit records is unaffected.
-    pub fn with_audit_sink(mut self, sink: Arc<dyn KmsAuditSink>) -> Self {
-        self.audit_sink = Some(sink);
-        self
-    }
-
    /// Get the default key ID if configured
    pub fn get_default_key_id(&self) -> Option<&String> {
        self.default_key_id.as_ref()
    }

-    /// Emit an audit record for a completed management operation.
-    ///
-    /// Called after the operation resolved, so nothing here can change its
-    /// result; the record is built only when a sink is installed.
-    fn audit<T>(
-        &self,
-        operation: KmsAuditOperation,
-        context: &OperationContext,
-        key_id: Option<&str>,
-        started: Instant,
-        result: &Result<T>,
-    ) {
-        let Some(sink) = self.audit_sink.as_ref() else {
-            return;
-        };
-
-        sink.emit(
-            KmsAuditRecord::new(operation, context, self.backend_kind)
-                .with_key_id(key_id)
-                .with_latency(started.elapsed())
-                .with_result(result),
-        );
-    }
-
    /// Create a new master key
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::create_key_with_context`].
    pub async fn create_key(&self, request: CreateKeyRequest) -> Result<CreateKeyResponse> {
-        self.create_key_with_context(request, &OperationContext::internal()).await
-    }
-
-    /// Create a new master key on behalf of `context`'s principal
-    pub async fn create_key_with_context(
-        &self,
-        request: CreateKeyRequest,
-        context: &OperationContext,
-    ) -> Result<CreateKeyResponse> {
-        let started = Instant::now();
-        let key_name = request.key_name.clone();
-        let result = self.create_key_inner(request).await;
-        let key_id = result.as_ref().ok().map(|r| r.key_id.as_str()).or(key_name.as_deref());
-        self.audit(KmsAuditOperation::CreateKey, context, key_id, started, &result);
-        result
-    }
-
-    async fn create_key_inner(&self, request: CreateKeyRequest) -> Result<CreateKeyResponse> {
        let response = self.backend.create_key(request).await?;

        // Cache the key metadata if enabled
@@ -144,27 +84,7 @@ impl KmsManager {
    }

    /// Describe a key
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::describe_key_with_context`].
    pub async fn describe_key(&self, request: DescribeKeyRequest) -> Result<DescribeKeyResponse> {
-        self.describe_key_with_context(request, &OperationContext::internal()).await
-    }
-
-    /// Describe a key on behalf of `context`'s principal
-    pub async fn describe_key_with_context(
-        &self,
-        request: DescribeKeyRequest,
-        context: &OperationContext,
-    ) -> Result<DescribeKeyResponse> {
-        let started = Instant::now();
-        let key_id = request.key_id.clone();
-        let result = self.describe_key_inner(request).await;
-        self.audit(KmsAuditOperation::DescribeKey, context, Some(&key_id), started, &result);
-        result
-    }
-
-    async fn describe_key_inner(&self, request: DescribeKeyRequest) -> Result<DescribeKeyResponse> {
        // Check cache first if enabled
        if self.enable_cache {
            let cache = self.cache.read().await;
@@ -189,20 +109,8 @@ impl KmsManager {
    }

    /// List keys
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::list_keys_with_context`].
    pub async fn list_keys(&self, request: ListKeysRequest) -> Result<ListKeysResponse> {
-        self.list_keys_with_context(request, &OperationContext::internal()).await
-    }
-
-    /// List keys on behalf of `context`'s principal
-    pub async fn list_keys_with_context(&self, request: ListKeysRequest, context: &OperationContext) -> Result<ListKeysResponse> {
-        let started = Instant::now();
-        let result = self.backend.list_keys(request).await;
-        // Listing spans keys, so the record carries no key id.
-        self.audit(KmsAuditOperation::ListKeys, context, None, started, &result);
-        result
+        self.backend.list_keys(request).await
    }

    /// Get cache statistics
@@ -225,27 +133,7 @@ impl KmsManager {
    }

    /// Delete a key
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::delete_key_with_context`].
    pub async fn delete_key(&self, request: DeleteKeyRequest) -> Result<DeleteKeyResponse> {
-        self.delete_key_with_context(request, &OperationContext::internal()).await
-    }
-
-    /// Delete a key on behalf of `context`'s principal
-    pub async fn delete_key_with_context(
-        &self,
-        request: DeleteKeyRequest,
-        context: &OperationContext,
-    ) -> Result<DeleteKeyResponse> {
-        let started = Instant::now();
-        let key_id = request.key_id.clone();
-        let result = self.delete_key_inner(request).await;
-        self.audit(KmsAuditOperation::ScheduleKeyDeletion, context, Some(&key_id), started, &result);
-        result
-    }
-
-    async fn delete_key_inner(&self, request: DeleteKeyRequest) -> Result<DeleteKeyResponse> {
        let response = self.backend.delete_key(request).await?;

        // Remove from cache if enabled and key is being deleted
@@ -258,28 +146,7 @@ impl KmsManager {
    }

    /// Cancel key deletion
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::cancel_key_deletion_with_context`].
    pub async fn cancel_key_deletion(&self, request: CancelKeyDeletionRequest) -> Result<CancelKeyDeletionResponse> {
-        self.cancel_key_deletion_with_context(request, &OperationContext::internal())
-            .await
-    }
-
-    /// Cancel key deletion on behalf of `context`'s principal
-    pub async fn cancel_key_deletion_with_context(
-        &self,
-        request: CancelKeyDeletionRequest,
-        context: &OperationContext,
-    ) -> Result<CancelKeyDeletionResponse> {
-        let started = Instant::now();
-        let key_id = request.key_id.clone();
-        let result = self.cancel_key_deletion_inner(request).await;
-        self.audit(KmsAuditOperation::CancelKeyDeletion, context, Some(&key_id), started, &result);
-        result
-    }
-
-    async fn cancel_key_deletion_inner(&self, request: CancelKeyDeletionRequest) -> Result<CancelKeyDeletionResponse> {
        let response = self.backend.cancel_key_deletion(request).await?;

        // Update cache if enabled
@@ -292,60 +159,24 @@ impl KmsManager {
    }

    /// Enable a disabled key
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::enable_key_with_context`].
    pub async fn enable_key(&self, key_id: &str) -> Result<()> {
-        self.enable_key_with_context(key_id, &OperationContext::internal()).await
-    }
-
-    /// Enable a disabled key on behalf of `context`'s principal
-    pub async fn enable_key_with_context(&self, key_id: &str, context: &OperationContext) -> Result<()> {
-        let started = Instant::now();
-        let result = self.backend.enable_key(key_id).await;
-        if result.is_ok() {
-            self.invalidate_cached_metadata(key_id).await;
-        }
-        self.audit(KmsAuditOperation::EnableKey, context, Some(key_id), started, &result);
-        result
+        self.backend.enable_key(key_id).await?;
+        self.invalidate_cached_metadata(key_id).await;
+        Ok(())
    }

    /// Disable a key; existing data remains decryptable
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::disable_key_with_context`].
    pub async fn disable_key(&self, key_id: &str) -> Result<()> {
-        self.disable_key_with_context(key_id, &OperationContext::internal()).await
-    }
-
-    /// Disable a key on behalf of `context`'s principal
-    pub async fn disable_key_with_context(&self, key_id: &str, context: &OperationContext) -> Result<()> {
-        let started = Instant::now();
-        let result = self.backend.disable_key(key_id).await;
-        if result.is_ok() {
-            self.invalidate_cached_metadata(key_id).await;
-        }
-        self.audit(KmsAuditOperation::DisableKey, context, Some(key_id), started, &result);
-        result
+        self.backend.disable_key(key_id).await?;
+        self.invalidate_cached_metadata(key_id).await;
+        Ok(())
    }

    /// Rotate a key to a new version
-    ///
-    /// Audited as an internal operation; callers serving an authenticated
-    /// request should use [`Self::rotate_key_with_context`].
    pub async fn rotate_key(&self, key_id: &str) -> Result<()> {
-        self.rotate_key_with_context(key_id, &OperationContext::internal()).await
-    }
-
-    /// Rotate a key on behalf of `context`'s principal
-    pub async fn rotate_key_with_context(&self, key_id: &str, context: &OperationContext) -> Result<()> {
-        let started = Instant::now();
-        let result = self.backend.rotate_key(key_id).await;
-        if result.is_ok() {
-            self.invalidate_cached_metadata(key_id).await;
-        }
-        self.audit(KmsAuditOperation::RotateKey, context, Some(key_id), started, &result);
-        result
+        self.backend.rotate_key(key_id).await?;
+        self.invalidate_cached_metadata(key_id).await;
+        Ok(())
    }

    /// Drop cached metadata after a state mutation so the next describe
@@ -377,470 +208,11 @@ impl KmsManager {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::audit::KmsAuditOutcome;
    use crate::backends::local::LocalKmsBackend;
-    use crate::error::KmsError;
-    use crate::types::{KeyMetadata, KeySpec, KeyState, KeyUsage};
-    use async_trait::async_trait;
-    use base64::Engine as _;
-    use jiff::Zoned;
+    use crate::types::{KeySpec, KeyState, KeyUsage};
    use std::collections::HashMap;
-    use std::sync::Mutex;
    use tempfile::tempdir;

-    /// Sink that keeps every record so tests can assert on the audit trail.
-    #[derive(Default)]
-    struct CapturingSink {
-        records: Mutex<Vec<KmsAuditRecord>>,
-    }
-
-    impl KmsAuditSink for CapturingSink {
-        fn emit(&self, record: KmsAuditRecord) {
-            self.records
-                .lock()
-                .expect("audit records lock should not be poisoned")
-                .push(record);
-        }
-    }
-
-    impl CapturingSink {
-        fn records(&self) -> Vec<KmsAuditRecord> {
-            self.records
-                .lock()
-                .expect("audit records lock should not be poisoned")
-                .clone()
-        }
-
-        fn take_one(&self) -> KmsAuditRecord {
-            let mut records = self.records.lock().expect("audit records lock should not be poisoned");
-            assert_eq!(records.len(), 1, "expected exactly one audit record, got {records:?}");
-            records.remove(0)
-        }
-    }
-
-    /// Backend whose management operations all succeed or all fail, so a
-    /// single test can drive every audited operation down both paths —
-    /// including operations no real backend supports on both.
-    struct ScriptedBackend {
-        failure: Option<KmsError>,
-    }
-
-    impl ScriptedBackend {
-        fn succeeding() -> Self {
-            Self { failure: None }
-        }
-
-        fn failing(failure: KmsError) -> Self {
-            Self { failure: Some(failure) }
-        }
-
-        fn check(&self) -> Result<()> {
-            match &self.failure {
-                Some(failure) => Err(failure.clone()),
-                None => Ok(()),
-            }
-        }
-
-        fn metadata(key_id: &str) -> KeyMetadata {
-            KeyMetadata {
-                key_id: key_id.to_string(),
-                key_state: KeyState::Enabled,
-                key_usage: KeyUsage::EncryptDecrypt,
-                description: None,
-                creation_date: Zoned::now(),
-                deletion_date: None,
-                origin: "RUSTFS_KMS".to_string(),
-                key_manager: "RUSTFS".to_string(),
-                tags: HashMap::new(),
-            }
-        }
-    }
-
-    #[async_trait]
-    impl KmsBackend for ScriptedBackend {
-        async fn create_key(&self, request: CreateKeyRequest) -> Result<CreateKeyResponse> {
-            self.check()?;
-            let key_id = request.key_name.unwrap_or_else(|| "scripted-key".to_string());
-            Ok(CreateKeyResponse {
-                key_metadata: Self::metadata(&key_id),
-                key_id,
-            })
-        }
-
-        async fn encrypt(&self, _request: EncryptRequest) -> Result<EncryptResponse> {
-            unimplemented!("data plane is not audited by the manager")
-        }
-
-        async fn decrypt(&self, _request: DecryptRequest) -> Result<DecryptResponse> {
-            unimplemented!("data plane is not audited by the manager")
-        }
-
-        async fn generate_data_key(&self, _request: GenerateDataKeyRequest) -> Result<GenerateDataKeyResponse> {
-            unimplemented!("data plane is not audited by the manager")
-        }
-
-        async fn describe_key(&self, request: DescribeKeyRequest) -> Result<DescribeKeyResponse> {
-            self.check()?;
-            Ok(DescribeKeyResponse {
-                key_metadata: Self::metadata(&request.key_id),
-            })
-        }
-
-        async fn list_keys(&self, _request: ListKeysRequest) -> Result<ListKeysResponse> {
-            self.check()?;
-            Ok(ListKeysResponse {
-                keys: Vec::new(),
-                next_marker: None,
-                truncated: false,
-            })
-        }
-
-        async fn delete_key(&self, request: DeleteKeyRequest) -> Result<DeleteKeyResponse> {
-            self.check()?;
-            Ok(DeleteKeyResponse {
-                key_metadata: Self::metadata(&request.key_id),
-                key_id: request.key_id,
-                deletion_date: None,
-            })
-        }
-
-        async fn cancel_key_deletion(&self, request: CancelKeyDeletionRequest) -> Result<CancelKeyDeletionResponse> {
-            self.check()?;
-            Ok(CancelKeyDeletionResponse {
-                key_metadata: Self::metadata(&request.key_id),
-                key_id: request.key_id,
-            })
-        }
-
-        async fn enable_key(&self, _key_id: &str) -> Result<()> {
-            self.check()
-        }
-
-        async fn disable_key(&self, _key_id: &str) -> Result<()> {
-            self.check()
-        }
-
-        async fn rotate_key(&self, _key_id: &str) -> Result<()> {
-            self.check()
-        }
-
-        async fn health_check(&self) -> Result<bool> {
-            Ok(true)
-        }
-    }
-
-    const AUDITED_KEY_ID: &str = "audited-key";
-
-    /// Prefix length used when checking that a record embedded no *part* of a
-    /// secret. Long enough that a collision with unrelated text is not a real
-    /// concern.
-    const FRAGMENT_LEN: usize = 24;
-
-    fn scripted_manager(backend: ScriptedBackend) -> (KmsManager, Arc<CapturingSink>) {
-        let temp_dir = tempdir().expect("Failed to create temp dir");
-        let config = KmsConfig::local(temp_dir.path().to_path_buf()).with_insecure_development_defaults();
-        let sink = Arc::new(CapturingSink::default());
-        let manager = KmsManager::new(Arc::new(backend), config).with_audit_sink(sink.clone());
-        (manager, sink)
-    }
-
-    fn request_context() -> OperationContext {
-        OperationContext::new("arn:aws:iam::user/alice".to_string())
-            .with_source_ip("192.0.2.10".to_string())
-            .with_user_agent("rustfs-admin/1".to_string())
-            .with_context("requestID".to_string(), "req-42".to_string())
-    }
-
-    /// Drive one management operation and return the single record it emitted.
-    async fn run_operation(manager: &KmsManager, operation: KmsAuditOperation, context: &OperationContext) -> Result<()> {
-        match operation {
-            KmsAuditOperation::CreateKey => manager
-                .create_key_with_context(
-                    CreateKeyRequest {
-                        key_name: Some(AUDITED_KEY_ID.to_string()),
-                        ..Default::default()
-                    },
-                    context,
-                )
-                .await
-                .map(|_| ()),
-            KmsAuditOperation::DescribeKey => manager
-                .describe_key_with_context(
-                    DescribeKeyRequest {
-                        key_id: AUDITED_KEY_ID.to_string(),
-                    },
-                    context,
-                )
-                .await
-                .map(|_| ()),
-            KmsAuditOperation::ListKeys => manager
-                .list_keys_with_context(ListKeysRequest::default(), context)
-                .await
-                .map(|_| ()),
-            KmsAuditOperation::ScheduleKeyDeletion => manager
-                .delete_key_with_context(
-                    DeleteKeyRequest {
-                        key_id: AUDITED_KEY_ID.to_string(),
-                        pending_window_in_days: None,
-                        force_immediate: None,
-                    },
-                    context,
-                )
-                .await
-                .map(|_| ()),
-            KmsAuditOperation::CancelKeyDeletion => manager
-                .cancel_key_deletion_with_context(
-                    CancelKeyDeletionRequest {
-                        key_id: AUDITED_KEY_ID.to_string(),
-                    },
-                    context,
-                )
-                .await
-                .map(|_| ()),
-            KmsAuditOperation::EnableKey => manager.enable_key_with_context(AUDITED_KEY_ID, context).await,
-            KmsAuditOperation::DisableKey => manager.disable_key_with_context(AUDITED_KEY_ID, context).await,
-            KmsAuditOperation::RotateKey => manager.rotate_key_with_context(AUDITED_KEY_ID, context).await,
-            // Physical removal happens on the background sweep, not here.
-            KmsAuditOperation::DeleteKey => unreachable!("removal is audited by the deletion worker"),
-        }
-    }
-
-    /// Every management operation the manager serves, in audit terms.
-    const AUDITED_OPERATIONS: [KmsAuditOperation; 8] = [
-        KmsAuditOperation::CreateKey,
-        KmsAuditOperation::DescribeKey,
-        KmsAuditOperation::ListKeys,
-        KmsAuditOperation::ScheduleKeyDeletion,
-        KmsAuditOperation::CancelKeyDeletion,
-        KmsAuditOperation::EnableKey,
-        KmsAuditOperation::DisableKey,
-        KmsAuditOperation::RotateKey,
-    ];
-
-    #[tokio::test]
-    async fn every_management_operation_emits_a_complete_success_record() {
-        for operation in AUDITED_OPERATIONS {
-            let (manager, sink) = scripted_manager(ScriptedBackend::succeeding());
-            let context = request_context();
-
-            let outer = Instant::now();
-            run_operation(&manager, operation, &context)
-                .await
-                .unwrap_or_else(|error| panic!("{} should succeed: {error}", operation.as_str()));
-            let outer_elapsed = outer.elapsed();
-
-            let record = sink.take_one();
-            assert_eq!(record.operation, operation);
-            assert_eq!(record.event, operation.event_name());
-            assert_eq!(record.outcome, KmsAuditOutcome::Success);
-            assert_eq!(record.error_class, None);
-            assert_eq!(record.operation_id, context.operation_id);
-            assert_eq!(record.principal, "arn:aws:iam::user/alice");
-            assert_eq!(record.source_ip.as_deref(), Some("192.0.2.10"));
-            assert_eq!(record.user_agent.as_deref(), Some("rustfs-admin/1"));
-            assert_eq!(record.backend, "local");
-            assert_eq!(record.context.get("requestID").map(String::as_str), Some("req-42"));
-            assert!(
-                record.latency <= outer_elapsed,
-                "{} reported a latency larger than the call it measured",
-                operation.as_str()
-            );
-
-            // Listing spans keys; every other operation names the key it touched.
-            if operation == KmsAuditOperation::ListKeys {
-                assert_eq!(record.key_id, None);
-            } else {
-                assert_eq!(record.key_id.as_deref(), Some(AUDITED_KEY_ID));
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn every_management_operation_emits_a_failure_record() {
-        for operation in AUDITED_OPERATIONS {
-            let (manager, sink) = scripted_manager(ScriptedBackend::failing(KmsError::access_denied("denied by policy")));
-            let context = request_context();
-
-            let error = run_operation(&manager, operation, &context)
-                .await
-                .expect_err("scripted backend should reject the operation");
-            assert!(matches!(error, KmsError::AccessDenied { .. }));
-
-            let record = sink.take_one();
-            assert_eq!(record.operation, operation);
-            assert_eq!(record.event, operation.event_name());
-            assert_eq!(record.outcome, KmsAuditOutcome::Failure);
-            assert_eq!(record.error_class, Some("access_denied"));
-            assert_eq!(record.operation_id, context.operation_id);
-            assert_eq!(record.principal, "arn:aws:iam::user/alice");
-            assert_eq!(record.source_ip.as_deref(), Some("192.0.2.10"));
-
-            // A denied create still has to name the key the caller asked for,
-            // otherwise the record cannot answer "what were they after".
-            if operation != KmsAuditOperation::ListKeys {
-                assert_eq!(record.key_id.as_deref(), Some(AUDITED_KEY_ID));
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn operations_are_unaffected_when_no_sink_is_installed() {
-        // The audit trail is optional; without a sink the manager must behave
-        // exactly as it did before records existed.
-        let temp_dir = tempdir().expect("Failed to create temp dir");
-        let config = KmsConfig::local(temp_dir.path().to_path_buf()).with_insecure_development_defaults();
-        let manager = KmsManager::new(Arc::new(ScriptedBackend::succeeding()), config);
-
-        for operation in AUDITED_OPERATIONS {
-            run_operation(&manager, operation, &request_context())
-                .await
-                .unwrap_or_else(|error| panic!("{} should succeed without a sink: {error}", operation.as_str()));
-        }
-    }
-
-    #[tokio::test]
-    async fn context_free_calls_are_attributed_to_the_internal_principal() {
-        // Callers that have no authenticated identity must still be
-        // distinguishable from an identity we failed to record.
-        let (manager, sink) = scripted_manager(ScriptedBackend::succeeding());
-
-        manager
-            .describe_key(DescribeKeyRequest {
-                key_id: AUDITED_KEY_ID.to_string(),
-            })
-            .await
-            .expect("describe should succeed");
-
-        let record = sink.take_one();
-        assert_eq!(record.principal, OperationContext::INTERNAL_PRINCIPAL);
-        assert_eq!(record.source_ip, None);
-        assert_eq!(record.user_agent, None);
-    }
-
-    #[tokio::test]
-    async fn unsupported_lifecycle_operations_are_audited_with_their_own_class() {
-        // The local backend has no version history, so rotation is a capability
-        // gap rather than a policy denial; the audit trail must say so.
-        let temp_dir = tempdir().expect("Failed to create temp dir");
-        let config = KmsConfig::local(temp_dir.path().to_path_buf()).with_insecure_development_defaults();
-        let backend = Arc::new(LocalKmsBackend::new(config.clone()).await.expect("Failed to create backend"));
-        let sink = Arc::new(CapturingSink::default());
-        let manager = KmsManager::new(backend, config).with_audit_sink(sink.clone());
-
-        let key_id = manager
-            .create_key_with_context(
-                CreateKeyRequest {
-                    key_name: Some("rotate-me".to_string()),
-                    ..Default::default()
-                },
-                &request_context(),
-            )
-            .await
-            .expect("create should succeed")
-            .key_id;
-
-        manager
-            .rotate_key_with_context(&key_id, &request_context())
-            .await
-            .expect_err("local rotation must be rejected");
-
-        let records = sink.records();
-        let rotate = records.last().expect("rotation should be audited");
-        assert_eq!(rotate.operation, KmsAuditOperation::RotateKey);
-        assert_eq!(rotate.outcome, KmsAuditOutcome::Failure);
-        assert_eq!(rotate.error_class, Some("unsupported_capability"));
-        assert_eq!(rotate.key_id.as_deref(), Some(key_id.as_str()));
-    }
-
-    /// Negative assertion: no audit record may reproduce key material. Driven
-    /// against the real local backend so the assertion covers whatever the
-    /// backend actually hands back, not a hand-written stand-in.
-    #[tokio::test]
-    async fn audit_records_never_reproduce_key_material() {
-        let temp_dir = tempdir().expect("Failed to create temp dir");
-        let config = KmsConfig::local(temp_dir.path().to_path_buf()).with_insecure_development_defaults();
-        let backend = Arc::new(LocalKmsBackend::new(config.clone()).await.expect("Failed to create backend"));
-        let sink = Arc::new(CapturingSink::default());
-        let manager = KmsManager::new(backend, config).with_audit_sink(sink.clone());
-
-        let grant_token = "grant-token-cec4d4b5a1";
-        let context = request_context();
-
-        let key_id = manager
-            .create_key_with_context(
-                CreateKeyRequest {
-                    key_name: Some("material-key".to_string()),
-                    ..Default::default()
-                },
-                &context,
-            )
-            .await
-            .expect("create should succeed")
-            .key_id;
-
-        // Produce real key material, then keep driving the management plane so
-        // any record built afterwards is covered by the assertions below.
-        let data_key = manager
-            .generate_data_key(GenerateDataKeyRequest {
-                key_id: key_id.clone(),
-                key_spec: KeySpec::Aes256,
-                encryption_context: HashMap::from([("bucket".to_string(), "secrets".to_string())]),
-            })
-            .await
-            .expect("data key generation should succeed");
-        let decrypted = manager
-            .decrypt(DecryptRequest {
-                ciphertext: data_key.ciphertext_blob.clone(),
-                encryption_context: HashMap::from([("bucket".to_string(), "secrets".to_string())]),
-                grant_tokens: vec![grant_token.to_string()],
-            })
-            .await
-            .expect("decrypt should succeed");
-
-        manager
-            .describe_key_with_context(DescribeKeyRequest { key_id: key_id.clone() }, &context)
-            .await
-            .expect("describe should succeed");
-        manager
-            .list_keys_with_context(ListKeysRequest::default(), &context)
-            .await
-            .expect("list should succeed");
-        manager
-            .disable_key_with_context(&key_id, &context)
-            .await
-            .expect("disable should succeed");
-        manager
-            .enable_key_with_context(&key_id, &context)
-            .await
-            .expect("enable should succeed");
-
-        let base64 = base64::engine::general_purpose::STANDARD;
-        let encodings = |bytes: &[u8]| vec![hex::encode(bytes), base64.encode(bytes)];
-        let mut forbidden = vec![grant_token.to_string()];
-        forbidden.extend(encodings(&data_key.plaintext_key));
-        forbidden.extend(encodings(&decrypted.plaintext));
-        forbidden.extend(encodings(&data_key.ciphertext_blob));
-        // Fragments catch a record that embedded only part of a blob.
-        let fragments: Vec<String> = forbidden
-            .iter()
-            .filter(|secret| secret.len() > FRAGMENT_LEN)
-            .map(|secret| secret[..FRAGMENT_LEN].to_string())
-            .collect();
-        forbidden.extend(fragments);
-
-        let records = sink.records();
-        assert!(!records.is_empty(), "management operations should have been audited");
-        for record in &records {
-            let rendered = format!("{record:?}");
-            for secret in &forbidden {
-                assert!(
-                    !rendered.contains(secret.as_str()),
-                    "audit record leaked key material or a grant token: {rendered}"
-                );
-            }
-        }
-    }
-
    #[tokio::test]
    async fn test_manager_operations() {
        let temp_dir = tempdir().expect("Failed to create temp dir");
@@ -1,894 +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.
-
-//! Background synthetic probe for the configured KMS backend.
-//!
-//! A health check that only reports "the backend answered" cannot distinguish a
-//! usable KMS from one that is reachable but no longer returns material that
-//! round-trips. Each probe round therefore generates a data key under a
-//! dedicated key, decrypts the returned ciphertext, and compares the plaintext,
-//! so a backend that answers without being usable becomes visible before object
-//! traffic depends on it.
-//!
-//! The probe key uses a fixed reserved id ([`PROBE_KEY_ID`]) and is created only
-//! when missing, so every node of a deployment converges on the same key and a
-//! create that loses the race against another node is a success, not an error.
-//!
-//! Backends that cannot host such a key — single-key read-only backends, or
-//! backends without data key generation — are reported as
-//! [`ProbeResult::Unsupported`] exactly once and then left alone: an
-//! unsupported backend is a configuration fact, not an outage, and must never
-//! raise failure metrics or alerts.
-//!
-//! Results are published two ways: as a lock-free [`ProbeStatus`] snapshot that
-//! readiness reporting can read without touching the backend, and as
-//! `rustfs_kms_probe_*` metrics. As everywhere else in this crate, metric labels
-//! carry only static outcome classes — never key identifiers, key material, or
-//! ciphertext.
-
-use crate::backends::KmsBackend;
-use crate::error::KmsError;
-use crate::types::{CreateKeyRequest, DecryptRequest, DescribeKeyRequest, GenerateDataKeyRequest, KeySpec, KeyUsage};
-use arc_swap::ArcSwap;
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Duration;
-use subtle::ConstantTimeEq;
-use tokio::time::Instant;
-use tokio_util::sync::CancellationToken;
-use tracing::{debug, info, warn};
-use zeroize::Zeroize;
-
-/// Reserved id of the key every probe round runs through.
-///
-/// Fixed rather than per-node or per-process: all nodes must converge on one
-/// key instead of littering the backend with probe keys, and the reserved
-/// `rustfs-internal-` prefix marks it as RustFS-owned for operators reviewing
-/// the key list.
-pub const PROBE_KEY_ID: &str = "rustfs-internal-kms-probe";
-
-/// Description stored on the probe key when this node creates it.
-const PROBE_KEY_DESCRIPTION: &str = "RustFS internal KMS health probe key; created and used only by the synthetic probe";
-
-/// Default interval between probe rounds.
-pub const DEFAULT_PROBE_INTERVAL: Duration = Duration::from_secs(60);
-
-/// Floor for the configured interval. Probing faster buys no additional signal
-/// and multiplies backend load by the size of the deployment.
-pub const MIN_PROBE_INTERVAL: Duration = Duration::from_secs(5);
-
-/// Probe interval in whole seconds; `0` disables the probe entirely.
-pub const ENV_KMS_PROBE_INTERVAL_SECS: &str = "RUSTFS_KMS_PROBE_INTERVAL_SECS";
-
-/// Result of the most recent probe round.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ProbeResult {
-    /// No round has completed yet for this service version.
-    Pending,
-    /// The full generate/decrypt/compare cycle succeeded.
-    Success,
-    /// The backend cannot host the probe key; no further rounds run and no
-    /// failures are recorded.
-    Unsupported,
-    /// The round failed with the given classification.
-    Failure(ProbeFailureKind),
-}
-
-impl ProbeResult {
-    /// Static metric label for this result.
-    fn as_label(self) -> &'static str {
-        match self {
-            ProbeResult::Pending => "pending",
-            ProbeResult::Success => "success",
-            ProbeResult::Unsupported => "unsupported",
-            ProbeResult::Failure(_) => "failure",
-        }
-    }
-}
-
-/// Stage of the round trip that failed, used as a static metric label.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ProbeFailureKind {
-    /// The dedicated probe key could not be described or created.
-    KeyProvisioning,
-    /// Data key generation failed.
-    Generate,
-    /// The freshly generated ciphertext could not be decrypted.
-    Decrypt,
-    /// Decryption succeeded but returned material that differs from what was
-    /// generated — the backend answers without round-tripping.
-    Mismatch,
-}
-
-impl ProbeFailureKind {
-    /// Static metric label for this failure class.
-    fn as_label(self) -> &'static str {
-        match self {
-            ProbeFailureKind::KeyProvisioning => "key_provisioning",
-            ProbeFailureKind::Generate => "generate",
-            ProbeFailureKind::Decrypt => "decrypt",
-            ProbeFailureKind::Mismatch => "mismatch",
-        }
-    }
-}
-
-/// Snapshot of what the probe has observed so far.
-///
-/// Consumed by readiness reporting, which owns the staleness and consecutive
-/// failure thresholds; the probe itself only records what happened.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ProbeStatus {
-    /// Result of the most recent completed round.
-    pub result: ProbeResult,
-    /// When the most recent round completed.
-    pub last_round_at: Option<Instant>,
-    /// When the most recent successful round completed.
-    pub last_success_at: Option<Instant>,
-    /// Wall-clock timestamp of the most recent success, in Unix seconds, for
-    /// display and for the exported gauge. Use [`ProbeStatus::last_success_age`]
-    /// for staleness decisions: it is monotonic and immune to clock steps.
-    pub last_success_unix_secs: Option<i64>,
-    /// Failed rounds since the last success; reset by any non-failure result.
-    pub consecutive_failures: u32,
-}
-
-impl ProbeStatus {
-    /// Initial snapshot published before the first round completes.
-    fn pending() -> Self {
-        Self {
-            result: ProbeResult::Pending,
-            last_round_at: None,
-            last_success_at: None,
-            last_success_unix_secs: None,
-            consecutive_failures: 0,
-        }
-    }
-
-    /// How long ago the most recent round completed.
-    pub fn last_round_age(&self) -> Option<Duration> {
-        self.last_round_at.map(|at| at.elapsed())
-    }
-
-    /// How long ago the most recent successful round completed.
-    pub fn last_success_age(&self) -> Option<Duration> {
-        self.last_success_at.map(|at| at.elapsed())
-    }
-}
-
-/// Lock-free publication slot for [`ProbeStatus`].
-///
-/// Written by the single worker task and read by anyone; readers never block
-/// the probe and the probe never blocks a readiness handler.
-struct ProbeState {
-    status: ArcSwap<ProbeStatus>,
-}
-
-impl ProbeState {
-    fn new() -> Self {
-        Self {
-            status: ArcSwap::from_pointee(ProbeStatus::pending()),
-        }
-    }
-
-    fn status(&self) -> Arc<ProbeStatus> {
-        self.status.load_full()
-    }
-
-    /// Fold one round result into the published snapshot.
-    ///
-    /// Safe as a plain load-then-store because the owning worker task is the
-    /// only writer.
-    fn publish(&self, result: ProbeResult) {
-        let previous = self.status.load();
-        let now = Instant::now();
-        let (last_success_at, last_success_unix_secs) = match result {
-            ProbeResult::Success => (Some(now), Some(jiff::Timestamp::now().as_second())),
-            _ => (previous.last_success_at, previous.last_success_unix_secs),
-        };
-        let consecutive_failures = match result {
-            ProbeResult::Failure(_) => previous.consecutive_failures.saturating_add(1),
-            _ => 0,
-        };
-        self.status.store(Arc::new(ProbeStatus {
-            result,
-            last_round_at: Some(now),
-            last_success_at,
-            last_success_unix_secs,
-            consecutive_failures,
-        }));
-        record_state(result, last_success_unix_secs, consecutive_failures);
-    }
-}
-
-/// Owner of one service version's probe worker.
-///
-/// Mirrors the deletion worker's ownership model: cancelling stops the loop,
-/// and dropping the handle — a service version replaced without an explicit
-/// stop — cancels as a safety net.
-pub struct ProbeHandle {
-    state: Arc<ProbeState>,
-    cancel: CancellationToken,
-    task: std::sync::Mutex<Option<tokio::task::JoinHandle<()>>>,
-}
-
-impl ProbeHandle {
-    /// Latest published snapshot.
-    pub fn status(&self) -> Arc<ProbeStatus> {
-        self.state.status()
-    }
-
-    /// Stop the worker. The task observes the cancelled token on its next poll.
-    pub(crate) fn shutdown(&self) {
-        self.cancel.cancel();
-        if let Ok(mut task) = self.task.lock() {
-            drop(task.take());
-        }
-    }
-
-    #[cfg(test)]
-    pub(crate) fn is_cancelled(&self) -> bool {
-        self.cancel.is_cancelled()
-    }
-}
-
-impl Drop for ProbeHandle {
-    fn drop(&mut self) {
-        self.cancel.cancel();
-    }
-}
-
-/// Start the probe for a service version.
-///
-/// Returns `None` when the backend advertises no data key round trip, or when
-/// the operator disabled the probe; both cases leave no background task behind.
-pub(crate) fn spawn_probe_worker(backend: Arc<dyn KmsBackend>) -> Option<ProbeHandle> {
-    let capabilities = backend.capabilities();
-    if !capabilities.generate_data_key || !capabilities.decrypt {
-        return None;
-    }
-    let interval = configured_interval()?;
-    let state = Arc::new(ProbeState::new());
-    let cancel = CancellationToken::new();
-    let task = ProbeWorker::new(backend, state.clone(), interval).spawn(cancel.clone());
-    Some(ProbeHandle {
-        state,
-        cancel,
-        task: std::sync::Mutex::new(Some(task)),
-    })
-}
-
-/// Probe interval from the environment, or `None` when the probe is disabled.
-fn configured_interval() -> Option<Duration> {
-    parse_interval(std::env::var(ENV_KMS_PROBE_INTERVAL_SECS).ok().as_deref())
-}
-
-/// Interpret the configured interval: unset or unparsable falls back to the
-/// default, `0` disables the probe, and anything below [`MIN_PROBE_INTERVAL`]
-/// is raised to it so a misconfigured value cannot turn the probe into a load
-/// generator against the backend.
-fn parse_interval(value: Option<&str>) -> Option<Duration> {
-    let Some(value) = value else {
-        return Some(DEFAULT_PROBE_INTERVAL);
-    };
-    let Ok(seconds) = value.trim().parse::<u64>() else {
-        warn!(
-            variable = ENV_KMS_PROBE_INTERVAL_SECS,
-            "ignoring unparsable KMS probe interval; falling back to the default"
-        );
-        return Some(DEFAULT_PROBE_INTERVAL);
-    };
-    if seconds == 0 {
-        return None;
-    }
-    Some(Duration::from_secs(seconds).max(MIN_PROBE_INTERVAL))
-}
-
-/// Encryption context bound to every probe data key.
-///
-/// Static and free of per-node values, so material generated by one node stays
-/// decryptable by every other node running the same probe.
-fn probe_encryption_context() -> HashMap<String, String> {
-    HashMap::from([("rustfs-purpose".to_string(), "kms-probe".to_string())])
-}
-
-/// Outcome of making sure the dedicated probe key exists.
-enum KeyProvisioning {
-    Ready,
-    Unsupported,
-    Failed,
-}
-
-pub(crate) struct ProbeWorker {
-    backend: Arc<dyn KmsBackend>,
-    state: Arc<ProbeState>,
-    interval: Duration,
-}
-
-impl ProbeWorker {
-    fn new(backend: Arc<dyn KmsBackend>, state: Arc<ProbeState>, interval: Duration) -> Self {
-        Self {
-            backend,
-            state,
-            interval,
-        }
-    }
-
-    fn spawn(self, cancel: CancellationToken) -> tokio::task::JoinHandle<()> {
-        tokio::spawn(async move { self.run(cancel).await })
-    }
-
-    async fn run(self, cancel: CancellationToken) {
-        describe_metrics();
-        let mut ticker = tokio::time::interval(self.interval);
-        ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
-        loop {
-            tokio::select! {
-                _ = cancel.cancelled() => {
-                    debug!("KMS probe worker stopped");
-                    return;
-                }
-                _ = ticker.tick() => {}
-            }
-            let started = Instant::now();
-            let result = self.round().await;
-            record_round(result, started.elapsed());
-            self.state.publish(result);
-            if result == ProbeResult::Unsupported {
-                // A capability gap does not change while a service version
-                // lives, so retrying it forever would only produce noise.
-                info!("KMS backend cannot host the synthetic probe key; probe disabled for this service version");
-                return;
-            }
-        }
-    }
-
-    /// Run one round. Exposed separately so tests can drive the round trip
-    /// deterministically without the interval loop.
-    pub(crate) async fn round(&self) -> ProbeResult {
-        let capabilities = self.backend.capabilities();
-        if !capabilities.generate_data_key || !capabilities.decrypt {
-            return ProbeResult::Unsupported;
-        }
-        match self.ensure_probe_key().await {
-            KeyProvisioning::Ready => {}
-            KeyProvisioning::Unsupported => return ProbeResult::Unsupported,
-            KeyProvisioning::Failed => return ProbeResult::Failure(ProbeFailureKind::KeyProvisioning),
-        }
-
-        let mut generated = match self
-            .backend
-            .generate_data_key(GenerateDataKeyRequest {
-                key_id: PROBE_KEY_ID.to_string(),
-                key_spec: KeySpec::Aes256,
-                encryption_context: probe_encryption_context(),
-            })
-            .await
-        {
-            Ok(generated) => generated,
-            Err(error) => {
-                warn!(%error, "KMS probe could not generate a data key");
-                return ProbeResult::Failure(ProbeFailureKind::Generate);
-            }
-        };
-
-        let decrypted = self
-            .backend
-            .decrypt(DecryptRequest {
-                ciphertext: generated.ciphertext_blob.clone(),
-                encryption_context: probe_encryption_context(),
-                grant_tokens: Vec::new(),
-            })
-            .await;
-
-        let result = match decrypted {
-            Ok(mut response) => {
-                let round_trips = bool::from(response.plaintext.ct_eq(&generated.plaintext_key));
-                response.plaintext.zeroize();
-                if round_trips {
-                    debug!("KMS probe round trip succeeded");
-                    ProbeResult::Success
-                } else {
-                    // The backend answered both calls but the material does not
-                    // survive the round trip: report it as loudly as an outage.
-                    warn!("KMS probe decrypted material does not match the generated data key");
-                    ProbeResult::Failure(ProbeFailureKind::Mismatch)
-                }
-            }
-            Err(error) => {
-                warn!(%error, "KMS probe could not decrypt its generated data key");
-                ProbeResult::Failure(ProbeFailureKind::Decrypt)
-            }
-        };
-        generated.plaintext_key.zeroize();
-        result
-    }
-
-    /// Create the probe key if it is missing.
-    ///
-    /// Idempotent by construction: an existing key is used as is, and a create
-    /// that loses the race against another node reports the key as ready
-    /// instead of failing the round.
-    async fn ensure_probe_key(&self) -> KeyProvisioning {
-        match self
-            .backend
-            .describe_key(DescribeKeyRequest {
-                key_id: PROBE_KEY_ID.to_string(),
-            })
-            .await
-        {
-            Ok(_) => return KeyProvisioning::Ready,
-            Err(KmsError::KeyNotFound { .. }) => {}
-            Err(error) if is_capability_gap(&error) => return KeyProvisioning::Unsupported,
-            Err(error) => {
-                warn!(%error, "KMS probe could not describe its probe key");
-                return KeyProvisioning::Failed;
-            }
-        }
-
-        match self
-            .backend
-            .create_key(CreateKeyRequest {
-                key_name: Some(PROBE_KEY_ID.to_string()),
-                key_usage: KeyUsage::EncryptDecrypt,
-                description: Some(PROBE_KEY_DESCRIPTION.to_string()),
-                ..Default::default()
-            })
-            .await
-        {
-            Ok(_) => {
-                info!(key_id = PROBE_KEY_ID, "created the KMS synthetic probe key");
-                KeyProvisioning::Ready
-            }
-            // Another node created the key between the describe and the create.
-            Err(KmsError::KeyAlreadyExists { .. }) => KeyProvisioning::Ready,
-            Err(error) if is_capability_gap(&error) => KeyProvisioning::Unsupported,
-            Err(error) => {
-                warn!(%error, "KMS probe could not create its probe key");
-                KeyProvisioning::Failed
-            }
-        }
-    }
-}
-
-/// Whether an error means "this backend will never host a probe key".
-///
-/// Read-only single-key backends reject key creation outright, and backends
-/// without the operation report an unsupported capability. Both are properties
-/// of the configuration rather than symptoms of an outage, so they stop the
-/// probe instead of counting as failures.
-fn is_capability_gap(error: &KmsError) -> bool {
-    matches!(error, KmsError::UnsupportedCapability { .. } | KmsError::InvalidOperation { .. })
-}
-
-// ---------------------------------------------------------------------------
-// Metrics
-//
-// Label values are exclusively static outcome classes; the probe key id is a
-// compile-time constant and still never becomes a label, so the metric shape
-// stays independent of how many keys or nodes exist.
-// ---------------------------------------------------------------------------
-
-/// Counter: probe rounds completed, by `result`.
-const METRIC_PROBE_ROUNDS_TOTAL: &str = "rustfs_kms_probe_rounds_total";
-/// Counter: failed probe rounds, by `failure_kind`.
-const METRIC_PROBE_FAILURES_TOTAL: &str = "rustfs_kms_probe_failures_total";
-/// Histogram: wall-clock duration of one probe round, in seconds, by `result`.
-const METRIC_PROBE_DURATION_SECONDS: &str = "rustfs_kms_probe_duration_seconds";
-/// Gauge: Unix timestamp of the most recent successful round.
-const METRIC_PROBE_LAST_SUCCESS_TIMESTAMP: &str = "rustfs_kms_probe_last_success_timestamp_seconds";
-/// Gauge: failed rounds since the last success.
-const METRIC_PROBE_CONSECUTIVE_FAILURES: &str = "rustfs_kms_probe_consecutive_failures";
-
-/// Register metric descriptions once per process.
-fn describe_metrics() {
-    static DESCRIBE: std::sync::Once = std::sync::Once::new();
-    DESCRIBE.call_once(|| {
-        metrics::describe_counter!(METRIC_PROBE_ROUNDS_TOTAL, "Total synthetic KMS probe rounds completed, by result");
-        metrics::describe_counter!(
-            METRIC_PROBE_FAILURES_TOTAL,
-            "Total failed synthetic KMS probe rounds, by the round-trip stage that failed"
-        );
-        metrics::describe_histogram!(
-            METRIC_PROBE_DURATION_SECONDS,
-            "Wall-clock duration of one synthetic KMS probe round, in seconds"
-        );
-        metrics::describe_gauge!(
-            METRIC_PROBE_LAST_SUCCESS_TIMESTAMP,
-            "Unix timestamp of the most recent successful synthetic KMS probe round"
-        );
-        metrics::describe_gauge!(
-            METRIC_PROBE_CONSECUTIVE_FAILURES,
-            "Synthetic KMS probe rounds that have failed since the last success"
-        );
-    });
-}
-
-/// Record one completed round.
-///
-/// An unsupported backend is deliberately counted as its own result and never
-/// as a failure, so alerts on the failure counter stay silent for deployments
-/// whose backend cannot host the probe.
-fn record_round(result: ProbeResult, elapsed: Duration) {
-    metrics::counter!(METRIC_PROBE_ROUNDS_TOTAL, "result" => result.as_label()).increment(1);
-    if let ProbeResult::Failure(kind) = result {
-        metrics::counter!(METRIC_PROBE_FAILURES_TOTAL, "failure_kind" => kind.as_label()).increment(1);
-    }
-    metrics::histogram!(METRIC_PROBE_DURATION_SECONDS, "result" => result.as_label()).record(elapsed.as_secs_f64());
-}
-
-/// Mirror the published snapshot into the gauges.
-fn record_state(result: ProbeResult, last_success_unix_secs: Option<i64>, consecutive_failures: u32) {
-    if result == ProbeResult::Success
-        && let Some(timestamp) = last_success_unix_secs
-    {
-        // Only ever moved forward by a success, so a failing probe leaves the
-        // gauge at the last known good time and its age keeps growing.
-        metrics::gauge!(METRIC_PROBE_LAST_SUCCESS_TIMESTAMP).set(timestamp as f64);
-    }
-    metrics::gauge!(METRIC_PROBE_CONSECUTIVE_FAILURES).set(f64::from(consecutive_failures));
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::backends::local::LocalKmsBackend;
-    use crate::backends::static_kms::StaticKmsBackend;
-    use crate::config::KmsConfig;
-    use crate::types::{
-        CancelKeyDeletionRequest, CancelKeyDeletionResponse, CreateKeyResponse, DecryptResponse, DeleteKeyRequest,
-        DeleteKeyResponse, DescribeKeyResponse, EncryptRequest, EncryptResponse, GenerateDataKeyResponse, KeyMetadata, KeyState,
-        ListKeysRequest, ListKeysResponse,
-    };
-    use async_trait::async_trait;
-    use base64::Engine as _;
-    use metrics_util::MetricKind;
-    use metrics_util::debugging::{DebugValue, DebuggingRecorder};
-    use std::future::Future;
-
-    async fn local_backend(temp_dir: &tempfile::TempDir) -> Arc<dyn KmsBackend> {
-        let config = KmsConfig::local(temp_dir.path().to_path_buf()).with_insecure_development_defaults();
-        Arc::new(LocalKmsBackend::new(config).await.expect("local backend should build"))
-    }
-
-    async fn static_backend() -> Arc<dyn KmsBackend> {
-        let config =
-            KmsConfig::static_kms("static-key".to_string(), base64::engine::general_purpose::STANDARD.encode([0x42u8; 32]));
-        Arc::new(StaticKmsBackend::new(config).await.expect("static backend should build"))
-    }
-
-    fn worker(backend: Arc<dyn KmsBackend>) -> ProbeWorker {
-        ProbeWorker::new(backend, Arc::new(ProbeState::new()), DEFAULT_PROBE_INTERVAL)
-    }
-
-    /// Backend that answers every probe call but corrupts the round trip in a
-    /// configurable way, so each failure classification can be provoked without
-    /// a real backend outage.
-    struct BrokenBackend {
-        fault: Fault,
-    }
-
-    #[derive(Clone, Copy)]
-    enum Fault {
-        Generate,
-        Decrypt,
-        /// Decrypt succeeds but returns material other than the generated key.
-        Mismatch,
-    }
-
-    impl BrokenBackend {
-        fn arc(fault: Fault) -> Arc<dyn KmsBackend> {
-            Arc::new(Self { fault })
-        }
-
-        fn probe_key_metadata() -> KeyMetadata {
-            KeyMetadata {
-                key_id: PROBE_KEY_ID.to_string(),
-                key_state: KeyState::Enabled,
-                key_usage: KeyUsage::EncryptDecrypt,
-                description: None,
-                creation_date: jiff::Zoned::now(),
-                deletion_date: None,
-                origin: "test".to_string(),
-                key_manager: "test".to_string(),
-                tags: HashMap::new(),
-            }
-        }
-    }
-
-    #[async_trait]
-    impl KmsBackend for BrokenBackend {
-        async fn create_key(&self, _request: CreateKeyRequest) -> crate::error::Result<CreateKeyResponse> {
-            unimplemented!("the probe key always exists on this backend")
-        }
-
-        async fn encrypt(&self, _request: EncryptRequest) -> crate::error::Result<EncryptResponse> {
-            unimplemented!("not exercised by probe tests")
-        }
-
-        async fn decrypt(&self, _request: DecryptRequest) -> crate::error::Result<DecryptResponse> {
-            match self.fault {
-                Fault::Decrypt => Err(KmsError::backend_error("decrypt unavailable")),
-                Fault::Mismatch => Ok(DecryptResponse {
-                    plaintext: vec![0xffu8; 32],
-                    key_id: PROBE_KEY_ID.to_string(),
-                    encryption_algorithm: None,
-                }),
-                Fault::Generate => unreachable!("generation fails before decrypt is reached"),
-            }
-        }
-
-        async fn generate_data_key(&self, _request: GenerateDataKeyRequest) -> crate::error::Result<GenerateDataKeyResponse> {
-            match self.fault {
-                Fault::Generate => Err(KmsError::backend_error("data key generation unavailable")),
-                _ => Ok(GenerateDataKeyResponse {
-                    key_id: PROBE_KEY_ID.to_string(),
-                    plaintext_key: vec![0x11u8; 32],
-                    ciphertext_blob: vec![0x22u8; 48],
-                }),
-            }
-        }
-
-        async fn describe_key(&self, _request: DescribeKeyRequest) -> crate::error::Result<DescribeKeyResponse> {
-            Ok(DescribeKeyResponse {
-                key_metadata: Self::probe_key_metadata(),
-            })
-        }
-
-        async fn list_keys(&self, _request: ListKeysRequest) -> crate::error::Result<ListKeysResponse> {
-            unimplemented!("not exercised by probe tests")
-        }
-
-        async fn delete_key(&self, _request: DeleteKeyRequest) -> crate::error::Result<DeleteKeyResponse> {
-            unimplemented!("not exercised by probe tests")
-        }
-
-        async fn cancel_key_deletion(
-            &self,
-            _request: CancelKeyDeletionRequest,
-        ) -> crate::error::Result<CancelKeyDeletionResponse> {
-            unimplemented!("not exercised by probe tests")
-        }
-
-        async fn health_check(&self) -> crate::error::Result<bool> {
-            Ok(true)
-        }
-    }
-
-    #[tokio::test]
-    async fn round_creates_the_probe_key_once_and_round_trips_it() {
-        let temp_dir = tempfile::tempdir().expect("temp dir");
-        let backend = local_backend(&temp_dir).await;
-        let worker = worker(backend.clone());
-
-        assert_eq!(worker.round().await, ProbeResult::Success);
-        let created = backend
-            .describe_key(DescribeKeyRequest {
-                key_id: PROBE_KEY_ID.to_string(),
-            })
-            .await
-            .expect("the first round must create the probe key");
-        assert_eq!(created.key_metadata.key_id, PROBE_KEY_ID);
-
-        // A second round reuses the key instead of failing on the existing one,
-        // which is also what a second node in the deployment would do.
-        assert_eq!(worker.round().await, ProbeResult::Success);
-        assert_eq!(
-            backend
-                .list_keys(ListKeysRequest {
-                    limit: Some(100),
-                    marker: None,
-                    usage_filter: None,
-                    status_filter: None,
-                })
-                .await
-                .expect("list keys")
-                .keys
-                .iter()
-                .filter(|key| key.key_id == PROBE_KEY_ID)
-                .count(),
-            1,
-            "probe key creation must be idempotent"
-        );
-    }
-
-    #[test]
-    fn read_only_backend_is_reported_unsupported_without_failures() {
-        let (snapshot, result) = record_metrics(|| {
-            Box::pin(async {
-                let worker = worker(static_backend().await);
-                let result = worker.round().await;
-                record_round(result, Duration::from_millis(1));
-                result
-            })
-        });
-
-        assert_eq!(result, ProbeResult::Unsupported);
-        assert_eq!(counter_value(&snapshot, METRIC_PROBE_ROUNDS_TOTAL, &[("result", "unsupported")]), 1);
-        assert_eq!(
-            counter_value(&snapshot, METRIC_PROBE_FAILURES_TOTAL, &[]),
-            0,
-            "an unsupported backend must never raise probe failures"
-        );
-    }
-
-    #[tokio::test]
-    async fn each_round_trip_stage_gets_its_own_failure_classification() {
-        for (fault, expected) in [
-            (Fault::Generate, ProbeFailureKind::Generate),
-            (Fault::Decrypt, ProbeFailureKind::Decrypt),
-            (Fault::Mismatch, ProbeFailureKind::Mismatch),
-        ] {
-            assert_eq!(worker(BrokenBackend::arc(fault)).round().await, ProbeResult::Failure(expected));
-        }
-    }
-
-    #[test]
-    fn metrics_and_status_record_success_then_failure() {
-        let (snapshot, status) = record_metrics(|| {
-            Box::pin(async {
-                let temp_dir = tempfile::tempdir().expect("temp dir");
-                let state = Arc::new(ProbeState::new());
-                let healthy = ProbeWorker::new(local_backend(&temp_dir).await, state.clone(), DEFAULT_PROBE_INTERVAL);
-                let round = healthy.round().await;
-                record_round(round, Duration::from_millis(10));
-                state.publish(round);
-
-                let broken = ProbeWorker::new(BrokenBackend::arc(Fault::Mismatch), state.clone(), DEFAULT_PROBE_INTERVAL);
-                for _ in 0..2 {
-                    let round = broken.round().await;
-                    record_round(round, Duration::from_millis(10));
-                    state.publish(round);
-                }
-                state.status()
-            })
-        });
-
-        assert_eq!(status.result, ProbeResult::Failure(ProbeFailureKind::Mismatch));
-        assert_eq!(status.consecutive_failures, 2);
-        assert!(
-            status.last_success_at.is_some() && status.last_success_unix_secs.is_some(),
-            "a failing probe must keep reporting when it last succeeded"
-        );
-
-        assert_eq!(counter_value(&snapshot, METRIC_PROBE_ROUNDS_TOTAL, &[("result", "success")]), 1);
-        assert_eq!(counter_value(&snapshot, METRIC_PROBE_ROUNDS_TOTAL, &[("result", "failure")]), 2);
-        assert_eq!(counter_value(&snapshot, METRIC_PROBE_FAILURES_TOTAL, &[("failure_kind", "mismatch")]), 2);
-        assert_eq!(histogram_values(&snapshot, METRIC_PROBE_DURATION_SECONDS, &[]).len(), 3);
-        assert!(
-            gauge_value(&snapshot, METRIC_PROBE_LAST_SUCCESS_TIMESTAMP).is_some_and(|timestamp| timestamp > 0.0),
-            "the last success gauge must carry a wall-clock timestamp"
-        );
-        assert_eq!(gauge_value(&snapshot, METRIC_PROBE_CONSECUTIVE_FAILURES), Some(2.0));
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn worker_publishes_status_and_stops_on_cancel() {
-        let temp_dir = tempfile::tempdir().expect("temp dir");
-        let state = Arc::new(ProbeState::new());
-        assert_eq!(state.status().result, ProbeResult::Pending);
-
-        let cancel = CancellationToken::new();
-        let task = ProbeWorker::new(local_backend(&temp_dir).await, state.clone(), DEFAULT_PROBE_INTERVAL).spawn(cancel.clone());
-
-        // The paused clock auto-advances through the worker's interval ticks.
-        let mut observed = None;
-        for _ in 0..100 {
-            tokio::time::sleep(Duration::from_secs(1)).await;
-            if state.status().result != ProbeResult::Pending {
-                observed = Some(state.status());
-                break;
-            }
-        }
-        let observed = observed.expect("the worker loop must publish a round result");
-        assert_eq!(observed.result, ProbeResult::Success);
-        assert_eq!(observed.consecutive_failures, 0);
-        assert!(observed.last_success_at.is_some());
-
-        cancel.cancel();
-        task.await.expect("worker task must stop after cancellation");
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn unsupported_backend_stops_the_worker_without_cancellation() {
-        let state = Arc::new(ProbeState::new());
-        let cancel = CancellationToken::new();
-        let task = ProbeWorker::new(static_backend().await, state.clone(), DEFAULT_PROBE_INTERVAL).spawn(cancel.clone());
-
-        task.await.expect("worker must exit on its own for an unsupported backend");
-        assert_eq!(state.status().result, ProbeResult::Unsupported);
-        assert!(!cancel.is_cancelled());
-    }
-
-    #[test]
-    fn interval_configuration_defaults_clamps_and_disables() {
-        assert_eq!(parse_interval(None), Some(DEFAULT_PROBE_INTERVAL));
-        assert_eq!(parse_interval(Some("not-a-number")), Some(DEFAULT_PROBE_INTERVAL));
-        assert_eq!(parse_interval(Some(" 120 ")), Some(Duration::from_secs(120)));
-        assert_eq!(parse_interval(Some("1")), Some(MIN_PROBE_INTERVAL));
-        assert_eq!(parse_interval(Some("0")), None, "zero must disable the probe");
-    }
-
-    // -- Metric assertion helpers, mirroring the policy engine's tests --------
-
-    type MetricEntry = (
-        metrics_util::CompositeKey,
-        Option<metrics::Unit>,
-        Option<metrics::SharedString>,
-        DebugValue,
-    );
-
-    /// Run `test` on a paused current-thread runtime under a debugging recorder
-    /// and return one snapshot of everything it emitted.
-    fn record_metrics<Out>(test: impl FnOnce() -> std::pin::Pin<Box<dyn Future<Output = Out>>>) -> (Vec<MetricEntry>, Out) {
-        let recorder = DebuggingRecorder::new();
-        let snapshotter = recorder.snapshotter();
-        let out = metrics::with_local_recorder(&recorder, || {
-            let runtime = tokio::runtime::Builder::new_current_thread()
-                .enable_time()
-                .start_paused(true)
-                .build()
-                .expect("current-thread runtime must build");
-            runtime.block_on(test())
-        });
-        (snapshotter.snapshot().into_vec(), out)
-    }
-
-    fn labels_match(key: &metrics::Key, labels: &[(&str, &str)]) -> bool {
-        labels
-            .iter()
-            .all(|(label, expected)| key.labels().any(|l| l.key() == *label && l.value() == *expected))
-    }
-
-    fn counter_value(snapshot: &[MetricEntry], name: &str, labels: &[(&str, &str)]) -> u64 {
-        snapshot
-            .iter()
-            .filter_map(|(composite, _unit, _description, value)| {
-                let matches = composite.kind() == MetricKind::Counter
-                    && composite.key().name() == name
-                    && labels_match(composite.key(), labels);
-                match (matches, value) {
-                    (true, DebugValue::Counter(count)) => Some(*count),
-                    _ => None,
-                }
-            })
-            .sum()
-    }
-
-    fn histogram_values(snapshot: &[MetricEntry], name: &str, labels: &[(&str, &str)]) -> Vec<f64> {
-        snapshot
-            .iter()
-            .filter_map(|(composite, _unit, _description, value)| {
-                let matches = composite.kind() == MetricKind::Histogram
-                    && composite.key().name() == name
-                    && labels_match(composite.key(), labels);
-                match (matches, value) {
-                    (true, DebugValue::Histogram(values)) => Some(values),
-                    _ => None,
-                }
-            })
-            .flatten()
-            .map(|value| value.into_inner())
-            .collect()
-    }
-
-    fn gauge_value(snapshot: &[MetricEntry], name: &str) -> Option<f64> {
-        snapshot.iter().find_map(|(composite, _unit, _description, value)| {
-            let matches = composite.kind() == MetricKind::Gauge && composite.key().name() == name;
-            match (matches, value) {
-                (true, DebugValue::Gauge(gauge)) => Some(gauge.into_inner()),
-                _ => None,
-            }
-        })
-    }
-}
@@ -112,23 +112,6 @@ impl ObjectEncryptionService {
        self.kms_manager.create_key(request).await
    }

-    /// Create a new master key on behalf of `context`'s principal
-    ///
-    /// # Arguments
-    /// * `request` - CreateKeyRequest with key parameters
-    /// * `context` - Identity and correlation data recorded in the audit trail
-    ///
-    /// # Returns
-    /// CreateKeyResponse with created key details
-    ///
-    pub async fn create_key_with_context(
-        &self,
-        request: CreateKeyRequest,
-        context: &OperationContext,
-    ) -> Result<CreateKeyResponse> {
-        self.kms_manager.create_key_with_context(request, context).await
-    }
-
    /// Describe a master key (delegates to KMS manager)
    ///
    /// # Arguments
@@ -141,23 +124,6 @@ impl ObjectEncryptionService {
        self.kms_manager.describe_key(request).await
    }

-    /// Describe a master key on behalf of `context`'s principal
-    ///
-    /// # Arguments
-    /// * `request` - DescribeKeyRequest with key ID
-    /// * `context` - Identity and correlation data recorded in the audit trail
-    ///
-    /// # Returns
-    /// DescribeKeyResponse with key metadata
-    ///
-    pub async fn describe_key_with_context(
-        &self,
-        request: DescribeKeyRequest,
-        context: &OperationContext,
-    ) -> Result<DescribeKeyResponse> {
-        self.kms_manager.describe_key_with_context(request, context).await
-    }
-
    /// List master keys (delegates to KMS manager)
    ///
    /// # Arguments
@@ -170,19 +136,6 @@ impl ObjectEncryptionService {
        self.kms_manager.list_keys(request).await
    }

-    /// List master keys on behalf of `context`'s principal
-    ///
-    /// # Arguments
-    /// * `request` - ListKeysRequest with listing parameters
-    /// * `context` - Identity and correlation data recorded in the audit trail
-    ///
-    /// # Returns
-    /// ListKeysResponse with list of keys
-    ///
-    pub async fn list_keys_with_context(&self, request: ListKeysRequest, context: &OperationContext) -> Result<ListKeysResponse> {
-        self.kms_manager.list_keys_with_context(request, context).await
-    }
-
    /// Generate a data encryption key (delegates to KMS manager)
    ///
    /// # Arguments
@@ -14,14 +14,12 @@

 //! KMS service manager for dynamic configuration and runtime management

-use crate::audit::KmsAuditSink;
 use crate::backends::vault_credentials::CredentialTaskHandle;
 use crate::backends::{KmsBackend, local::LocalKmsBackend};
 use crate::config::{BackendConfig, KmsConfig};
 use crate::deletion_worker::{DeletionReferenceChecker, DeletionWorker};
 use crate::error::{KmsError, Result};
 use crate::manager::KmsManager;
-use crate::probe::{ProbeHandle, ProbeStatus, spawn_probe_worker};
 use crate::service::ObjectEncryptionService;
 use arc_swap::ArcSwap;
 use sha2::{Digest, Sha256};
@@ -122,23 +120,13 @@ struct ServiceVersion {
    /// Background deletion worker owned by this service version, if the
    /// backend supports deletion scheduling
    deletion_worker: Option<Arc<DeletionWorkerHandle>>,
-    /// Background synthetic probe owned by this service version, if the
-    /// backend can round-trip a data key and the probe is enabled
-    probe_worker: Option<Arc<ProbeHandle>>,
 }

 impl ServiceVersion {
-    /// Stop the background workers this version owns.
-    ///
-    /// The credential renewal task is recycled separately because its shutdown
-    /// is asynchronous.
-    fn shutdown_background_workers(&self) {
+    fn shutdown_deletion_worker(&self) {
        if let Some(worker) = &self.deletion_worker {
            worker.shutdown();
        }
-        if let Some(probe) = &self.probe_worker {
-            probe.shutdown();
-        }
    }
 }

@@ -183,8 +171,6 @@ pub struct KmsServiceManager {
    lifecycle_mutex: Arc<Mutex<()>>,
    /// External reference checker consulted before expired keys are removed
    deletion_reference_checker: std::sync::RwLock<Option<Arc<dyn DeletionReferenceChecker>>>,
-    /// External sink receiving audit records for management operations
-    audit_sink: std::sync::RwLock<Option<Arc<dyn KmsAuditSink>>>,
 }

 impl KmsServiceManager {
@@ -199,26 +185,9 @@ impl KmsServiceManager {
            version_counter: Arc::new(AtomicU64::new(0)),
            lifecycle_mutex: Arc::new(Mutex::new(())),
            deletion_reference_checker: std::sync::RwLock::new(None),
-            audit_sink: std::sync::RwLock::new(None),
        }
    }

-    /// Install the sink that receives an audit record for every KMS
-    /// management operation. Takes effect for services built by the next
-    /// start or reconfigure.
-    ///
-    /// Without a sink no records are built, so KMS operations are unaffected
-    /// when auditing is not configured.
-    pub fn set_audit_sink(&self, sink: Arc<dyn KmsAuditSink>) {
-        if let Ok(mut slot) = self.audit_sink.write() {
-            *slot = Some(sink);
-        }
-    }
-
-    fn audit_sink(&self) -> Option<Arc<dyn KmsAuditSink>> {
-        self.audit_sink.read().ok().and_then(|slot| slot.clone())
-    }
-
    /// Install the reference checker consulted before the deletion worker
    /// removes an expired key. Takes effect for workers spawned by the next
    /// start or reconfigure.
@@ -410,7 +379,7 @@ impl KmsServiceManager {
        // Note: Existing Arc references will keep the service alive until operations complete
        let state = self.state.load_full();
        if let Some(current) = state.current_service.as_ref() {
-            current.shutdown_background_workers();
+            current.shutdown_deletion_worker();
        }
        self.state.store(Arc::new(RuntimeState {
            config: state.config.clone(),
@@ -545,19 +514,6 @@ impl KmsServiceManager {
        self.state.load().current_service.as_ref().map(|sv| sv.version)
    }

-    /// Latest synthetic probe snapshot of the running service version.
-    ///
-    /// `None` when KMS is not running, when the backend cannot round-trip a
-    /// data key, or when the probe is disabled. The read is lock-free and
-    /// performs no backend I/O, so a health endpoint can consult it without
-    /// turning an external KMS hiccup into probe pressure of its own; the
-    /// staleness and consecutive-failure thresholds belong to the caller.
-    pub fn probe_status(&self) -> Option<Arc<ProbeStatus>> {
-        let state = self.state.load();
-        let service_version = state.current_service.as_ref()?;
-        Some(service_version.probe_worker.as_ref()?.status())
-    }
-
    /// Health check for the KMS service
    pub async fn health_check(&self) -> Result<bool> {
        let checked_state = self.state.load_full();
@@ -629,11 +585,7 @@ impl KmsServiceManager {
        };

        // Create KMS manager
-        let mut kms_manager = KmsManager::new(backend, config.clone());
-        if let Some(sink) = self.audit_sink() {
-            kms_manager = kms_manager.with_audit_sink(sink);
-        }
-        let kms_manager = Arc::new(kms_manager);
+        let kms_manager = Arc::new(KmsManager::new(backend, config.clone()));

        // Create encryption service
        let encryption_service = Arc::new(ObjectEncryptionService::new((*kms_manager).clone()));
@@ -644,7 +596,6 @@ impl KmsServiceManager {
            manager: kms_manager,
            credential_task,
            deletion_worker: None,
-            probe_worker: None,
        })
    }

@@ -658,13 +609,9 @@ impl KmsServiceManager {

    fn publish_running(&self, config: KmsConfig, mut service_version: ServiceVersion) {
        if let Some(previous) = self.state.load().current_service.as_ref() {
-            previous.shutdown_background_workers();
+            previous.shutdown_deletion_worker();
        }
        service_version.deletion_worker = self.spawn_deletion_worker(&config, &service_version);
-        // Started at publish time for the same reason as the deletion worker:
-        // a start or reconfigure candidate that never becomes current must not
-        // leak a running task or publish probe results nobody asked for.
-        service_version.probe_worker = spawn_probe_worker(service_version.manager.backend()).map(Arc::new);
        self.state.store(Arc::new(RuntimeState {
            config: Some(config),
            status: KmsServiceStatus::Running,
@@ -682,13 +629,7 @@ impl KmsServiceManager {
            return None;
        }
        let cancel = CancellationToken::new();
-        let worker = DeletionWorker::new(
-            backend,
-            config.default_key_id.clone(),
-            self.deletion_reference_checker(),
-            config.backend.as_str(),
-        )
-        .with_audit_sink(self.audit_sink());
+        let worker = DeletionWorker::new(backend, config.default_key_id.clone(), self.deletion_reference_checker());
        let task = worker.spawn(cancel.clone());
        Some(Arc::new(DeletionWorkerHandle {
            cancel,
@@ -1039,49 +980,6 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn probe_worker_follows_the_service_lifecycle() {
-        use tempfile::TempDir;
-
-        let key_dir = TempDir::new().expect("create local KMS directory");
-        let mut config = KmsConfig::local(key_dir.path().to_path_buf());
-        config.allow_insecure_dev_defaults = true;
-        let manager = KmsServiceManager::new();
-        manager.configure(config).await.expect("configure local KMS");
-        manager.start().await.expect("start local KMS");
-
-        let first_probe = manager
-            .state
-            .load()
-            .current_service
-            .as_ref()
-            .expect("running service")
-            .probe_worker
-            .clone()
-            .expect("a backend with a data key round trip must run a probe");
-        assert!(!first_probe.is_cancelled());
-        assert!(manager.probe_status().is_some(), "a running service must publish probe status");
-
-        // Replacing the service version replaces (and cancels) its probe.
-        manager.restart().await.expect("restart");
-        assert!(first_probe.is_cancelled(), "replaced version's probe must be cancelled");
-        let second_probe = manager
-            .state
-            .load()
-            .current_service
-            .as_ref()
-            .expect("running service")
-            .probe_worker
-            .clone()
-            .expect("restarted service must run a fresh probe");
-        assert!(!second_probe.is_cancelled());
-
-        // Stopping the service stops its probe and withdraws the snapshot.
-        manager.stop().await.expect("stop");
-        assert!(second_probe.is_cancelled(), "stop must cancel the probe worker");
-        assert!(manager.probe_status().is_none(), "a stopped service must publish no status");
-    }
-
    #[tokio::test]
    async fn reconfigure_allows_safe_local_runtime_settings_only() {
        use tempfile::TempDir;
@@ -484,20 +484,6 @@ impl OperationContext {
        }
    }

-    /// Principal recorded for work the server starts on its own behalf.
-    ///
-    /// Namespaced so it can never collide with an access key or an IAM ARN,
-    /// which keeps "no human did this" distinguishable from "we lost track of
-    /// who did this" in the audit trail.
-    pub const INTERNAL_PRINCIPAL: &'static str = "rustfs:internal";
-
-    /// Context for an operation with no authenticated caller, such as
-    /// background maintenance or a call made while serving a data-plane
-    /// request that carries its own audit entry.
-    pub fn internal() -> Self {
-        Self::new(Self::INTERNAL_PRINCIPAL.to_string())
-    }
-
    /// Add additional context
    ///
    /// # Arguments
@@ -14,8 +14,8 @@

 //! Fault-injection matrix for the Vault backend operation policy.
 //!
-//! Offline cases run against locally injected transport faults (a listener
-//! that never responds) — deterministic, no external
+//! Offline cases run against locally injected transport faults (a closed
+//! port, a listener that never responds) — deterministic, no external
 //! dependencies. Real-Vault cases are `#[ignore]`d and need a dev Vault
 //! (default `http://127.0.0.1:8200`, override with `RUSTFS_KMS_VAULT_ADDR`).
 //!
@@ -118,6 +118,44 @@ fn counter_value(snapshot: &[MetricEntry], name: &str, labels: &[(&str, &str)])
        .sum()
 }

+/// Connection refused: connection-class failures are retried up to the
+/// configured budget, then surface as a backend error.
+#[test]
+fn connection_refused_is_retried_within_budget() {
+    // Reserve a loopback port and release it so nothing is listening there.
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("reserve a loopback port");
+    let address = format!("http://{}", listener.local_addr().expect("reserved port addr"));
+    drop(listener);
+
+    let snapshot = record_metrics(|| {
+        Box::pin(async move {
+            let client = VaultKmsBackend::new(kms_config(vault_config(&address, "unused"), Duration::from_secs(2), 2))
+                .await
+                .expect("client construction performs no network calls");
+            let error = KmsBackendTrait::describe_key(&client, describe_key_request("fault-injection-refused"))
+                .await
+                .expect_err("a refused connection must fail the operation");
+            assert!(matches!(error, KmsError::BackendError { .. }), "got {error:?}");
+        })
+    });
+
+    assert_eq!(
+        counter_value(&snapshot, ATTEMPT_FAILURES_TOTAL, &[("error_class", "retryable_conn")]),
+        2,
+        "both budgeted attempts must observe the refused connection"
+    );
+    assert_eq!(counter_value(&snapshot, OPERATIONS_TOTAL, &[("outcome", "budget_exhausted")]), 1);
+    // The static-token login records its own success; the Vault read must not.
+    assert_eq!(
+        counter_value(
+            &snapshot,
+            OPERATIONS_TOTAL,
+            &[("operation", "vault_kv2_read_key"), ("outcome", "success")]
+        ),
+        0
+    );
+}
+
 /// Stalled connection: a server that accepts but never responds is cut off by
 /// the per-attempt timeout (either the policy timer or the equally sized HTTP
 /// client timeout, whichever fires first) instead of hanging forever.
@@ -22,8 +22,6 @@ mod pattern_rules_test;
 #[cfg(test)]
 mod pattern_test;
 mod rules_map;
-#[cfg(test)]
-mod rules_map_test;
 mod subscriber_index;
 mod subscriber_snapshot;
 mod target_id_set;
@@ -1,104 +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.
-
-//! Regressions for rule matching against the KMS event namespace.
-//!
-//! KMS events (backlog#1583) are appended to `EventName` for the audit sink,
-//! but they must stay invisible to bucket notification rules: a subscriber
-//! asking for `s3:ObjectCreated:*` — or for everything — must never receive
-//! key management activity.
-
-use super::RulesMap;
-use rustfs_s3_types::EventName;
-use rustfs_targets::arn::TargetID;
-
-const KMS_EVENTS: &[EventName] = &[
-    EventName::KmsKeyCreated,
-    EventName::KmsKeyRotated,
-    EventName::KmsKeyEnabled,
-    EventName::KmsKeyDisabled,
-    EventName::KmsKeyDeletionScheduled,
-    EventName::KmsKeyDeletionCancelled,
-    EventName::KmsKeyDeleted,
-    EventName::KmsKeyAccessed,
-];
-
-fn test_target() -> TargetID {
-    TargetID::new("primary".to_string(), "webhook".to_string())
-}
-
-fn rules_for(events: &[EventName]) -> RulesMap {
-    let mut rules = RulesMap::new();
-    rules.add_rule_config(events, String::new(), test_target());
-    rules
-}
-
-#[test]
-fn s3_wildcard_subscriptions_do_not_match_kms_events() {
-    let rules = rules_for(&[
-        EventName::ObjectCreatedAll,
-        EventName::ObjectAccessedAll,
-        EventName::ObjectRemovedAll,
-        EventName::ObjectTaggingAll,
-        EventName::ObjectReplicationAll,
-        EventName::ObjectRestoreAll,
-        EventName::ObjectTransitionAll,
-        EventName::LifecycleExpirationAll,
-        EventName::ObjectScannerAll,
-    ]);
-
-    for event in KMS_EVENTS {
-        assert!(!rules.has_subscriber(event), "{event} must not have an S3 wildcard subscriber");
-        assert!(
-            rules.match_rules(*event, "any/object").is_empty(),
-            "{event} must not match any S3 wildcard rule"
-        );
-    }
-}
-
-#[test]
-fn everything_subscription_does_not_match_kms_events() {
-    let rules = rules_for(&[EventName::Everything]);
-
-    // Sanity: the catch-all really is subscribed to the S3 surface.
-    assert!(rules.has_subscriber(&EventName::ObjectCreatedPut));
-
-    for event in KMS_EVENTS {
-        assert!(!rules.has_subscriber(event), "{event} must stay outside the s3 catch-all");
-        assert!(
-            rules.match_rules(*event, "any/object").is_empty(),
-            "{event} must not match the s3 catch-all rule"
-        );
-    }
-}
-
-#[test]
-fn kms_subscription_does_not_leak_into_s3_matching() {
-    // The inverse direction: even an explicit KMS subscription must not widen
-    // the mask so that S3 events start matching a KMS-only rule.
-    let rules = rules_for(KMS_EVENTS);
-
-    for event in [
-        EventName::ObjectCreatedPut,
-        EventName::ObjectRemovedDelete,
-        EventName::ObjectAccessedGet,
-        EventName::BucketCreated,
-    ] {
-        assert!(!rules.has_subscriber(&event), "{event} must not match a KMS-only rule");
-        assert!(
-            rules.match_rules(event, "any/object").is_empty(),
-            "{event} must not match a KMS-only rule"
-        );
-    }
-}
@@ -30,10 +30,6 @@ impl Args {
    }
 }

-pub fn is_configured() -> bool {
-    env::var_os(ENV_POLICY_PLUGIN_OPA_URL).is_some_and(|url| !url.is_empty())
-}
-
 #[derive(Debug, Clone)]
 pub struct AuthZPlugin {
    client: OpaHttpClient,
@@ -92,12 +88,7 @@ async fn validate(config: &Args) -> Result<(), OpaConfigError> {
        .build()
        .map_err(OpaConfigError::Connection)?;

-    let mut request = client.post(&config.url);
-    if !config.auth_token.is_empty() {
-        request = request.header("Authorization", format!("Bearer {}", config.auth_token));
-    }
-
-    match request.send().await {
+    match client.post(&config.url).send().await {
        Ok(resp) => {
            match resp.status() {
                reqwest::StatusCode::OK => {
@@ -86,20 +86,6 @@ pub enum EventName {
    ObjectRemovedAbortMultipartUpload,
    ObjectCreatedCreateMultipartUpload,
    ObjectRemovedDeleteObjects,
-
-    // KMS management-plane events. They travel to the audit sink only and are
-    // never produced by the bucket notification path, so no compound `s3:`
-    // event expands to them. New variants must keep being appended here: the
-    // discriminant of every preceding variant is a `mask()` bit position, and
-    // inserting in the middle would silently renumber existing bits.
-    KmsKeyCreated,
-    KmsKeyRotated,
-    KmsKeyEnabled,
-    KmsKeyDisabled,
-    KmsKeyDeletionScheduled,
-    KmsKeyDeletionCancelled,
-    KmsKeyDeleted,
-    KmsKeyAccessed,
 }

 // Single event type sequential array for Everything.expand()
@@ -200,17 +186,6 @@ impl EventName {
            "s3:Scanner:LargeVersions" => Ok(EventName::ScannerLargeVersions),
            "s3:Scanner:BigPrefix" => Ok(EventName::ScannerBigPrefix),
            "s3:Scanner:*" => Ok(EventName::ObjectScannerAll),
-            // KMS events use their own namespace so a `s3:` wildcard in a bucket
-            // notification config can never select them. They still round-trip
-            // because audit entries are persisted and replayed by the store targets.
-            "kms:Key:Created" => Ok(EventName::KmsKeyCreated),
-            "kms:Key:Rotated" => Ok(EventName::KmsKeyRotated),
-            "kms:Key:Enabled" => Ok(EventName::KmsKeyEnabled),
-            "kms:Key:Disabled" => Ok(EventName::KmsKeyDisabled),
-            "kms:Key:DeletionScheduled" => Ok(EventName::KmsKeyDeletionScheduled),
-            "kms:Key:DeletionCancelled" => Ok(EventName::KmsKeyDeletionCancelled),
-            "kms:Key:Deleted" => Ok(EventName::KmsKeyDeleted),
-            "kms:Key:Accessed" => Ok(EventName::KmsKeyAccessed),
            // `Everything` has no string representation (`as_str` yields ""), so it
            // cannot be parsed back from a string. Every other variant round-trips.
            _ => Err(ParseEventNameError(s.to_string())),
@@ -276,14 +251,6 @@ impl EventName {
            EventName::ObjectRemovedAbortMultipartUpload => "s3:ObjectRemoved:AbortMultipartUpload",
            EventName::ObjectCreatedCreateMultipartUpload => "s3:ObjectCreated:CreateMultipartUpload",
            EventName::ObjectRemovedDeleteObjects => "s3:ObjectRemoved:DeleteObjects",
-            EventName::KmsKeyCreated => "kms:Key:Created",
-            EventName::KmsKeyRotated => "kms:Key:Rotated",
-            EventName::KmsKeyEnabled => "kms:Key:Enabled",
-            EventName::KmsKeyDisabled => "kms:Key:Disabled",
-            EventName::KmsKeyDeletionScheduled => "kms:Key:DeletionScheduled",
-            EventName::KmsKeyDeletionCancelled => "kms:Key:DeletionCancelled",
-            EventName::KmsKeyDeleted => "kms:Key:Deleted",
-            EventName::KmsKeyAccessed => "kms:Key:Accessed",
        }
    }

@@ -390,25 +357,6 @@ impl EventName {
                | EventName::ObjectRemovedDeleteObjects
        )
    }
-
-    /// Returns `true` for KMS management-plane events.
-    ///
-    /// These are audit-only: they are never emitted through the bucket
-    /// notification pipeline, and no `s3:` event selector expands to them.
-    #[inline]
-    pub fn is_kms(&self) -> bool {
-        matches!(
-            self,
-            EventName::KmsKeyCreated
-                | EventName::KmsKeyRotated
-                | EventName::KmsKeyEnabled
-                | EventName::KmsKeyDisabled
-                | EventName::KmsKeyDeletionScheduled
-                | EventName::KmsKeyDeletionCancelled
-                | EventName::KmsKeyDeleted
-                | EventName::KmsKeyAccessed
-        )
-    }
 }

 /// Returns the S3 notification event schema version for a given event.
@@ -622,26 +570,6 @@ mod tests {
        EventName::ObjectRemovedAbortMultipartUpload,
        EventName::ObjectCreatedCreateMultipartUpload,
        EventName::ObjectRemovedDeleteObjects,
-        EventName::KmsKeyCreated,
-        EventName::KmsKeyRotated,
-        EventName::KmsKeyEnabled,
-        EventName::KmsKeyDisabled,
-        EventName::KmsKeyDeletionScheduled,
-        EventName::KmsKeyDeletionCancelled,
-        EventName::KmsKeyDeleted,
-        EventName::KmsKeyAccessed,
-    ];
-
-    /// Every KMS management-plane event.
-    const KMS_EVENT_NAMES: &[EventName] = &[
-        EventName::KmsKeyCreated,
-        EventName::KmsKeyRotated,
-        EventName::KmsKeyEnabled,
-        EventName::KmsKeyDisabled,
-        EventName::KmsKeyDeletionScheduled,
-        EventName::KmsKeyDeletionCancelled,
-        EventName::KmsKeyDeleted,
-        EventName::KmsKeyAccessed,
    ];

    /// Regression for backlog#965: `mask()` used to recurse forever for the
@@ -754,54 +682,6 @@ mod tests {
        }
    }

-    /// KMS events are audit-plane only. No `s3:` selector — including the
-    /// catch-all `Everything` and every compound "All" type — may share a bit
-    /// with them, otherwise a bucket notification rule would silently start
-    /// matching KMS activity.
-    #[test]
-    fn test_kms_event_masks_are_disjoint_from_every_s3_selector() {
-        let s3_selectors: Vec<EventName> = ALL_EVENT_NAMES.iter().copied().filter(|ev| !ev.is_kms()).collect();
-
-        let mut seen = 0u64;
-        for kms in KMS_EVENT_NAMES {
-            let mask = kms.mask();
-            assert_ne!(mask, 0, "KMS event {kms} must have a non-zero mask");
-            assert_eq!(seen & mask, 0, "KMS event {kms} mask overlaps another KMS event");
-            seen |= mask;
-
-            for s3 in &s3_selectors {
-                assert_eq!(s3.mask() & mask, 0, "KMS event {kms} mask collides with S3 selector {s3}");
-            }
-        }
-    }
-
-    /// KMS event names must live in their own namespace so that neither a
-    /// `s3:` prefix filter nor an `s3:...:*` wildcard can select them.
-    #[test]
-    fn test_kms_event_names_are_outside_the_s3_namespace() {
-        for ev in KMS_EVENT_NAMES {
-            assert!(ev.is_kms(), "{ev} should be classified as a KMS event");
-            assert!(ev.as_str().starts_with("kms:"), "unexpected KMS event name {:?}", ev.as_str());
-            assert_eq!(EventName::parse(ev.as_str()).as_ref(), Ok(ev), "KMS event {ev} must round-trip");
-            assert_eq!(ev.expand(), vec![*ev], "KMS event {ev} must expand to itself only");
-        }
-
-        for ev in ALL_EVENT_NAMES.iter().filter(|ev| !ev.is_kms()) {
-            assert!(!ev.as_str().starts_with("kms:"), "{ev} must not claim the KMS namespace");
-        }
-    }
-
-    /// `mask()` shifts by `discriminant - 1`, so the enum may hold at most 64
-    /// mask-bearing variants. Appending past that overflows the shift instead
-    /// of failing loudly, so keep the budget check next to the variants.
-    #[test]
-    fn test_mask_bit_budget_is_not_exhausted() {
-        for ev in ALL_EVENT_NAMES {
-            let value = *ev as u32;
-            assert!(value <= 64, "{ev} has discriminant {value}; mask() only has 64 bits to hand out");
-        }
-    }
-
    /// `Everything` must cover every sequential single-type bit.
    #[test]
    fn test_everything_mask_covers_all_single_types() {
@@ -88,7 +88,6 @@ rmp-serde = { workspace = true }
 hmac = { workspace = true }
 sha2 = { workspace = true }
 rustfs-filemeta = { workspace = true }
-rustfs-lock.workspace = true
 tokio-util = { workspace = true, features = ["io", "compat", "rt"] }
 rustfs-ecstore = { workspace = true }
 rustfs-storage-api = { workspace = true }
@@ -12,18 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#[cfg(test)]
-use crate::RUSTFS_META_BUCKET;
 use crate::scanner_budget::{ScannerCycleBudget, ScannerCycleBudgetConfig};
 use crate::scanner_io::{
-    DataUsageCacheScanState, ScannerDiskScanOutcome, ScannerIODisk, acquire_scanner_cache_locks, cache_root_entry_info,
-    current_cache_root_or_prepare, scanner_set_disk_inventory,
+    DataUsageCacheScanState, ScannerDiskScanOutcome, ScannerIODisk, cache_root_entry_info, current_cache_root_or_prepare,
+    scanner_cache_lock_resource, scanner_cache_lock_timeout, scanner_set_disk_inventory,
 };
 use crate::storage_api::owner::NS_SCANNER_PROTOCOL_VERSION;
+use crate::storage_api::scan::NamespaceLocking as _;
 use crate::{
    DATA_USAGE_BLOOM_NAME_PATH, DATA_USAGE_CACHE_NAME, DataUsageCache, DataUsageCachePrepareOutcome, DataUsageCacheSource,
-    DataUsageEntryInfo, DataUsageScanPlanDigest, Disk, EcstoreError, ScannerDiskExt as _, ScannerError, ScannerObjectIO,
-    StorageError, is_reserved_or_invalid_bucket, read_config, resolve_scanner_object_store_handle,
+    DataUsageEntryInfo, DataUsageScanPlanDigest, Disk, EcstoreError, RUSTFS_META_BUCKET, ScannerDiskExt as _, ScannerError,
+    ScannerObjectIO, StorageError, is_reserved_or_invalid_bucket, read_config, resolve_scanner_object_store_handle,
 };
 use hmac::{Hmac, KeyInit, Mac};
 use rustfs_common::heal_channel::HealScanMode;
@@ -64,7 +63,6 @@ const NS_SCANNER_DISK_HEALTH_TIMEOUT: Duration = Duration::from_secs(5);
 const NS_SCANNER_VALIDATED_CYCLE_TTL: Duration = Duration::from_secs(1);
 const NS_SCANNER_MAX_REPLAY_SESSIONS: usize = 65_536;
 const NS_SCANNER_MAX_ERROR_CHARS: usize = 4096;
-const NS_SCANNER_RETRY_BUCKET_ERROR_PREFIX: &str = "retry_bucket:";
 const NS_SCANNER_FRAME_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-frame-v3";

 pub const NS_SCANNER_MAX_REQUEST_BODY_SIZE: usize = 16 * 1024;
@@ -319,13 +317,6 @@ impl RemoteScannerServerError {
        }
    }

-    fn retry_bucket(message: impl Into<String>) -> Self {
-        Self {
-            scope: RemoteScannerErrorScope::Bucket,
-            error: ScannerError::Other(format!("{}{}", NS_SCANNER_RETRY_BUCKET_ERROR_PREFIX, message.into())),
-        }
-    }
-
    fn into_frame(self) -> RemoteScannerErrorFrame {
        RemoteScannerErrorFrame {
            scope: self.scope,
@@ -345,7 +336,6 @@ struct RemoteScannerStreamError {
    error: StorageError,
    progress_fully_reported: bool,
    retire_worker: bool,
-    retry_bucket: bool,
 }

 impl RemoteScannerStreamError {
@@ -354,7 +344,6 @@ impl RemoteScannerStreamError {
            error,
            progress_fully_reported: false,
            retire_worker: true,
-            retry_bucket: false,
        }
    }

@@ -363,7 +352,6 @@ impl RemoteScannerStreamError {
            error,
            progress_fully_reported: true,
            retire_worker: true,
-            retry_bucket: false,
        }
    }

@@ -372,16 +360,6 @@ impl RemoteScannerStreamError {
            error,
            progress_fully_reported: true,
            retire_worker: false,
-            retry_bucket: false,
-        }
-    }
-
-    fn retry_bucket(error: StorageError) -> Self {
-        Self {
-            error,
-            progress_fully_reported: true,
-            retire_worker: false,
-            retry_bucket: true,
        }
    }

@@ -973,14 +951,16 @@ async fn scan_and_persist_local_bucket(
            ))
        })?;
    let cache_name = path_join_buf(&[&bucket, DATA_USAGE_CACHE_NAME]);
-    let guard = acquire_scanner_cache_locks(set.as_ref(), &cache_name, source)
+    let lock_resource = scanner_cache_lock_resource(&cache_name);
+    let ns_lock = set
+        .new_ns_lock(RUSTFS_META_BUCKET, &lock_resource)
+        .await
+        .map_err(|err| RemoteScannerServerError::worker(format!("remote namespace scanner cache lock creation failed: {err}")))?;
+    let guard = ns_lock
+        .get_write_lock_quiet(scanner_cache_lock_timeout())
        .await
        .map_err(|err| {
-            if err.is_contention() {
-                RemoteScannerServerError::retry_bucket(format!("remote namespace scanner cache lock contention: {err}"))
-            } else {
-                RemoteScannerServerError::worker(format!("remote namespace scanner cache lock acquisition failed: {err}"))
-            }
+            RemoteScannerServerError::worker(format!("remote namespace scanner cache lock acquisition failed: {err}"))
        })?;
    let mut cache = DataUsageCache::default();
    let revisions = cache.load_with_revisions(set.clone(), &cache_name).await.map_err(|err| {
@@ -1236,9 +1216,7 @@ fn finish_remote_scanner_stream(
            if !error.progress_fully_reported {
                budget.cancel_after_unreported_remote_progress();
            }
-            let failure = if error.retry_bucket {
-                RemoteScannerFailure::retry_bucket(error.error)
-            } else if error.retire_worker {
+            let failure = if error.retire_worker {
                RemoteScannerFailure::transport(error.error)
            } else {
                RemoteScannerFailure::bucket(error.error)
@@ -1396,16 +1374,9 @@ where
                return Ok(RemoteScannerOutcome::CycleAhead(required_cycle));
            }
            RemoteScannerFrameResult::Error(error_frame) => {
-                let retry_bucket = error_frame.message.starts_with(NS_SCANNER_RETRY_BUCKET_ERROR_PREFIX);
-                let message = error_frame
-                    .message
-                    .strip_prefix(NS_SCANNER_RETRY_BUCKET_ERROR_PREFIX)
-                    .map(str::trim_start)
-                    .unwrap_or(error_frame.message.as_str());
                let error =
-                    StorageError::other(format!("remote namespace scanner failed: {}", limit_error_message(message.to_string())));
+                    StorageError::other(format!("remote namespace scanner failed: {}", limit_error_message(error_frame.message)));
                return Err(match error_frame.scope {
-                    RemoteScannerErrorScope::Bucket if retry_bucket => RemoteScannerStreamError::retry_bucket(error),
                    RemoteScannerErrorScope::Bucket => RemoteScannerStreamError::bucket(error),
                    RemoteScannerErrorScope::Worker => RemoteScannerStreamError::reconciled(error),
                });
@@ -2520,42 +2491,6 @@ mod tests {
        assert!(!budget.budget_elapsed());
    }

-    #[tokio::test]
-    async fn retry_bucket_error_terminal_frame_requeues_bucket_work() {
-        let request_id = Uuid::new_v4();
-        let writer_auth = FrameAuthenticator::for_test(request_id);
-        let reader_auth = FrameAuthenticator::for_test(request_id);
-        let (mut writer, reader) = tokio::io::duplex(4096);
-        tokio::spawn(async move {
-            let mut sequence = 0;
-            write_frame(
-                &mut writer,
-                &writer_auth,
-                &mut sequence,
-                &RemoteScannerFrame::terminal(
-                    RemoteScannerProgress::default(),
-                    RemoteScannerFrameResult::Error(RemoteScannerErrorFrame {
-                        scope: RemoteScannerErrorScope::Bucket,
-                        message: format!("{NS_SCANNER_RETRY_BUCKET_ERROR_PREFIX} cache lock contention"),
-                    }),
-                ),
-            )
-            .await
-            .expect("retry-bucket error terminal frame should write");
-        });
-
-        let parent = CancellationToken::new();
-        let budget = ScannerCycleBudget::new(&parent, ScannerCycleBudgetConfig::default());
-        let stream_result =
-            consume_remote_scanner_stream(reader, parent, budget.clone(), "bucket", TEST_SOURCE, TEST_PLAN_DIGEST, reader_auth)
-                .await;
-        let error = finish_remote_scanner_stream(stream_result, budget.as_ref()).expect_err("retry-bucket frame must fail");
-
-        assert!(error.retry_bucket_work());
-        assert!(!error.retire_worker());
-        assert!(error.to_string().contains("cache lock contention"));
-    }
-
    #[tokio::test]
    async fn worker_error_terminal_frame_retires_worker_without_cancelling_reported_budget() {
        let request_id = Uuid::new_v4();
@@ -949,7 +949,7 @@ pub(crate) async fn probe_scanner_activity(storeapi: &ECStore, distributed: bool
                }
                SCANNER_ACTIVITY_PREVIOUS_PROTOCOL_VERSION => {
                    return Err(format!(
-                        "scanner activity peer {host} cannot safely share scanner cache locks with protocol {}",
+                        "scanner activity peer {host} cannot acknowledge distributed dirty usage with protocol {}",
                        SCANNER_ACTIVITY_PREVIOUS_PROTOCOL_VERSION
                    ));
                }
@@ -7114,17 +7114,9 @@ mod tests {
                ..scanner_node_activity("epoch-a", 7, 3)
            },
        )]);
-        let previous = BTreeMap::from([(
-            "node-2".to_string(),
-            ScannerNodeActivity {
-                protocol_version: SCANNER_ACTIVITY_PREVIOUS_PROTOCOL_VERSION,
-                ..scanner_node_activity("epoch-a", 7, 3)
-            },
-        )]);
        let current = BTreeMap::from([("node-2".to_string(), scanner_node_activity("epoch-a", 7, 3))]);

        assert_ne!(scanner_activity_snapshot_digest(&legacy), scanner_activity_snapshot_digest(&current));
-        assert_ne!(scanner_activity_snapshot_digest(&previous), scanner_activity_snapshot_digest(&current));
    }

    #[test]
@@ -75,7 +75,7 @@ const DATA_SCANNER_COMPACT_LEAST_OBJECT: usize = 500;
 const DATA_SCANNER_COMPACT_AT_CHILDREN: usize = 10000;
 const DATA_SCANNER_COMPACT_AT_FOLDERS: usize = DATA_SCANNER_COMPACT_AT_CHILDREN / 4;
 const DATA_SCANNER_FORCE_COMPACT_AT_FOLDERS: usize = 250_000;
-const SCANNER_LIST_PATH_RAW_STALL_TIMEOUT: Duration = Duration::from_secs(60);
+const SCANNER_LIST_PATH_RAW_TIMEOUT: Duration = Duration::from_secs(60);
 const SCANNER_ENTRY_PROGRESS_BATCH: u64 = 32;
 const SCANNER_ENTRY_PROGRESS_INTERVAL: Duration = Duration::from_secs(30);
 const DEFAULT_HEAL_OBJECT_SELECT_PROB: u32 = 1024;
@@ -100,21 +100,6 @@ static SCANNER_INLINE_HEAL_WARN_ONCE: Once = Once::new();
 static SCANNER_INLINE_HEAL_METRICS_ONCE: Once = Once::new();
 static SCANNER_ALERT_METRICS_ONCE: Once = Once::new();

-#[cfg(test)]
-type ListPathRawTimeoutSnapshot = (bool, Option<Duration>, Option<Duration>);
-
-fn scanner_abandoned_child_list_options() -> ListPathRawOptions {
-    // A complete heal walk scales with bucket size and may legitimately take
-    // longer than a fixed wall-clock budget. Keep the total duration unbounded;
-    // Retain the scanner's per-read stall budget and keep cancellation controlled
-    // by the scanner cycle token.
-    ListPathRawOptions {
-        skip_walkdir_total_timeout: true,
-        walkdir_stall_timeout: Some(SCANNER_LIST_PATH_RAW_STALL_TIMEOUT),
-        ..Default::default()
-    }
-}
-
 pub fn data_usage_update_dir_cycles() -> u32 {
    rustfs_utils::get_env_u32(ENV_DATA_USAGE_UPDATE_DIR_CYCLES, DATA_USAGE_UPDATE_DIR_CYCLES)
 }
@@ -1296,8 +1281,6 @@ pub struct FolderScanner {
    skip_heal: Arc<std::sync::atomic::AtomicBool>,
    local_disk: Arc<Disk>,
    pending_heals_changed: bool,
-    #[cfg(test)]
-    list_path_raw_options_observer: Option<mpsc::UnboundedSender<ListPathRawTimeoutSnapshot>>,
 }

 impl FolderScanner {
@@ -2427,79 +2410,75 @@ impl FolderScanner {
                let bucket_clone = bucket.clone();
                let prefix_clone = prefix.clone();
                let child_ctx_clone = child_ctx.clone();
-                #[cfg(test)]
-                let list_path_raw_options_observer = self.list_path_raw_options_observer.clone();

                tokio::spawn(async move {
-                    let options = ListPathRawOptions {
-                        disks,
-                        bucket: bucket_clone.clone(),
-                        path: prefix_clone.clone(),
-                        recursive: true,
-                        report_not_found: true,
-                        min_disks: disks_quorum,
-                        agreed: Some(Box::new(move |entry: MetaCacheEntry| {
-                            let entry_name = entry.name.clone();
-                            let agreed_tx = agreed_tx.clone();
-                            Box::pin(async move {
-                                if let Err(e) = agreed_tx.send(entry_name).await {
-                                    error!(
-                                        target: "rustfs::scanner::folder",
-                                        event = EVENT_SCANNER_FOLDER_STATE,
-                                        component = LOG_COMPONENT_SCANNER,
-                                        subsystem = LOG_SUBSYSTEM_FOLDER,
-                                        entry = %entry.name,
-                                        state = "list_path_agreed_send_failed",
-                                        error = %e,
-                                        "Scanner list_path_raw agreed callback failed"
-                                    );
-                                }
-                            })
-                        })),
-                        partial: Some(Box::new(move |entries: MetaCacheEntries, _: &[Option<DiskError>]| {
-                            let partial_tx = partial_tx.clone();
-                            Box::pin(async move {
-                                if let Err(e) = partial_tx.send(entries).await {
-                                    error!(
-                                        target: "rustfs::scanner::folder",
-                                        event = EVENT_SCANNER_FOLDER_STATE,
-                                        component = LOG_COMPONENT_SCANNER,
-                                        subsystem = LOG_SUBSYSTEM_FOLDER,
-                                        state = "list_path_partial_send_failed",
-                                        error = %e,
-                                        "Scanner list_path_raw partial callback failed"
-                                    );
-                                }
-                            })
-                        })),
-                        finished: Some(Box::new(move |errs: &[Option<DiskError>]| {
-                            let finished_tx = finished_tx.clone();
-                            let errs_clone = errs.to_vec();
-                            Box::pin(async move {
-                                if let Err(e) = finished_tx.send(errs_clone).await {
-                                    error!(
-                                        target: "rustfs::scanner::folder",
-                                        event = EVENT_SCANNER_FOLDER_STATE,
-                                        component = LOG_COMPONENT_SCANNER,
-                                        subsystem = LOG_SUBSYSTEM_FOLDER,
-                                        state = "list_path_finished_send_failed",
-                                        error = %e,
-                                        "Scanner list_path_raw finished callback failed"
-                                    );
-                                }
-                            })
-                        })),
-                        ..scanner_abandoned_child_list_options()
-                    };
-                    #[cfg(test)]
-                    if let Some(observer) = list_path_raw_options_observer {
-                        let _ = observer.send((
-                            options.skip_walkdir_total_timeout,
-                            options.walkdir_timeout,
-                            options.walkdir_stall_timeout,
-                        ));
-                    }
-                    if let Err(e) = list_path_raw(child_ctx_clone.clone(), options).await {
+                    if let Err(e) = list_path_raw(
+                        child_ctx_clone.clone(),
+                        ListPathRawOptions {
+                            disks,
+                            bucket: bucket_clone.clone(),
+                            path: prefix_clone.clone(),
+                            recursive: true,
+                            report_not_found: true,
+                            min_disks: disks_quorum,
+                            walkdir_timeout: Some(SCANNER_LIST_PATH_RAW_TIMEOUT),
+                            walkdir_stall_timeout: Some(SCANNER_LIST_PATH_RAW_TIMEOUT),
+                            agreed: Some(Box::new(move |entry: MetaCacheEntry| {
+                                let entry_name = entry.name.clone();
+                                let agreed_tx = agreed_tx.clone();
+                                Box::pin(async move {
+                                    if let Err(e) = agreed_tx.send(entry_name).await {
+                                        error!(
+                                            target: "rustfs::scanner::folder",
+                                            event = EVENT_SCANNER_FOLDER_STATE,
+                                            component = LOG_COMPONENT_SCANNER,
+                                            subsystem = LOG_SUBSYSTEM_FOLDER,
+                                            entry = %entry.name,
+                                            state = "list_path_agreed_send_failed",
+                                            error = %e,
+                                            "Scanner list_path_raw agreed callback failed"
+                                        );
+                                    }
+                                })
+                            })),
+                            partial: Some(Box::new(move |entries: MetaCacheEntries, _: &[Option<DiskError>]| {
+                                let partial_tx = partial_tx.clone();
+                                Box::pin(async move {
+                                    if let Err(e) = partial_tx.send(entries).await {
+                                        error!(
+                                            target: "rustfs::scanner::folder",
+                                            event = EVENT_SCANNER_FOLDER_STATE,
+                                            component = LOG_COMPONENT_SCANNER,
+                                            subsystem = LOG_SUBSYSTEM_FOLDER,
+                                            state = "list_path_partial_send_failed",
+                                            error = %e,
+                                            "Scanner list_path_raw partial callback failed"
+                                        );
+                                    }
+                                })
+                            })),
+                            finished: Some(Box::new(move |errs: &[Option<DiskError>]| {
+                                let finished_tx = finished_tx.clone();
+                                let errs_clone = errs.to_vec();
+                                Box::pin(async move {
+                                    if let Err(e) = finished_tx.send(errs_clone).await {
+                                        error!(
+                                            target: "rustfs::scanner::folder",
+                                            event = EVENT_SCANNER_FOLDER_STATE,
+                                            component = LOG_COMPONENT_SCANNER,
+                                            subsystem = LOG_SUBSYSTEM_FOLDER,
+                                            state = "list_path_finished_send_failed",
+                                            error = %e,
+                                            "Scanner list_path_raw finished callback failed"
+                                        );
+                                    }
+                                })
+                            })),
+                            ..Default::default()
+                        },
+                    )
+                    .await
+                    {
                        if is_missing_path_disk_error(&e) {
                            debug!(
                                target: "rustfs::scanner::folder",
@@ -2841,8 +2820,6 @@ pub async fn scan_data_folder(
        skip_heal,
        local_disk,
        pending_heals_changed: false,
-        #[cfg(test)]
-        list_path_raw_options_observer: None,
    };

    // Check if context is cancelled
@@ -3049,7 +3026,6 @@ mod tests {
            skip_heal: Arc::new(AtomicBool::new(false)),
            local_disk: disk,
            pending_heals_changed: false,
-            list_path_raw_options_observer: None,
        };

        (scanner, temp_dir)
@@ -4234,8 +4210,6 @@ mod tests {
        scanner.heal_object_select = 1;
        scanner.disks = disks;
        scanner.disks_quorum = 2;
-        let (options_tx, mut options_rx) = mpsc::unbounded_channel();
-        scanner.list_path_raw_options_observer = Some(options_tx);
        scanner.old_cache.replace(
            &format!("{bucket}/{object}"),
            bucket,
@@ -4257,11 +4231,6 @@ mod tests {
            .expect("scan_folder should not hang after list_path_raw finishes")
            .expect("scan_folder should finish successfully");

-        let observed_options = tokio::time::timeout(Duration::from_secs(1), options_rx.recv())
-            .await
-            .expect("abandoned-child listing options should be observed promptly")
-            .expect("abandoned-child listing options channel should remain open");
-        assert_eq!(observed_options, (true, None, Some(SCANNER_LIST_PATH_RAW_STALL_TIMEOUT)));
        let root = scanner
            .new_cache
            .checked_flatten(bucket)
@@ -30,7 +30,6 @@ use rustfs_common::metrics::{Metric, Metrics, emit_scan_bucket_drive_complete, e
 use rustfs_config::{ENV_SCANNER_MAX_CONCURRENT_DISK_SCANS, ENV_SCANNER_MAX_CONCURRENT_SET_SCANS};
 use rustfs_data_usage::{BucketTargetUsageInfo, BucketUsageInfo};
 use rustfs_filemeta::FileMeta;
-use rustfs_lock::{LockError, NamespaceLockGuard};
 use rustfs_utils::path::path_join_buf;
 use s3s::dto::{BucketLifecycleConfiguration, ObjectLockConfiguration, ObjectLockEnabled, ReplicationConfiguration};
 use sha2::{Digest as _, Sha256};
@@ -945,85 +944,14 @@ fn checked_bucket_usage_info(entry: &DataUsageEntry) -> Option<BucketUsageInfo>
    Some(usage)
 }

-pub(crate) fn scanner_cache_lock_resource(cache_name: &str, source: DataUsageCacheSource) -> String {
-    let lock_name = format!("{SCANNER_CACHE_LOCK_SUFFIX}.pool-{}.set-{}", source.pool_index, source.set_index);
-    path_join_buf(&[crate::BUCKET_META_PREFIX, cache_name, &lock_name])
+pub(crate) fn scanner_cache_lock_resource(cache_name: &str) -> String {
+    path_join_buf(&[crate::BUCKET_META_PREFIX, cache_name, SCANNER_CACHE_LOCK_SUFFIX])
 }

 pub(crate) fn scanner_cache_lock_timeout() -> Duration {
    Duration::from_secs(rustfs_utils::get_env_u64("RUSTFS_LOCK_ACQUIRE_TIMEOUT", 5))
 }

-#[derive(Debug)]
-pub(crate) struct ScannerCacheLockGuards {
-    scoped: NamespaceLockGuard,
-}
-
-impl ScannerCacheLockGuards {
-    pub(crate) fn is_lock_lost(&self) -> bool {
-        self.scoped.is_lock_lost()
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum ScannerCacheLockError {
-    Create { resource: String, source: Error },
-    Acquire { resource: String, source: LockError },
-}
-
-impl ScannerCacheLockError {
-    pub(crate) fn state(&self) -> &'static str {
-        match self {
-            Self::Create { .. } => "lock_create_failed",
-            Self::Acquire { .. } => "lock_acquire_failed",
-        }
-    }
-
-    pub(crate) fn is_contention(&self) -> bool {
-        matches!(
-            self,
-            Self::Acquire {
-                source: LockError::Timeout { .. } | LockError::AlreadyLocked { .. },
-                ..
-            }
-        )
-    }
-}
-
-impl std::fmt::Display for ScannerCacheLockError {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Create { resource, source } => write!(formatter, "create scanner cache lock {resource}: {source}"),
-            Self::Acquire { resource, source } => write!(formatter, "acquire scanner cache lock {resource}: {source}"),
-        }
-    }
-}
-
-pub(crate) async fn acquire_scanner_cache_locks(
-    store: &SetDisks,
-    cache_name: &str,
-    source: DataUsageCacheSource,
-) -> std::result::Result<ScannerCacheLockGuards, ScannerCacheLockError> {
-    let timeout = scanner_cache_lock_timeout();
-    let scoped_resource = scanner_cache_lock_resource(cache_name, source);
-    let scoped_lock = store
-        .new_ns_lock(RUSTFS_META_BUCKET, &scoped_resource)
-        .await
-        .map_err(|source| ScannerCacheLockError::Create {
-            resource: scoped_resource.clone(),
-            source,
-        })?;
-    let scoped = scoped_lock
-        .get_write_lock_quiet(timeout)
-        .await
-        .map_err(|source| ScannerCacheLockError::Acquire {
-            resource: scoped_resource,
-            source,
-        })?;
-
-    Ok(ScannerCacheLockGuards { scoped })
-}
-
 async fn await_scanner_disk_shutdown<F>(scan: Pin<&mut F>)
 where
    F: Future,
@@ -1769,19 +1697,6 @@ mod publish_gate_tests {
        assert!(!cache_snapshot_is_current(&cache, "photos", source, 11, 0, second));
    }

-    #[test]
-    fn scanner_cache_lock_resource_is_scoped_to_cache_source() {
-        let cache_name = "photos/.usage-cache.bin";
-        let first_source = DataUsageCacheSource::new(0, 1);
-        let same_source = DataUsageCacheSource::new(0, 1);
-        let other_source = DataUsageCacheSource::new(1, 0);
-
-        let first = scanner_cache_lock_resource(cache_name, first_source);
-        assert_eq!(first, scanner_cache_lock_resource(cache_name, same_source));
-        assert_ne!(first, scanner_cache_lock_resource(cache_name, other_source));
-        assert!(first.ends_with(".scanner-cycle.lock.pool-0.set-1"));
-    }
-
    #[test]
    fn count_budget_serializes_set_and_disk_work() {
        assert_eq!(scanner_budgeted_concurrency_limit(8, true), 1);
@@ -1882,7 +1797,24 @@ async fn persist_and_publish_cache_snapshot(
    cache_cycle_floor: &AtomicU64,
 ) -> Option<SystemTime> {
    let source = cache_snapshot.info.source?;
-    let guard = match acquire_scanner_cache_locks(store.as_ref(), DATA_USAGE_CACHE_NAME, source).await {
+    let lock_resource = scanner_cache_lock_resource(DATA_USAGE_CACHE_NAME);
+    let ns_lock = match store.new_ns_lock(RUSTFS_META_BUCKET, &lock_resource).await {
+        Ok(lock) => lock,
+        Err(err) => {
+            error!(
+                target: "rustfs::scanner::io",
+                event = EVENT_SCANNER_CACHE_PERSIST_STATE,
+                component = LOG_COMPONENT_SCANNER,
+                subsystem = LOG_SUBSYSTEM_IO,
+                cache_name = DATA_USAGE_CACHE_NAME,
+                state = "lock_create_failed",
+                error = %err,
+                "Scanner cache snapshot lock creation failed"
+            );
+            return None;
+        }
+    };
+    let guard = match ns_lock.get_write_lock_quiet(scanner_cache_lock_timeout()).await {
        Ok(guard) => guard,
        Err(err) => {
            error!(
@@ -1891,7 +1823,7 @@ async fn persist_and_publish_cache_snapshot(
                component = LOG_COMPONENT_SCANNER,
                subsystem = LOG_SUBSYSTEM_IO,
                cache_name = DATA_USAGE_CACHE_NAME,
-                state = err.state(),
+                state = "lock_acquire_failed",
                error = %err,
                "Scanner cache snapshot lock acquisition failed"
            );
@@ -3148,35 +3080,14 @@ impl ScannerIOCache for SetDisks {
                        None
                    };

-                    // Lock order: scanner leader fence -> set-scoped per-bucket cache lock ->
-                    // cache object read/write.
-                    let cache_guard = match acquire_scanner_cache_locks(store_clone_clone.as_ref(), &cache_name, source).await {
-                        Ok(guard) => guard,
+                    // Lock order: scanner leader fence -> per-bucket cache lock ->
+                    // cache object read/write. The cache lock stays outermost for
+                    // local and rolling-upgrade workers so leader failover cannot
+                    // execute the same bucket concurrently.
+                    let lock_resource = scanner_cache_lock_resource(&cache_name);
+                    let ns_lock = match store_clone_clone.new_ns_lock(RUSTFS_META_BUCKET, &lock_resource).await {
+                        Ok(lock) => lock,
                        Err(e) => {
-                            if e.is_contention() {
-                                if requeue_bucket_work(&bucket_tx_clone, &bucket, &mut work_guard).await {
-                                    increment_disk_bucket_scans_queued(
-                                        &queued_disk_bucket_scans_clone,
-                                        &pool_label_clone,
-                                        &set_label_clone,
-                                    );
-                                } else {
-                                    record_failed_dirty_bucket(&failed_dirty_buckets_clone, &bucket.name).await;
-                                }
-                                debug!(
-                                    target: "rustfs::scanner::io",
-                                    event = EVENT_SCANNER_CACHE_PERSIST_STATE,
-                                    component = LOG_COMPONENT_SCANNER,
-                                    subsystem = LOG_SUBSYSTEM_IO,
-                                    bucket = %bucket.name,
-                                    cache_name = %cache_name,
-                                    state = "lock_contention_requeued",
-                                    error = %e,
-                                    "Scanner bucket cache lock contention requeued bucket work"
-                                );
-                                break;
-                            }
-
                            record_failed_dirty_bucket(&failed_dirty_buckets_clone, &bucket.name).await;
                            error!(
                                target: "rustfs::scanner::io",
@@ -3185,7 +3096,25 @@ impl ScannerIOCache for SetDisks {
                                subsystem = LOG_SUBSYSTEM_IO,
                                bucket = %bucket.name,
                                cache_name = %cache_name,
-                                state = e.state(),
+                                state = "lock_create_failed",
+                                error = %e,
+                                "Scanner bucket cache lock creation failed"
+                            );
+                            continue;
+                        }
+                    };
+                    let cache_guard = match ns_lock.get_write_lock_quiet(scanner_cache_lock_timeout()).await {
+                        Ok(guard) => guard,
+                        Err(e) => {
+                            record_failed_dirty_bucket(&failed_dirty_buckets_clone, &bucket.name).await;
+                            error!(
+                                target: "rustfs::scanner::io",
+                                event = EVENT_SCANNER_CACHE_PERSIST_STATE,
+                                component = LOG_COMPONENT_SCANNER,
+                                subsystem = LOG_SUBSYSTEM_IO,
+                                bucket = %bucket.name,
+                                cache_name = %cache_name,
+                                state = "lock_acquire_failed",
                                error = %e,
                                "Scanner bucket cache lock acquisition failed"
                            );
@@ -3965,52 +3894,6 @@ mod tests {
        (temp_dir, store)
    }

-    #[tokio::test]
-    #[serial]
-    async fn scanner_cache_locks_block_same_source_workers() {
-        let (_temp_dir, store) = setup_two_pool_scanner_store().await;
-        let set = &store.pools[0].disk_set[0];
-        let source = DataUsageCacheSource::new(0, 0);
-        let cache_name = "photos/.usage-cache.bin";
-
-        let guards = acquire_scanner_cache_locks(set.as_ref(), cache_name, source)
-            .await
-            .expect("scanner cache locks should be acquired");
-        let scoped_lock = set
-            .new_ns_lock(RUSTFS_META_BUCKET, &scanner_cache_lock_resource(cache_name, source))
-            .await
-            .expect("scoped scanner cache lock should be created");
-        let scoped_err = scoped_lock
-            .get_write_lock_quiet(Duration::from_millis(100))
-            .await
-            .expect_err("same-source workers must be blocked while scanner cache lock is held");
-        assert!(matches!(scoped_err, LockError::Timeout { .. } | LockError::AlreadyLocked { .. }));
-
-        drop(guards);
-        acquire_scanner_cache_locks(set.as_ref(), cache_name, source)
-            .await
-            .expect("scanner cache locks should be released when guards drop");
-    }
-
-    #[tokio::test]
-    #[serial]
-    async fn scanner_cache_locks_allow_cross_source_workers() {
-        let (_temp_dir, store) = setup_two_pool_scanner_store().await;
-        let first_set = &store.pools[0].disk_set[0];
-        let second_set = &store.pools[1].disk_set[0];
-        let cache_name = "photos/.usage-cache.bin";
-
-        let first = acquire_scanner_cache_locks(first_set.as_ref(), cache_name, DataUsageCacheSource::new(0, 0))
-            .await
-            .expect("first source scanner cache locks should be acquired");
-        let second = acquire_scanner_cache_locks(second_set.as_ref(), cache_name, DataUsageCacheSource::new(1, 0))
-            .await
-            .expect("different source scanner cache locks should not contend");
-
-        assert!(!first.is_lock_lost());
-        assert!(!second.is_lock_lost());
-    }
-
    #[tokio::test]
    async fn data_usage_publish_fails_when_receiver_is_closed() {
        let (updates, receiver) = mpsc::channel(1);
@@ -28,8 +28,8 @@ pub const NS_SCANNER_SESSION_SEQUENCE_QUERY: &str = "ns_scanner_session_sequence
 pub const NS_SCANNER_PROTOCOL_VERSION_QUERY: &str = "ns_scanner_protocol";
 pub const NS_SCANNER_PROTOCOL_VERSION: u16 = 3;
 pub const SCANNER_ACTIVITY_LEGACY_PROTOCOL_VERSION: u32 = 0;
-pub const SCANNER_ACTIVITY_PREVIOUS_PROTOCOL_VERSION: u32 = 5;
-pub const SCANNER_ACTIVITY_PROTOCOL_VERSION: u32 = 6;
+pub const SCANNER_ACTIVITY_PREVIOUS_PROTOCOL_VERSION: u32 = 4;
+pub const SCANNER_ACTIVITY_PROTOCOL_VERSION: u32 = 5;

 #[derive(Debug, serde::Deserialize, serde::Serialize)]
 #[serde(deny_unknown_fields)]
@@ -17,7 +17,7 @@ for later deletion.
 - `rustfs-5416-kubernetes-alias-dns` Kubernetes endpoint identity fallback: deployments created before explicit local endpoint identity may use resolvable aliases that do not match the Pod hostname. An implicit auto-mode zero match retains legacy DNS locality with a bounded deadline, while ambiguous matches and invalid explicit anchors still fail closed. Remove the fallback after every supported direct-upgrade chart and deployment manifest provides a canonical RUSTFS_LOCAL_ENDPOINT_HOST for domain-based distributed topologies.
 - `rustfs-5416-zero-retry-delay` startup retry-delay validation: releases before bounded topology convergence accept RUSTFS_STARTUP_TOPOLOGY_RETRY_MAX_DELAY values of 0 or 0ms. New servers replace those values with the safe nonzero default so a direct upgrade neither fails startup nor enters a busy loop. Reject zero after the minimum supported direct-upgrade release validates or rewrites this setting before rollout.
 - `scanner-usage-v2` persisted scanner usage migration: pre-v2 scanners write `.usage.json`, so upgraded clusters read that primary/backup pair only while `.usage.v2.json` is absent and continue removing deleted buckets from legacy copies that still exist. The additive usage_snapshot_complete field in `.usage.v2.json` must remain optional while mixed-version clusters are supported; a missing field means the snapshot is not authoritative. Remove the legacy object fallback and cleanup only after every supported direct-upgrade source writes `.usage.v2.json`.
- `ns-scanner-rpc-v3` namespace scanner capability and activity handshake: old peers and legacy internode transports lack the authenticated startup-epoch handshake. The oldest peers send an empty activity request and receive a field-empty protocol-0 response. Protocol v4 binds the challenge and response topology but cannot authenticate distributed dirty-usage state. Protocol v5 binds the request version, acknowledgement target and generation, and the response dirty-usage state, but predates set-scoped scanner cache locks. Current protocol v6 additionally fences scanner cache lock-domain changes, so distributed scanner cycles publish usage only after every peer reports protocol v6 state. Servers retain protocol-0 and protocol-v4 codecs for rolling upgrades, while protocol-v5 peers are treated as previous-version peers that cannot safely participate in the new cache lock domain. Scanner selection treats HTTP 404/405/426 and the legacy MethodNotAllowed default as an explicit lack of remote scanner v3 support and assigns those disks to coordinator-driven workers; transient capability failures remain incomplete and do not activate the fallback. Remove the coordinator fallback after the minimum supported RustFS peer version implements namespace scanner protocol v3, remove protocol-0 activity requests and responses after every supported peer implements authenticated scanner activity protocol v4, remove the protocol-v4 activity codec after every supported peer implements protocol v5, and remove protocol-v5 previous-version rejection after every supported peer implements protocol v6; future protocol revisions must keep the same dual-version server/codec window before changing the advertised version.
+- `ns-scanner-rpc-v3` namespace scanner capability and activity handshake: old peers and legacy internode transports lack the authenticated startup-epoch handshake. The oldest peers send an empty activity request and receive a field-empty protocol-0 response. Protocol v4 binds the challenge and response topology but cannot authenticate distributed dirty-usage state. Current protocol v5 binds the request version, acknowledgement target and generation, and the response dirty-usage state. Servers retain protocol-0 and protocol-v4 codecs for rolling upgrades, while the distributed scanner publishes usage only after every peer returns authenticated protocol v5 state. Scanner selection treats HTTP 404/405/426 and the legacy MethodNotAllowed default as an explicit lack of remote scanner v3 support and assigns those disks to coordinator-driven workers; transient capability failures remain incomplete and do not activate the fallback. Remove the coordinator fallback after the minimum supported RustFS peer version implements namespace scanner protocol v3, remove protocol-0 activity requests and responses after every supported peer implements authenticated scanner activity protocol v4, and remove the protocol-v4 activity codec after every supported peer implements protocol v5; future protocol revisions must keep the same dual-version server/codec window before changing the advertised version.
 - `#4648` walk-dir stream completion capability: old clients can append fallback output to an already-used metacache writer after a terminal body error, so servers emit terminal walk errors only to clients that sign the `walk_dir_stream_completion=error-v1` query capability and its request-body digest. Remove the legacy clean-EOF path after the minimum supported RustFS peer version always advertises this capability.
 - `heal-rpc-auth-v2` internode gRPC authentication: servers temporarily accept legacy prefix signatures so old peers remain available during rolling upgrades. Remove the legacy fallback after the minimum supported RustFS peer version sends v2 authentication on every internode gRPC request.
 - `disk-mutation-body-digest` internode mutating disk RPCs: servers temporarily accept mutating disk RPCs (RenameData, DeleteVersion, DeleteVersions, WriteMetadata, UpdateMetadata, WriteAll, Delete, DeletePaths, RenameFile, RenamePart, DeleteVolume, MakeVolume, MakeVolumes) that carry no signature-bound canonical body digest, so peers from releases that predate body-digest signing remain available during rolling upgrades. Accepted digestless mutations increment the internode body-digest fallback counter; that counter must read zero fleet-wide across a release window before RUSTFS_INTERNODE_RPC_BODY_DIGEST_STRICT is enabled. Because body-bound requests now consume replay-cache nonces on the receiver, deploy the raised RUSTFS_INTERNODE_RPC_REPLAY_CACHE_CAPACITY default fleet-wide before enabling strict mode, and watch the internode replay-cache overflow counter for undersized capacity during the rollout. Remove the digestless fallback after the minimum supported RustFS peer version body-binds every mutating disk RPC.
@@ -2,7 +2,7 @@

 RustFS ships several KMS backends. They differ not only in deployment effort but in **where master key material lives and who can read it**. Pick a backend based on the confidentiality boundary you need, not on the name alone.

-For how the Vault backends authenticate (static token, AppRole, Vault Agent token file) and how credential refresh and the fail-closed window behave, see the [Vault KMS authentication runbook](vault-kms-authentication.md). For what may be claimed about the cryptographic implementations themselves, see [Cryptographic compliance positioning](kms-cryptographic-compliance.md).
+For how the Vault backends authenticate (static token, AppRole, Vault Agent token file) and how credential refresh and the fail-closed window behave, see the [Vault KMS authentication runbook](vault-kms-authentication.md).

 ## Backend comparison

@@ -69,77 +69,6 @@ Decryption loads exactly the version recorded in the envelope and fails closed w

 Do not rotate any key until **every** RustFS node in the cluster runs a build that understands the `master_key_version` envelope field. Older binaries ignore the field and always decrypt with the current material: harmless while nothing has been rotated, but after a rotation they will fail to decrypt every object wrapped by an earlier key version. Complete the rolling upgrade of the entire cluster first, then rotate.

-This is the sharpest instance of a broader class of constraints; the rest are collected in [Mixed-version clusters during a rolling upgrade](#mixed-version-clusters-during-a-rolling-upgrade).
-
-## Mixed-version clusters during a rolling upgrade
-
-During a rolling upgrade the cluster runs two RustFS builds at once. That window matters more for KMS than for most subsystems, because KMS state is shared three ways: **Vault** holds the key records and Transit metadata, **cluster storage** holds the persisted KMS configuration, and **each node's process memory** holds caches and the live backend instance. Nodes on different builds agree on the first, may disagree on the third, and — for configuration — can disagree for as long as the operator leaves them running.
-
-This section states only what is true of the current implementation. It is written for the KV2 and Transit backends; the Local backend is unsupported for multi-node deployments regardless of version (see the [deployment support matrix](#deployment-support-matrix)).
-
-### Persisted formats are backward compatible in both directions
-
-Nothing in this list requires a coordinated format cutover. The compatibility is deliberate and is covered by decode tests.
-
- **DEK envelopes.** `DataKeyEnvelope::master_key_version` is optional and omitted when absent, so envelopes written by non-rotating backends stay byte-identical to the historical seven-field JSON shape. An upgraded node reading a pre-versioning envelope resolves `None` to the key's recorded baseline version, or — for a key that was never rotated, and so has no baseline — to the current version, which is exactly the pre-versioning behavior.
- **KV2 key records.** `baseline_version` is read with a serde default, so records written by older builds deserialize unchanged, and `None` correctly means "never rotated".
- **Transit metadata records.** Metadata persisted in KV v2 by either build decodes on the other.
-
-The one-way hazard is the rotation constraint above: an older binary reading a *new* envelope silently ignores the version field and decrypts with the current material.
-
-### Guarantees that hold only once every node is upgraded
-
-These are properties of the upgraded code, so a single node left behind removes them for the whole cluster.
-
- **Check-and-set lifecycle writes.** Upgraded builds write every KV2 lifecycle mutation — create, enable, disable, tag metadata, schedule deletion, cancel deletion — as a versioned read followed by a check-and-set write, retrying on conflict by re-reading and re-validating the state gate (rustfs/rustfs#5518). Transit metadata writes got the same treatment (rustfs/rustfs#5520). Builds older than those write blind. A blind write from an old node can overwrite a check-and-set commit from an upgraded node without any conflict being reported, which is precisely the lost update the change was made to eliminate.
- **`baseline_version` survives a write-back.** The KV2 key record does not deny unknown fields, so an old build reads a new record without error — and drops `baseline_version` when it writes that record back for any reason. A key that loses its baseline resolves pre-versioning envelopes to the current version again, which after a rotation means the wrong master key material. Any lifecycle operation issued to an old node is enough to trigger this.
- **Version-record awareness.** Rotation stores each historical version under `{prefix}/{key_id}/versions/{N}` as a create-only record (check-and-set of 0), so two nodes racing the same version number produce exactly one creator; the loser adopts the persisted, never-current material or fails without touching the current pointer. Old builds have no concept of that sub-path: they never read or write it, and their key listing reports the KV2 directory entry (`my-key/`) as though it were a key, because the directory filter only exists in upgraded builds.
-
-### Windows in which nodes can legitimately disagree
-
-Even with every node on the same build, some state is process-local. These windows are bounded by design, except the last one.
-
-| What can diverge | Bound | Mechanism |
-| --- | --- | --- |
-| Transit key lifecycle state used by the `encrypt` and `generate_data_key` gates | ≤ 300 s (`METADATA_CACHE_TTL`) | Each node caches Transit metadata in process, TTL- and capacity-bounded, with targeted invalidation when a data-path call reports the key is gone server-side. A disable or schedule-deletion performed on one node is enforced on the others within one TTL at the latest, sooner if they hit that signal. |
-| `describe_key` output | ≤ 300 s | The manager-level key metadata cache. This is a reporting cache; the KV2 state gates do not read it. |
-| KV2 key lifecycle state | None | The KV2 backend re-reads the key record from Vault for every lifecycle and data-key operation, so a committed disable is effective on every upgraded node immediately. |
-| Active KMS configuration | Until the remaining nodes are restarted | See below. |
-
-Builds older than rustfs/rustfs#5520 held the Transit metadata cache with no TTL and no capacity bound. On such a node the divergence window is not 300 seconds but "until the process restarts": it can keep encrypting under a key that another node disabled, indefinitely.
-
-### Configuration is persisted cluster-wide but applied per node
-
-`POST /rustfs/admin/v3/kms/reconfigure` currently does two things: it switches the KMS service **on the node that handled the request**, and it persists the new configuration to cluster storage at `config/kms_config.json`. It does not notify peers. Every other node keeps running the configuration it started with until it is restarted, at which point it loads the persisted configuration during startup.
-
-The practical consequences today:
-
- The configuration-split window has no upper bound other than the operator restarting the remaining nodes. Convergence is a restart, not a timeout.
- During the window both configurations are live. If the reconfiguration changed backends, or changed the Vault mount or key prefix, different nodes write new key material to different places, and a key created through one node is invisible to the others.
- `kms status` reflects the node that answered the request, so a single successful status response is not evidence that the cluster is consistent. Query every node.
-
-Treat `reconfigure` as the first step of a cluster-wide operation, not as the operation itself.
-
-### Recommended rolling upgrade order
-
-Follow the node-at-a-time procedure in the [multi-node restart runbook](rolling-restart.md); this adds the KMS-specific sequencing around it.
-
-1. **Freeze KMS administrative traffic** for the duration: no key creation, enable, disable, tagging, schedule-deletion, cancel-deletion, rotation, or reconfiguration. Object read and write traffic continues normally.
-2. **Upgrade one node at a time**, waiting for each to report ready before starting the next.
-3. **Verify no node is left behind** before unfreezing. A single old node is enough to reintroduce blind writes and to strip `baseline_version` on its next lifecycle write.
-4. **Resume administrative traffic.**
-5. **Only then perform the first rotation of any key.** Once the whole cluster understands `master_key_version`, rotation is safe; before that it is not.
-6. **If the KMS configuration was changed at any point**, restart the nodes that did not handle the request so they reload the persisted configuration, and confirm each one reports the intended backend.
-
-### Do not do these during a mixed-version window
-
- **Rotate any key.** This is the hard constraint stated above; a rotation is unrecoverable for objects an old node must read.
- **Issue any KV2 lifecycle write to an old node.** Its blind write can clobber a concurrent check-and-set commit and will drop `baseline_version` from the record.
- **Create the same key ID from two nodes.** The create path is create-only on upgraded builds, but an old node's blind write does not honor that: the later writer's material wins and every DEK already wrapped with the earlier material becomes permanently unwrappable.
- **Assume a disable or schedule-deletion took effect cluster-wide.** Old Transit nodes cache lifecycle state without expiry; confirm per node, or restart the old nodes, before treating a key as no longer in use.
- **Reconfigure the KMS backend and consider it done.** The change applies to one node and is persisted; the rest need a restart.
- **Delete or prune version records** under `{prefix}/{key_id}/versions/*` for any reason. This is never safe, mixed-version or not; see [Retention and destruction preconditions](#retention-and-destruction-preconditions).
-
 ## Choosing between Vault KV2 and Vault Transit

 Use **Vault Transit** (`VaultTransit`) when key material must be cryptographically isolated from anyone holding storage-level read access: Transit keeps key-encryption keys inside Vault and only ever returns ciphertext, and supports server-side key versioning/rotation.
@@ -1,148 +0,0 @@
-# Cryptographic compliance positioning
-
-This document records where RustFS stands on cryptographic module validation, what may and may not be said about it in external material, and what each possible route to a stronger position would actually cost. It exists so that the question is answered once, from the code, instead of being re-litigated from assumptions about crate names and feature flags.
-
-For where master key material lives per backend and how rotation retention works, see [KMS backend security properties](kms-backend-security.md).
-
-## Status: not FIPS 140-3 validated
-
-**RustFS is not FIPS 140-3 (or 140-2) validated, and no component it links is running as a validated cryptographic module.** There is no CMVP certificate covering RustFS or the libraries it uses in the shipped configuration.
-
-This is a deliberate position, not an oversight. It is also not a statement about algorithm strength: the algorithms in use are standard, well-reviewed AEADs. Validation is a property of a specific module build, its documented boundary, and a certificate — none of which RustFS has or currently pursues.
-
-### What the process actually links
-
-The table below is the audited inventory as of this document's writing. "Validated module" asks only whether the code performing the operation is a FIPS-validated cryptographic module; the answer is uniformly no.
-
-| Layer | Where | Implementation | Primitives | Validated module |
-| --- | --- | --- | --- | --- |
-| TLS (S3 server, internode, outbound clients) | Process-wide default provider installed by `install_default_crypto_provider` in `rustfs/src/startup_runtime_hooks.rs` | `rustls` with the `aws-lc-rs` provider | TLS 1.2/1.3 suites, `prefer-post-quantum` hybrid key exchange | No — this is the ordinary `aws-lc-rs` build, not the `aws-lc-fips-sys`-backed FIPS variant |
-| Object data path AEAD (SSE) | `crates/kms/src/encryption/ciphers.rs`, `crates/rio/src/encrypt_reader.rs`, `crates/rio-v2/src/encrypt_reader.rs` | RustCrypto `aes-gcm`, `chacha20poly1305` | AES-256-GCM, ChaCha20-Poly1305 | No |
-| DEK wrapping | `crates/kms/src/encryption/dek.rs` | RustCrypto `aes-gcm` | AES-256-GCM | No |
-| Local KMS backend master key | `crates/kms/src/backends/local.rs` | RustCrypto `argon2`, `aes-gcm` | Argon2id KDF, AES-256-GCM | No |
-| Config and IAM blobs at rest | `crates/crypto/src/encdec/` (`rustfs-crypto`) | RustCrypto `pbkdf2`/`argon2`, `aes-gcm`, `chacha20poly1305`, `sha2` | see [the `fips` feature](#the-rustfs-crypto-fips-feature-what-it-actually-does) | No |
-| JWT signing and verification | `jsonwebtoken` with the `aws_lc_rs` feature (`crates/crypto`, `crates/iam`, `crates/policy`) | AWS-LC through `aws-lc-rs` | Non-FIPS build | No |
-
-Two consequences follow directly from the table and are worth stating explicitly, because both are commonly assumed the other way:
-
- **AWS-LC being present does not imply FIPS.** `aws-lc-rs` has a FIPS variant; the workspace does not enable it. Every `aws-lc-rs` dependency in the workspace is the default, non-FIPS build.
- **The data path never touches AWS-LC.** Every byte of object plaintext is encrypted by RustCrypto software implementations. Swapping the TLS provider would not change that; see [route 1](#route-1-adopt-the-aws-lc-rs-fips-variant) for what would.
-
-## Terminology red lines for external material
-
-These rules apply to the README, CHANGELOG, release notes, marketing pages, sales decks, RFP responses, and security questionnaires. Claiming validation RustFS does not have is a false statement of fact with regulatory and contractual consequences, not a marketing overreach.
-
-### Never use
-
- "FIPS validated", "FIPS certified", "FIPS 140-2/140-3 compliant", "FIPS compliant"
- "FIPS mode", "runs in FIPS mode", "FIPS-enabled"
- "NIST certified", "NIST approved", "CMVP certificate", any certificate number
- "meets FIPS requirements", "satisfies FIPS", or any phrasing a reader would reasonably read as validation
- The internal Cargo feature name `fips` as a product capability. It is a build-time algorithm selector (see below), and surfacing it as a feature name invites exactly the misreading this section exists to prevent.
-
-### Permitted, with the qualifier attached
-
- **"FIPS-preferred algorithms"** — permitted only when accompanied, in the same paragraph or table cell, by an explicit non-validation statement. The defined meaning is: *the default algorithm selection is restricted to algorithms on the FIPS 140-3 approved list, implemented by software that has not been validated as a cryptographic module.*
- Naming specific primitives factually ("AES-256-GCM", "ChaCha20-Poly1305", "PBKDF2-HMAC-SHA256") is always fine. Algorithm names carry no validation claim.
-
-Suggested boilerplate when the topic cannot be avoided:
-
-> RustFS encrypts object data with AES-256-GCM and supports ChaCha20-Poly1305. These are FIPS-approved algorithms, but the implementations are not FIPS 140-3 validated cryptographic modules and RustFS makes no FIPS validation claim.
-
-### Guard
-
-There is currently no FIPS-related wording anywhere in the repository's Markdown; that clean baseline is what a grep anchor test protects. Any future occurrence of the banned strings in shipped documentation should be treated as a defect and either removed or brought under the qualifier rule above.
-
-## The `rustfs-crypto` `fips` feature: what it actually does
-
-`crates/crypto/Cargo.toml` declares `default = ["crypto", "fips"]`, so the feature is on in every normal build. Its entire effect is **which algorithm the write path selects**; the implementation is RustCrypto either way.
-
-| `fips` | Algorithm ID written | KDF | AEAD |
-| --- | --- | --- | --- |
-| enabled (default) | `ID::Pbkdf2AESGCM` (`0x02`) | PBKDF2-HMAC-SHA256, 8192 iterations | AES-256-GCM |
-| disabled | `ID::Argon2idAESGCM` (`0x00`) or `ID::Argon2idChaCHa20Poly1305` (`0x01`), chosen at runtime by CPU AES support | Argon2id (64 MiB, t=1, p=4) | AES-256-GCM or ChaCha20-Poly1305 |
-
-The selection sites are `crates/crypto/src/encdec/encrypt.rs` and `crates/crypto/src/encdec/stream_io.rs`; the algorithm identifiers and their KDF parameters live in `crates/crypto/src/encdec/id.rs`.
-
-Three properties matter for anyone reasoning about this feature:
-
- **It affects writes only.** The decrypt path in `crates/crypto/src/encdec/id.rs` accepts all three identifiers unconditionally, and every ciphertext carries its identifier byte. Toggling the feature therefore never orphans existing data in either direction.
- **It does not select a different implementation.** Both branches call RustCrypto. There is no validated module on either side of the switch, so the feature cannot move RustFS toward or away from validation.
- **It is a trade-off, not an upgrade.** The FIPS-preferred branch uses PBKDF2-HMAC-SHA256 at 8192 iterations, a work factor well below current password-hashing guidance, whereas the non-FIPS branch uses memory-hard Argon2id. Against an attacker who has obtained an encrypted config or IAM blob and is attacking the passphrase offline, the default branch is the weaker of the two. Enabling the feature buys approved-algorithm alignment, not more resistance.
-
-### Rename recommendation
-
-The name `fips` states a compliance property the feature does not provide, and `rustfs-crypto` is published, so the name is visible to downstream consumers. Recommended direction:
-
-1. Introduce `fips-preferred-algs` as the real feature name, carrying the current behavior.
-2. Redefine `fips = ["fips-preferred-algs"]` so existing consumers keep building, and mark it deprecated in the crate documentation with a pointer to this document.
-3. Drop the `fips` alias after one release cycle.
-4. While renaming, raise the PBKDF2 iteration count or document the trade-off above at the feature definition, so the choice is explicit rather than inherited.
-
-This is a naming and documentation change only; no ciphertext format changes, because the identifier bytes stay as they are.
-
-## Routes to a stronger position, and what each costs
-
-### Route 1: adopt the `aws-lc-rs` FIPS variant
-
-Switch the whole process to `aws-lc-rs`'s FIPS build (backed by `aws-lc-fips-sys`) so cryptographic operations run inside a validated module boundary.
-
-**Scope.** The TLS provider swap is the small part — one feature flag plus the provider install sites. The substantial work is the data path: every AEAD call in `crates/kms/src/encryption/ciphers.rs`, `crates/kms/src/encryption/dek.rs`, `crates/rio/src/encrypt_reader.rs`, `crates/rio-v2/src/encrypt_reader.rs`, `crates/kms/src/backends/local.rs`, and `crates/crypto/src/encdec/` would have to be re-implemented against `aws-lc-rs` primitives. Anything the validated module does not expose has to be dropped or moved out of the boundary: Argon2id has no FIPS status, so the Local backend's KDF and the non-FIPS branch of `rustfs-crypto` would need a compatibility story (read-only support for existing records, PBKDF2 for new ones), and ChaCha20-Poly1305 would become non-approved for new writes.
-
-**Build and platform cost.** `aws-lc-fips-sys` builds a pinned, validated source release and needs CMake, a C toolchain, and Go at build time; it supports a narrower target set than the ordinary crate. The platform matrix cost of plain AWS-LC is already documented and non-hypothetical: rustfs/backlog#883 records that the static musl release build compiles AWS-LC's `getentropy` entropy backend, which aborts on Linux kernels older than 3.17 (the Synology class of device), and that upstream considers this by design with no plan to fix it. The FIPS variant constrains the buildable matrix strictly harder than that, and pins upgrades to whatever the certified source revision allows.
-
-**What it would and would not buy.** Linking the validated module makes the accurate claim "cryptographic operations are performed by a FIPS 140-3 validated module", not "RustFS is FIPS validated". A product-level claim additionally requires a documented module boundary, approved-mode enforcement, power-on self-tests, key zeroization, and entropy-source documentation, plus the operational procedures to keep them true across releases.
-
-**Verdict.** Heavy, and it re-opens a platform-support question that is already an open problem. Justified only by a concrete customer or regulatory commitment that names FIPS as a requirement.
-
-### Route 2: let an externally validated KMS carry key operations
-
-Keep RustFS as-is and place key management inside someone else's validated boundary: the Vault Transit backend against a Vault deployment whose seal/HSM is validated, or an equivalent managed KMS.
-
-**Scope.** Mostly already built. The Transit backend (`VaultTransit`) never lets key-encryption key material leave Vault; RustFS only ever holds Transit ciphertext. What remains is configuration guidance, a supported-deployment statement, and the operational documentation that says which parts of the system are covered.
-
-**What it buys.** Master key generation, wrapping, unwrapping, and rotation happen inside the external module. That is a real, defensible partial answer to "where do keys live and who validated that": it covers the key operations, which is often the part an auditor actually asks about.
-
-**What it does not buy.** The object data path is untouched. DEKs are used for bulk AEAD by RustCrypto inside the RustFS process, and TLS still runs the non-FIPS AWS-LC build. The honest formulation is "key management operations are performed by an externally validated module; the object data path is not validated".
-
-**Verdict.** The nearest partial step, with no code rewrite and no platform-matrix risk. This is the route to point customers at when the requirement is about key custody rather than about a certificate covering the storage layer.
-
-### Route 3: make no validation claim (current default)
-
-Document the position, hold the terminology line, and revisit only when a requirement with a name attached shows up.
-
-**Cost.** This document plus the grep guard. Nothing else.
-
-**Verdict.** The current decision. FIPS 140-3 validation is explicitly not a roadmap target, and adjacent items (PKCS#11, KMIP, BYOK, signing keys) are deferred for lack of demand and because HSM-dependent paths cannot be exercised in CI.
-
-## Algorithm disablement and migration policy
-
-Retiring an algorithm from a storage system is not a code change; it is a data migration with a code change at each end. This section fixes the sequence so that no future deprecation removes a decrypt path while data still depends on it.
-
-### Every persisted artifact is self-describing
-
-The precondition for safe migration already holds: nothing relies on a global "current algorithm" setting to be decodable.
-
- `rustfs-crypto` blobs carry the `ID` byte (`crates/crypto/src/encdec/id.rs`) immediately after the salt.
- KMS ciphers are selected from the recorded `EncryptionAlgorithm` (`crates/kms/src/types.rs`).
- DEK envelopes record which master key version wrapped them in `DataKeyEnvelope::master_key_version` (`crates/kms/src/encryption/dek.rs`).
-
-So for any stored object it is decidable, from the object alone, which algorithm and which key version it needs.
-
-### Deprecation classes
-
-Retirement moves an algorithm through these states, never skipping one:
-
-1. **Write-disabled, read-supported.** New writes select a replacement; existing data decrypts unchanged. This is the only step that is cheap and reversible.
-2. **Read-deprecated.** Reads still work but are counted and warned on, so the remaining population is measurable.
-3. **Read-removed.** The decrypt path is deleted. Permitted only once the remaining population is provably zero.
-
-### Sequencing rules
-
- Never advance to read-removed on the strength of an argument that data "should have been" migrated. Removal requires evidence that nothing references the algorithm, not an elapsed-time policy.
- A change to default algorithm selection is a compatibility event: it changes what new nodes write, which matters in a mixed-version cluster. Record it in the release notes and in the relevant crate's feature documentation, and check it against the [mixed-version constraints](kms-backend-security.md#mixed-version-clusters-during-a-rolling-upgrade).
- Roll out write-disablement before the corresponding read change, and let the cluster fully converge in between. A build that cannot read what a peer is still writing is the failure mode to avoid.
-
-### Known gap
-
-Step 3 is currently unreachable for object data. There is no object rewrap or re-encryption capability, so there is no supported way to migrate already-written objects off an algorithm or off a master key version — the same gap that forces the rotation retention rule in [KMS backend security properties](kms-backend-security.md#retention-and-destruction-preconditions). Until a rewrap capability exists, treat every algorithm that has ever been written as permanently read-required, and confine deprecation to step 1.
@@ -9,7 +9,7 @@
 > (`.config/nextest.toml`); admission criteria: `crates/e2e_test/README.md`.
 > 🌙 marks tests in the scheduled `e2e-repl-nightly` profile (backlog#1147
 > repl-1): `replication_extension_test` splits 20 fast tests into the PR smoke
-> lane and 28 slow / `_real_dual_node` / `_real_three_node` / `_real_single_node` tests into the
+> lane and 27 slow / `_real_dual_node` / `_real_three_node` / `_real_single_node` tests into the
 > nightly lane (`.github/workflows/e2e-replication-nightly.yml`).
 > Note: counts exclude `#[ignore]`d tests (nextest lists them separately).
 > The SSE-S3 replication contract is ignored under backlog#1291 until its
@@ -17,11 +17,11 @@

 | module | tests | PR smoke |
 |---|---|---|
-| admin_auth_test | 4 | ✅ |
+| admin_auth_test | 3 | ✅ |
 | admin_iam_crud_test | 2 | ✅ |
 | admin_pools_test | 1 | ✅ |
 | admin_timeout_regression_test | 1 |  |
-| anonymous_access_test | 4 | ✅ |
+| anonymous_access_test | 3 | ✅ |
 | api_rate_limit_test | 3 |  |
 | archive_download_integrity_test | 13 |  |
 | bucket_logging_test | 3 |  |
@@ -29,7 +29,7 @@
 | checksum_upload_test | 7 |  |
 | cluster_concurrency_test | 2 |  |
 | cluster_multidrive_pool_test | 2 |  |
-| common | 12 |  |
+| common | 10 |  |
 | compression_test | 1 |  |
 | connection_cap_test | 2 |  |
 | console_smoke_test | 1 | ✅ |
@@ -51,9 +51,7 @@
 | head_object_consistency_test | 1 | ✅ |
 | head_object_range_test | 1 | ✅ |
 | heal_erasure_disk_rebuild_test | 3 |  |
-| inline_fast_path_cluster_test | 14 |  |
-| internode_rpc_signature_e2e_test | 5 |  |
-| kms | 41 |  |
+| kms | 40 |  |
 | leading_slash_key_test | 2 | ✅ |
 | list_buckets_double_slash_test | 3 | ✅ |
 | list_object_versions_metadata_extension_test | 1 |  |
@@ -74,7 +72,7 @@
 | protocols | 16 |  |
 | quota_test | 14 |  |
 | reliability_disk_fault_test | 3 |  |
-| reliant | 24 | 18 ✅ |
+| reliant | 10 | 5 ✅ |
 | replication_extension_test | 48 | 20 ✅ +28 🌙 |
 | security_boundary_test | 4 |  |
 | ssec_copy_test | 2 | ✅ |
@@ -83,11 +81,10 @@
 | special_chars_test | 14 | ✅ |
 | stale_multipart_cleanup_cluster_test | 1 |  |
 | storage_class_capability_test | 4 | ✅ |
-| sts_query_compat_test | 3 | ✅ |
 | tls_gen | 3 |  |
 | tls_hot_reload_test | 1 | ✅ |
 | version_id_regression_test | 10 | ✅ |

 `notification_webhook_test` also has 1 ignored store-and-forward regression tracked by rustfs#4852; ignored tests are excluded from the active counts above.

-**Total listed: 527 tests across 70 modules · PR smoke subset: 147 tests / 33 modules** (31 full modules + 18 `reliant` tests + 20 of `replication_extension_test`) **· nightly `e2e-repl-nightly`: 28 tests** · generated 2026-07-30.
+**Total listed: 486 tests across 67 modules · PR smoke subset: 129 tests / 32 modules** (30 full modules + 5 `reliant` tests + 20 of `replication_extension_test`) **· nightly `e2e-repl-nightly`: 28 tests** · generated 2026-07-26.
@@ -46,20 +46,6 @@ impl<'a> AdminResourceScope<'a> {
    pub fn bucket_object(bucket: &'a str, object: &'a str) -> Self {
        Self { bucket, object }
    }
-
-    /// Scope an admin request to a single KMS key.
-    ///
-    /// The policy crate carries the requested key identifier in the object slot
-    /// with an empty bucket (see `Statement::kms_key_scope_matches`); `Args` has
-    /// no dedicated field for it. An empty `key_id` means the caller could not
-    /// name a target key, which keeps the pre-resource-scoping behaviour where a
-    /// KMS statement matches every key.
-    pub fn kms_key(key_id: &'a str) -> Self {
-        Self {
-            bucket: "",
-            object: key_id,
-        }
-    }
 }

 pub async fn validate_admin_request(
@@ -188,34 +174,6 @@ pub async fn validate_admin_request_with_bucket_object(
    evaluate_admin_actions(iam_store, &ctx, &actions, resource.bucket, resource.object).await
 }

-/// Admin gate for KMS endpoints that act on one key.
-///
-/// `key_id` is the identifier as requested (before any alias resolution), so a
-/// policy scoped to `arn:aws:kms:::key/<id>` only authorizes that key. Endpoints
-/// without a target key pass `""` and stay unscoped, which is also what a
-/// malformed request resolves to: the request is rejected on its own parse error
-/// right after the gate, so no key is ever touched under an unscoped decision.
-pub async fn validate_admin_request_with_kms_key(
-    headers: &HeaderMap,
-    cred: &Credentials,
-    is_owner: bool,
-    deny_only: bool,
-    actions: Vec<Action>,
-    remote_addr: Option<std::net::SocketAddr>,
-    key_id: &str,
-) -> S3Result<()> {
-    validate_admin_request_with_bucket_object(
-        headers,
-        cred,
-        is_owner,
-        deny_only,
-        actions,
-        remote_addr,
-        AdminResourceScope::kms_key(key_id),
-    )
-    .await
-}
-
 /// Unified authentication request handler for both UI and CLI
 ///
 /// This function provides a single entry point for authentication,
@@ -290,13 +248,12 @@ mod tests {
    use rustfs_iam::manager::IamCache;
    use rustfs_iam::store::{GroupInfo, MappedPolicy, UserType};
    use rustfs_policy::auth::UserIdentity;
-    use rustfs_policy::policy::action::{AdminAction, KmsAction};
-    use rustfs_policy::policy::{Policy, PolicyDoc};
+    use rustfs_policy::policy::PolicyDoc;
+    use rustfs_policy::policy::action::AdminAction;
    use serde::Serialize;
    use serde::de::DeserializeOwned;
    use std::collections::HashMap;
    use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU8, AtomicU64};
-    use time::OffsetDateTime;

    /// A `Store` whose methods are never invoked by these tests: the gate only
    /// reaches the persistence layer for non-owner principals, and the
@@ -426,14 +383,14 @@ mod tests {
        }
    }

-    /// An `IamCache` over an empty in-memory snapshot. It is constructed
-    /// directly (all fields are public, mirroring the iam crate's own
-    /// `build_test_iam_cache`) so no cluster-backed `ObjectStore` or disk load is
-    /// required. Readiness state is irrelevant: the gate calls `is_allowed`
-    /// directly, which does not gate on `is_ready`.
-    fn iam_cache_with_empty_store() -> IamCache<EmptyStore> {
+    /// Build an `IamSys` backed by an empty in-memory cache. The cache is
+    /// constructed directly (all fields are public, mirroring the iam crate's
+    /// own `build_test_iam_cache`) so no cluster-backed `ObjectStore` or disk
+    /// load is required. Readiness state is irrelevant: the gate calls
+    /// `is_allowed` directly, which does not gate on `is_ready`.
+    fn iam_sys_with_empty_store() -> Arc<IamSys<EmptyStore>> {
        let (send_chan, _rx) = tokio::sync::mpsc::channel::<i64>(1);
-        IamCache {
+        let cache = IamCache {
            cache: Cache::default(),
            api: EmptyStore,
            state: Arc::new(AtomicU8::new(0)),
@@ -444,47 +401,10 @@ mod tests {
            sync_failures: AtomicU64::new(0),
            sync_successes: AtomicU64::new(0),
            last_sync_duration_millis: AtomicU64::new(0),
-        }
+        };
+        Arc::new(IamSys::new(Arc::new(cache)))
    }

-    fn iam_sys_with_empty_store() -> Arc<IamSys<EmptyStore>> {
-        Arc::new(IamSys::new(Arc::new(iam_cache_with_empty_store())))
-    }
-
-    /// Same in-memory `IamSys`, with one regular (non-owner, non-temp,
-    /// non-service) account carrying `document` as its only attached policy. All
-    /// three cache entries the evaluation path consults are pre-seeded, so no
-    /// `EmptyStore` method is ever reached.
-    fn iam_sys_with_policy(account: &str, document: &str) -> Arc<IamSys<EmptyStore>> {
-        let store = iam_cache_with_empty_store();
-        let now = OffsetDateTime::now_utc();
-        let cache = &store.cache;
-
-        cache.add_or_update_user(
-            account,
-            &UserIdentity::new(Credentials {
-                access_key: account.to_string(),
-                secret_key: "kms-operator-secret".to_string(),
-                status: "on".to_string(),
-                ..Default::default()
-            }),
-            now,
-        );
-        cache.add_or_update_policy_doc(
-            KMS_TEST_POLICY_NAME,
-            &PolicyDoc {
-                policy: Policy::parse_config(document.as_bytes()).expect("test policy should parse"),
-                ..Default::default()
-            },
-            now,
-        );
-        cache.add_or_update_user_policy(account, &MappedPolicy::new(KMS_TEST_POLICY_NAME), now);
-
-        Arc::new(IamSys::new(Arc::new(store)))
-    }
-
-    const KMS_TEST_POLICY_NAME: &str = "kms-key-a-only";
-
    fn ctx_for<'a>(headers: &'a HeaderMap, cred: &'a Credentials, is_owner: bool) -> AuthContext<'a> {
        AuthContext {
            headers,
@@ -551,87 +471,6 @@ mod tests {
        assert_access_denied(res);
    }

-    /// KMS scoping rides the object slot with an empty bucket, matching the
-    /// contract the policy crate evaluates KMS statements against.
-    #[test]
-    fn kms_scope_carries_the_key_id_in_the_object_slot() {
-        let scope = AdminResourceScope::kms_key("key-a");
-        assert_eq!(scope.bucket, "");
-        assert_eq!(scope.object, "key-a");
-
-        let unscoped = AdminResourceScope::kms_key("");
-        assert_eq!(unscoped.object, "", "an absent key id must stay unscoped");
-    }
-
-    const KMS_OPERATOR: &str = "kms-operator";
-
-    fn kms_disable_key_actions() -> Vec<Action> {
-        vec![Action::KmsAction(KmsAction::DisableKeyAction)]
-    }
-
-    async fn gate_for_key(iam: Arc<IamSys<EmptyStore>>, key_id: &str, is_owner: bool) -> S3Result<()> {
-        let headers = HeaderMap::new();
-        let cred = Credentials {
-            access_key: KMS_OPERATOR.to_string(),
-            secret_key: "kms-operator-secret".to_string(),
-            status: "on".to_string(),
-            ..Default::default()
-        };
-        let ctx = ctx_for(&headers, &cred, is_owner);
-        let scope = AdminResourceScope::kms_key(key_id);
-
-        evaluate_admin_actions(iam, &ctx, &kms_disable_key_actions(), scope.bucket, scope.object).await
-    }
-
-    /// End-to-end through the gate: a `kms:DisableKey` grant limited to `key/A`
-    /// authorizes key A and denies key B with `AccessDenied`. This is the seam the
-    /// per-handler tests cannot reach — it pins that the scope actually travels
-    /// into the policy verdict rather than being dropped on the way
-    /// (rustfs/backlog#1582).
-    #[tokio::test]
-    async fn kms_scoped_gate_denies_a_key_outside_the_policy_scope() {
-        let document = r#"{"Version":"2012-10-17","Statement":[
-            {"Effect":"Allow","Action":["kms:DisableKey"],"Resource":["arn:aws:kms:::key/key-a"]}
-        ]}"#;
-
-        let allowed = gate_for_key(iam_sys_with_policy(KMS_OPERATOR, document), "key-a", false).await;
-        assert!(allowed.is_ok(), "the key the policy names must pass the gate");
-
-        assert_access_denied(gate_for_key(iam_sys_with_policy(KMS_OPERATOR, document), "key-b", false).await);
-    }
-
-    /// Compatibility pins for the same gate: a resource-less KMS statement keeps
-    /// authorizing every key, and the owner short-circuit is unaffected by scoping.
-    #[tokio::test]
-    async fn kms_scoped_gate_keeps_unscoped_policies_and_owners_unrestricted() {
-        let unscoped = r#"{"Version":"2012-10-17","Statement":[
-            {"Effect":"Allow","Action":["kms:DisableKey"]}
-        ]}"#;
-        let scoped = r#"{"Version":"2012-10-17","Statement":[
-            {"Effect":"Allow","Action":["kms:DisableKey"],"Resource":["arn:aws:kms:::key/key-a"]}
-        ]}"#;
-
-        for key in ["key-a", "key-b"] {
-            let res = gate_for_key(iam_sys_with_policy(KMS_OPERATOR, unscoped), key, false).await;
-            assert!(res.is_ok(), "a resource-less KMS statement must keep authorizing {key}");
-
-            let res = gate_for_key(iam_sys_with_policy(KMS_OPERATOR, scoped), key, true).await;
-            assert!(res.is_ok(), "the owner short-circuit must still authorize {key}");
-        }
-    }
-
-    /// An endpoint with no target key passes an empty scope, which must behave
-    /// exactly like the unscoped gate it replaced.
-    #[tokio::test]
-    async fn kms_gate_without_a_target_key_matches_every_key() {
-        let scoped = r#"{"Version":"2012-10-17","Statement":[
-            {"Effect":"Allow","Action":["kms:DisableKey"],"Resource":["arn:aws:kms:::key/key-a"]}
-        ]}"#;
-
-        let res = gate_for_key(iam_sys_with_policy(KMS_OPERATOR, scoped), "", false).await;
-        assert!(res.is_ok(), "an absent key id must keep the pre-resource-scoping verdict");
-    }
-
    /// The multi-action loop authorizes as soon as one candidate action passes
    /// (owner short-circuits every action), and denies when none pass.
    #[tokio::test]
@@ -14,8 +14,8 @@

 //! KMS key lifecycle admin API handlers: enable, disable and rotate.

-use super::kms_keys::{extract_query_params, scoped_key_id};
-use crate::admin::auth::validate_admin_request_with_kms_key;
+use super::kms_keys::extract_query_params;
+use crate::admin::auth::validate_admin_request;
 use crate::admin::router::{AdminOperation, Operation, S3Router};
 use crate::admin::runtime_sources::current_kms_runtime_service_manager;
 use crate::auth::{check_key_valid, get_session_token};
@@ -252,27 +252,21 @@ async fn handle_lifecycle_request(

    let (cred, owner) = check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &cred.access_key).await?;

-    // The body (or the `keyId` query parameter) names the key this operation acts
-    // on, so it has to be resolved before the gate runs. A read failure is
-    // surfaced only afterwards so an unauthorized caller still sees AccessDenied.
-    let body = req.input.store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE).await;
-
-    validate_admin_request_with_kms_key(
+    validate_admin_request(
        &req.headers,
        &cred,
        owner,
        false,
        actions,
        req.extensions.get::<Option<RemoteAddr>>().and_then(|opt| opt.map(|a| a.0)),
-        body.as_ref()
-            .ok()
-            .and_then(|body| scoped_key_id(body, &req.uri))
-            .as_deref()
-            .unwrap_or_default(),
    )
    .await?;

-    let body = body.map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;
+    let body = req
+        .input
+        .store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE)
+        .await
+        .map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;

    let request: KmsKeyLifecycleRequest = if body.is_empty() {
        let query_params = extract_query_params(&req.uri);
@@ -341,7 +335,6 @@ impl Operation for RotateKmsKeyHandler {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use http::Uri;
    use rustfs_kms::backends::local::LocalKmsBackend;
    use rustfs_kms::config::KmsConfig;
    use rustfs_kms::types::{CreateKeyRequest, KeyState};
@@ -454,47 +447,6 @@ mod tests {
        }
    }

-    /// The lifecycle gate must be scoped to the key the request names, and the
-    /// key must be resolved the same way for authorization and for execution.
-    #[test]
-    fn lifecycle_requests_authorize_against_the_key_they_operate_on() {
-        let src = include_str!("kms_key_lifecycle.rs");
-        let handler = src
-            .split_once("async fn handle_lifecycle_request(")
-            .expect("lifecycle entry point should exist")
-            .1;
-        let handler = &handler[..handler.find("\nfn kms_service_manager_from_context").unwrap_or(handler.len())];
-
-        assert!(
-            handler.contains("validate_admin_request_with_kms_key("),
-            "lifecycle requests must scope authorization to the requested key"
-        );
-        assert!(
-            handler.contains("scoped_key_id(body, &req.uri)"),
-            "authorization must resolve the key exactly as execution does"
-        );
-
-        let uri: Uri = "/rustfs/admin/v3/kms/keys/disable?keyId=query-key"
-            .parse()
-            .expect("uri should parse");
-        let body = br#"{"key_id":"body-key"}"#;
-
-        assert_eq!(scoped_key_id(body, &uri).as_deref(), Some("body-key"));
-        assert_eq!(
-            scoped_key_id(body, &uri).as_deref(),
-            Some(
-                serde_json::from_slice::<KmsKeyLifecycleRequest>(body)
-                    .expect("lifecycle body should parse")
-                    .key_id
-                    .as_str()
-            )
-        );
-        assert_eq!(
-            scoped_key_id(b"", &uri).as_deref(),
-            extract_query_params(&uri).get("keyId").map(String::as_str)
-        );
-    }
-
    #[test]
    fn lifecycle_request_rejects_unknown_fields() {
        let error = serde_json::from_str::<KmsKeyLifecycleRequest>(r#"{"key_id":"key","unexpected_field":true}"#)
@@ -14,7 +14,7 @@

 //! KMS key management admin API handlers

-use crate::admin::auth::{validate_admin_request, validate_admin_request_with_kms_key};
+use crate::admin::auth::validate_admin_request;
 use crate::admin::router::{AdminOperation, Operation, S3Router};
 use crate::admin::runtime_sources::{current_kms_runtime_service_manager, current_or_init_kms_runtime_service_manager};
 use crate::auth::{check_key_valid, get_session_token};
@@ -116,29 +116,6 @@ fn extract_key_id(uri: &hyper::Uri) -> Option<String> {
        .find_map(|name| query_params.get(name).filter(|value| !value.is_empty()).cloned())
 }

-/// The `key_id` of a KMS admin request body, read without committing to the
-/// strict schema of the endpoint: the authorization gate needs the target key
-/// before the body is parsed for execution, and a body that fails the strict
-/// parse is rejected right after the gate anyway.
-#[derive(Deserialize)]
-struct KeyIdProbe {
-    #[serde(default)]
-    key_id: String,
-}
-
-/// Target key of an endpoint that accepts either a JSON body or a `keyId` query
-/// parameter, resolved exactly the way the endpoint resolves it for execution so
-/// the authorized key can never differ from the operated one. Returns `None`
-/// when the target cannot be determined, which authorizes unscoped and lets the
-/// request fail on its own parse error afterwards.
-pub(super) fn scoped_key_id(body: &[u8], uri: &hyper::Uri) -> Option<String> {
-    if body.is_empty() {
-        return extract_query_params(uri).get("keyId").cloned();
-    }
-
-    serde_json::from_slice::<KeyIdProbe>(body).ok().map(|probe| probe.key_id)
-}
-
 fn kms_service_manager_from_context() -> Option<std::sync::Arc<rustfs_kms::KmsServiceManager>> {
    current_kms_runtime_service_manager()
 }
@@ -302,20 +279,17 @@ impl Operation for DescribeKeyHandler {
        let (cred, owner) =
            check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &cred.access_key).await?;

-        let requested_key_id = extract_key_id(&req.uri);
-
-        validate_admin_request_with_kms_key(
+        validate_admin_request(
            &req.headers,
            &cred,
            owner,
            false,
            kms_describe_key_actions(),
            req.extensions.get::<Option<RemoteAddr>>().and_then(|opt| opt.map(|a| a.0)),
-            requested_key_id.as_deref().unwrap_or_default(),
        )
        .await?;

-        let Some(key_id) = requested_key_id else {
+        let Some(key_id) = extract_key_id(&req.uri) else {
            return Err(s3_error!(InvalidRequest, "missing required parameter: 'keyId'"));
        };

@@ -361,12 +335,10 @@ mod tests {
    use super::{
        CancelKmsKeyDeletionRequest, CreateKeyApiRequest, CreateKmsKeyRequest, DeleteKmsKeyRequest, GenerateDataKeyApiRequest,
        extract_key_id, kms_create_key_actions, kms_delete_key_actions, kms_describe_key_actions, kms_generate_data_key_actions,
-        kms_list_keys_actions, scoped_key_id,
+        kms_list_keys_actions,
    };
    use http::Uri;
    use rustfs_policy::policy::action::{Action, AdminAction, KmsAction};
-    use rustfs_policy::policy::{Args, Policy};
-    use std::collections::HashMap;

    fn assert_has_action(actions: &[Action], action: Action) {
        assert!(actions.contains(&action), "expected action list to contain {action:?}");
@@ -450,248 +422,6 @@ mod tests {
            assert!(err.to_string().contains("unknown field"));
        }
    }
-
-    #[test]
-    fn scoped_key_id_reads_the_body_first_and_falls_back_to_the_query() {
-        let uri: Uri = "/rustfs/admin/v3/kms/keys/delete?keyId=query-key"
-            .parse()
-            .expect("uri should parse");
-
-        assert_eq!(scoped_key_id(br#"{"key_id":"body-key"}"#, &uri).as_deref(), Some("body-key"));
-        assert_eq!(scoped_key_id(b"", &uri).as_deref(), Some("query-key"));
-
-        // The query aliases accepted by the legacy describe endpoint are not
-        // accepted here, because the handlers only execute on `keyId`.
-        let alias_uri: Uri = "/rustfs/admin/v3/kms/keys/delete?key-id=query-key"
-            .parse()
-            .expect("uri should parse");
-        assert_eq!(scoped_key_id(b"", &alias_uri), None);
-    }
-
-    /// A body the endpoint will reject leaves the request unscoped: the gate then
-    /// answers as it did before resource scoping and the request still fails on
-    /// its own parse error, so no key is operated on under that decision.
-    #[test]
-    fn scoped_key_id_is_absent_for_bodies_that_name_no_key() {
-        let uri: Uri = "/rustfs/admin/v3/kms/keys/delete".parse().expect("uri should parse");
-
-        assert_eq!(scoped_key_id(b"not json", &uri), None);
-        assert_eq!(scoped_key_id(br#"{"key_id":"" }"#, &uri).as_deref(), Some(""));
-        assert_eq!(scoped_key_id(b"{}", &uri).as_deref(), Some(""));
-        assert_eq!(scoped_key_id(b"", &uri), None);
-    }
-
-    /// Identity policy scoped to a single KMS key, or unscoped when `key_arn` is
-    /// `None` (the legacy action-only form that must keep matching every key).
-    fn kms_policy(key_arn: Option<&str>) -> Policy {
-        let resource = match key_arn {
-            Some(arn) => format!(r#","Resource":["{arn}"]"#),
-            None => String::new(),
-        };
-        let document = format!(r#"{{"Version":"2012-10-17","Statement":[{{"Effect":"Allow","Action":["kms:*"]{resource}}}]}}"#);
-
-        Policy::parse_config(document.as_bytes()).expect("kms policy should parse")
-    }
-
-    async fn policy_allows(policy: &Policy, action: Action, key_id: &str, is_owner: bool) -> bool {
-        let groups = None;
-        let conditions = HashMap::new();
-        let claims = HashMap::new();
-
-        policy
-            .is_allowed(&Args {
-                account: "kms-operator",
-                groups: &groups,
-                action,
-                // The admin gate scopes KMS requests through `AdminResourceScope::kms_key`,
-                // which puts the requested key id in the object slot with an empty bucket.
-                bucket: "",
-                conditions: &conditions,
-                is_owner,
-                object: key_id,
-                claims: &claims,
-                deny_only: false,
-            })
-            .await
-    }
-
-    fn describe_by_query(key_id: &str) -> String {
-        let uri: Uri = format!("/rustfs/admin/v3/kms/key/status?keyId={key_id}")
-            .parse()
-            .expect("uri should parse");
-        extract_key_id(&uri).unwrap_or_default()
-    }
-
-    fn describe_by_path(key_id: &str) -> String {
-        // `DescribeKmsKeyHandler` reads the router path parameter verbatim.
-        key_id.to_string()
-    }
-
-    fn generate_data_key_body(key_id: &str) -> String {
-        let body = format!(r#"{{"key_id":"{key_id}","key_spec":"Aes256"}}"#);
-        serde_json::from_str::<GenerateDataKeyApiRequest>(&body)
-            .expect("generate-data-key body should parse")
-            .key_id
-    }
-
-    fn key_id_body(key_id: &str) -> String {
-        let uri: Uri = "/rustfs/admin/v3/kms/keys".parse().expect("uri should parse");
-        scoped_key_id(format!(r#"{{"key_id":"{key_id}"}}"#).as_bytes(), &uri).unwrap_or_default()
-    }
-
-    fn key_id_query(key_id: &str) -> String {
-        let uri: Uri = format!("/rustfs/admin/v3/kms/keys?keyId={key_id}")
-            .parse()
-            .expect("uri should parse");
-        scoped_key_id(b"", &uri).unwrap_or_default()
-    }
-
-    /// Endpoint label, the action it gates on, and the resolution its handler
-    /// performs to obtain the key the gate is scoped to.
-    type SingleKeyEndpoint = (&'static str, Action, fn(&str) -> String);
-
-    /// Every KMS admin endpoint that acts on one key. Lifecycle endpoints share
-    /// `scoped_key_id` with the delete/cancel endpoints (see `kms_key_lifecycle`).
-    fn single_key_endpoints() -> Vec<SingleKeyEndpoint> {
-        vec![
-            (
-                "GET /v3/kms/key/status",
-                Action::KmsAction(KmsAction::DescribeKeyAction),
-                describe_by_query,
-            ),
-            (
-                "GET /v3/kms/keys/{key_id}",
-                Action::KmsAction(KmsAction::DescribeKeyAction),
-                describe_by_path,
-            ),
-            (
-                "POST /v3/kms/generate-data-key",
-                Action::KmsAction(KmsAction::GenerateDataKeyAction),
-                generate_data_key_body,
-            ),
-            ("DELETE /v3/kms/keys/delete", Action::KmsAction(KmsAction::DeleteKeyAction), key_id_body),
-            (
-                "DELETE /v3/kms/keys/delete?keyId=",
-                Action::KmsAction(KmsAction::DeleteKeyAction),
-                key_id_query,
-            ),
-            (
-                "POST /v3/kms/keys/cancel-deletion",
-                Action::KmsAction(KmsAction::DeleteKeyAction),
-                key_id_body,
-            ),
-            ("POST /v3/kms/keys/enable", Action::KmsAction(KmsAction::EnableKeyAction), key_id_body),
-            ("POST /v3/kms/keys/disable", Action::KmsAction(KmsAction::DisableKeyAction), key_id_body),
-            ("POST /v3/kms/keys/rotate", Action::KmsAction(KmsAction::RotateKeyAction), key_id_body),
-        ]
-    }
-
-    /// A policy limited to `key/A` must not authorize any single-key endpoint
-    /// against another key (rustfs/backlog#1582).
-    #[tokio::test]
-    async fn single_key_endpoints_reject_a_key_outside_the_policy_scope() {
-        let policy = kms_policy(Some("arn:aws:kms:::key/key-a"));
-
-        for (endpoint, action, resolve_key_id) in single_key_endpoints() {
-            assert!(
-                policy_allows(&policy, action, &resolve_key_id("key-a"), false).await,
-                "{endpoint} must stay allowed on the key the policy names"
-            );
-            assert!(
-                !policy_allows(&policy, action, &resolve_key_id("key-b"), false).await,
-                "{endpoint} must be denied on a key outside the policy scope"
-            );
-        }
-    }
-
-    /// Compatibility pin: a KMS statement without resources keeps matching every
-    /// key, and the owner short-circuit is unaffected by scoping.
-    #[tokio::test]
-    async fn unscoped_policies_and_owner_credentials_keep_matching_every_key() {
-        let unscoped = kms_policy(None);
-        let scoped = kms_policy(Some("arn:aws:kms:::key/key-a"));
-
-        for (endpoint, action, resolve_key_id) in single_key_endpoints() {
-            for key in ["key-a", "key-b"] {
-                assert!(
-                    policy_allows(&unscoped, action, &resolve_key_id(key), false).await,
-                    "{endpoint} must stay allowed on {key} for a resource-less KMS statement"
-                );
-                assert!(
-                    policy_allows(&scoped, action, &resolve_key_id(key), true).await,
-                    "{endpoint} must stay allowed on {key} for an owner credential"
-                );
-            }
-        }
-    }
-
-    /// The key the handler resolves also reaches Deny statements, so an explicit
-    /// Deny on one key survives an unscoped Allow.
-    #[tokio::test]
-    async fn explicit_deny_on_one_key_overrides_an_unscoped_allow() {
-        let document = r#"{"Version":"2012-10-17","Statement":[
-            {"Effect":"Allow","Action":["kms:*"]},
-            {"Effect":"Deny","Action":["kms:*"],"Resource":["arn:aws:kms:::key/key-b"]}
-        ]}"#;
-        let policy = Policy::parse_config(document.as_bytes()).expect("kms policy should parse");
-
-        for (endpoint, action, resolve_key_id) in single_key_endpoints() {
-            assert!(
-                policy_allows(&policy, action, &resolve_key_id("key-a"), false).await,
-                "{endpoint} must stay allowed on a key the Deny does not name"
-            );
-            assert!(
-                !policy_allows(&policy, action, &resolve_key_id("key-b"), false).await,
-                "{endpoint} must be denied on the key the Deny names"
-            );
-        }
-    }
-
-    /// The single-key handlers must reach the gate through the KMS-scoped entry
-    /// point; the endpoints that have no target key must not (passing an empty
-    /// scope there would be a no-op, but the unscoped call documents intent).
-    #[test]
-    fn single_key_handlers_authorize_through_the_kms_scoped_gate() {
-        let src = include_str!("kms_keys.rs");
-
-        for handler in [
-            "DescribeKeyHandler",
-            "GenerateDataKeyHandler",
-            "DeleteKmsKeyHandler",
-            "CancelKmsKeyDeletionHandler",
-            "DescribeKmsKeyHandler",
-        ] {
-            let block = operation_block(src, handler);
-            assert!(
-                block.contains("validate_admin_request_with_kms_key("),
-                "{handler} must scope its authorization to the requested key"
-            );
-        }
-
-        for handler in [
-            "CreateKeyHandler",
-            "ListKeysHandler",
-            "CreateKmsKeyHandler",
-            "ListKmsKeysHandler",
-        ] {
-            let block = operation_block(src, handler);
-            assert!(
-                !block.contains("validate_admin_request_with_kms_key("),
-                "{handler} has no target key and must not claim a KMS resource scope"
-            );
-        }
-    }
-
-    fn operation_block<'a>(src: &'a str, handler: &str) -> &'a str {
-        let marker = format!("impl Operation for {handler}");
-        let block = src.split_once(&marker).expect("handler impl should exist").1;
-        let end = ["\n/// ", "\n#[derive(", "\n#[cfg(test)]", "\npub struct "]
-            .into_iter()
-            .filter_map(|item| block.find(item))
-            .min()
-            .unwrap_or(block.len());
-        &block[..end]
-    }
 }

 /// List KMS keys (legacy endpoint)
@@ -777,31 +507,24 @@ impl Operation for GenerateDataKeyHandler {
        let (cred, owner) =
            check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &cred.access_key).await?;

-        // The body names the key this endpoint derives a data key from, so it has
-        // to be read before the gate runs. Input failures stay deferred until
-        // after the gate so an unauthorized caller still sees AccessDenied.
-        let parsed = req
-            .input
-            .store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE)
-            .await
-            .map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))
-            .and_then(|body| {
-                serde_json::from_slice::<GenerateDataKeyApiRequest>(&body)
-                    .map_err(|e| s3_error!(InvalidRequest, "invalid JSON: {}", e))
-            });
-
-        validate_admin_request_with_kms_key(
+        validate_admin_request(
            &req.headers,
            &cred,
            owner,
            false,
            kms_generate_data_key_actions(),
            req.extensions.get::<Option<RemoteAddr>>().and_then(|opt| opt.map(|a| a.0)),
-            parsed.as_ref().map(|request| request.key_id.as_str()).unwrap_or_default(),
        )
        .await?;

-        let request = parsed?;
+        let body = req
+            .input
+            .store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE)
+            .await
+            .map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;
+
+        let request: GenerateDataKeyApiRequest =
+            serde_json::from_slice(&body).map_err(|e| s3_error!(InvalidRequest, "invalid JSON: {}", e))?;

        let Some(service) = kms_encryption_service_from_context().await else {
            return Err(s3_error!(InternalError, "KMS service not initialized"));
@@ -1009,27 +732,21 @@ impl Operation for DeleteKmsKeyHandler {
        let (cred, owner) =
            check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &cred.access_key).await?;

-        // Read the body before the gate so the request can be scoped to the key it
-        // targets; the read failure is surfaced afterwards to keep AccessDenied
-        // ahead of input errors for callers that are not authorized at all.
-        let body = req.input.store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE).await;
-
-        validate_admin_request_with_kms_key(
+        validate_admin_request(
            &req.headers,
            &cred,
            owner,
            false,
            kms_delete_key_actions(),
            req.extensions.get::<Option<RemoteAddr>>().and_then(|opt| opt.map(|a| a.0)),
-            body.as_ref()
-                .ok()
-                .and_then(|body| scoped_key_id(body, &req.uri))
-                .as_deref()
-                .unwrap_or_default(),
        )
        .await?;

-        let body = body.map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;
+        let body = req
+            .input
+            .store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE)
+            .await
+            .map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;

        let request: DeleteKmsKeyRequest = if body.is_empty() {
            let query_params = extract_query_params(&req.uri);
@@ -1189,26 +906,21 @@ impl Operation for CancelKmsKeyDeletionHandler {
        let (cred, owner) =
            check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &cred.access_key).await?;

-        // Same ordering as the delete endpoint: the target key is resolved before
-        // the gate, the read failure only after it.
-        let body = req.input.store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE).await;
-
-        validate_admin_request_with_kms_key(
+        validate_admin_request(
            &req.headers,
            &cred,
            owner,
            false,
            kms_delete_key_actions(),
            req.extensions.get::<Option<RemoteAddr>>().and_then(|opt| opt.map(|a| a.0)),
-            body.as_ref()
-                .ok()
-                .and_then(|body| scoped_key_id(body, &req.uri))
-                .as_deref()
-                .unwrap_or_default(),
        )
        .await?;

-        let body = body.map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;
+        let body = req
+            .input
+            .store_all_limited(MAX_ADMIN_REQUEST_BODY_SIZE)
+            .await
+            .map_err(|e| s3_error!(InvalidRequest, "failed to read request body: {}", e))?;

        let request: CancelKmsKeyDeletionRequest = if body.is_empty() {
            let query_params = extract_query_params(&req.uri);
@@ -1468,14 +1180,13 @@ impl Operation for DescribeKmsKeyHandler {
        let (cred, owner) =
            check_key_valid(get_session_token(&req.uri, &req.headers).unwrap_or_default(), &cred.access_key).await?;

-        validate_admin_request_with_kms_key(
+        validate_admin_request(
            &req.headers,
            &cred,
            owner,
            false,
            kms_describe_key_actions(),
            req.extensions.get::<Option<RemoteAddr>>().and_then(|opt| opt.map(|a| a.0)),
-            params.get("key_id").unwrap_or_default(),
        )
        .await?;

@@ -183,7 +183,7 @@ async fn handle_assume_role(
            conditions: &conditions,
            is_owner: owner,
            claims: cred.claims_or_empty(),
-            deny_only: true,
+            deny_only: false,
            bucket: "",
            object: "",
        })
@@ -12,32 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#[cfg(all(feature = "hotpath", feature = "hotpath-alloc"))]
-use std::alloc::{GlobalAlloc, Layout};
-
-#[cfg(all(feature = "hotpath", feature = "hotpath-alloc"))]
-#[derive(Default)]
-struct DefaultMiMalloc;
-
-#[cfg(all(feature = "hotpath", feature = "hotpath-alloc"))]
-// SAFETY: allocation and deallocation are forwarded unchanged to MiMalloc, so
-// MiMalloc's GlobalAlloc guarantees apply to every returned pointer and layout.
-#[allow(unsafe_code)]
-unsafe impl GlobalAlloc for DefaultMiMalloc {
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // SAFETY: the caller upholds GlobalAlloc's contract for layout.
-        unsafe { mimalloc::MiMalloc.alloc(layout) }
-    }
-
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        // SAFETY: ptr and layout came from this allocator and are forwarded unchanged.
-        unsafe { mimalloc::MiMalloc.dealloc(ptr, layout) }
-    }
-}
-
 #[cfg(all(feature = "hotpath", feature = "hotpath-alloc"))]
 #[global_allocator]
-static GLOBAL: hotpath::CountingAllocator<DefaultMiMalloc> = hotpath::CountingAllocator::new();
+static GLOBAL: hotpath::CountingAllocator = hotpath::CountingAllocator::new();

 #[cfg(not(all(feature = "hotpath", feature = "hotpath-alloc")))]
 #[global_allocator]
@@ -48,15 +25,3 @@ fn main() {

    rustfs::startup_entrypoint::run_process();
 }
-
-#[cfg(all(test, feature = "hotpath", feature = "hotpath-alloc"))]
-mod tests {
-    #[test]
-    #[allow(unsafe_code)]
-    fn hotpath_allocator_uses_mimalloc() {
-        let allocation = Box::new([0_u8; 64]);
-
-        // SAFETY: the live Box pointer is valid to inspect for heap ownership.
-        assert!(unsafe { libmimalloc_sys::mi_is_in_heap_region(allocation.as_ptr().cast()) });
-    }
-}
@@ -18,10 +18,7 @@ use super::{
    collect_cluster_read_health_report, collect_cluster_write_health_report, collect_node_readiness_report,
 };
 use http::{Method, StatusCode};
-use rustfs_kms::ProbeStatus;
-use rustfs_kms::probe::{DEFAULT_PROBE_INTERVAL, ENV_KMS_PROBE_INTERVAL_SECS, MIN_PROBE_INTERVAL};
 use serde_json::{Value, json};
-use std::time::Duration;

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct HealthCheckState {
@@ -125,86 +122,6 @@ pub(crate) fn health_minimal_response_enabled() -> bool {
    )
 }

-/// Consecutive failed probe rounds tolerated before readiness withdraws the KMS.
-///
-/// One failed round is routinely an external hiccup — a Vault leader election, a
-/// dropped connection, a rotated token — and reporting not ready on the first one
-/// would turn that hiccup into a rolling restart of every node that shares the
-/// backend. Requiring the failure to survive three rounds keeps the signal while
-/// costing at most three intervals of detection latency.
-const KMS_PROBE_FAILURE_THRESHOLD: u32 = 3;
-
-/// Probe rounds a snapshot may age before readiness stops acting on it.
-///
-/// Expressed in rounds rather than seconds so the bound follows the configured
-/// interval: a deployment probing every ten minutes must not read every snapshot
-/// as stale. Three rounds absorbs a round that overruns its slot or a worker that
-/// misses a tick without discarding a signal that is merely late.
-const KMS_PROBE_STALENESS_ROUNDS: u32 = 3;
-
-/// Upper bound on the age of a probe snapshot that readiness is willing to act on.
-pub(crate) fn kms_probe_staleness_limit() -> Duration {
-    configured_kms_probe_interval().saturating_mul(KMS_PROBE_STALENESS_ROUNDS)
-}
-
-/// Probe interval currently in force.
-///
-/// Readiness reads the same variable as the probe worker because it only needs
-/// the value to scale [`kms_probe_staleness_limit`]; the worker owns the interval
-/// itself and keeps its parsing private.
-fn configured_kms_probe_interval() -> Duration {
-    kms_probe_interval_from_env(std::env::var(ENV_KMS_PROBE_INTERVAL_SECS).ok().as_deref())
-}
-
-/// Interval implied by a raw environment value, mirroring the worker's own rules:
-/// unset or unparsable means the default, and anything below the floor is raised
-/// to it. `0` disables the probe, which publishes no snapshot at all — the bound
-/// is then never consulted, so the default stands in.
-fn kms_probe_interval_from_env(value: Option<&str>) -> Duration {
-    let Some(seconds) = value.and_then(|value| value.trim().parse::<u64>().ok()) else {
-        return DEFAULT_PROBE_INTERVAL;
-    };
-    if seconds == 0 {
-        return DEFAULT_PROBE_INTERVAL;
-    }
-    Duration::from_secs(seconds).max(MIN_PROBE_INTERVAL)
-}
-
-/// KMS readiness verdict from the service status bit and the background probe.
-///
-/// Reads only the published snapshot and never calls the backend: a readiness
-/// request must not become load on a KMS that is already struggling, and a
-/// Kubernetes probe timing out on an external dependency is how one slow Vault
-/// becomes a fleet-wide restart.
-///
-/// The probe can only ever withdraw readiness from a service that is otherwise
-/// running, and only on evidence that is both fresh and repeated. Everything the
-/// probe cannot speak to — no worker (a backend without a data key round trip, or
-/// the probe disabled), no completed round yet, or a snapshot older than
-/// `staleness_limit` — leaves the status-bit verdict standing rather than
-/// reporting a failure nobody observed.
-pub(crate) fn kms_ready_from_probe(service_running: bool, probe: Option<&ProbeStatus>, staleness_limit: Duration) -> bool {
-    if !service_running {
-        return false;
-    }
-
-    let Some(probe) = probe else {
-        return true;
-    };
-
-    let Some(age) = probe.last_round_age() else {
-        return true;
-    };
-
-    if age > staleness_limit {
-        return true;
-    }
-
-    // Every non-failure result resets the counter, so an unsupported backend or a
-    // recovered round can never reach the threshold.
-    probe.consecutive_failures < KMS_PROBE_FAILURE_THRESHOLD
-}
-
 pub(crate) fn build_component_details(
    storage_ready: bool,
    iam_ready: bool,
@@ -360,177 +277,3 @@ pub(crate) fn build_health_payload(ctx: HealthPayloadContext<'_>) -> Value {

    payload
 }
-
-#[cfg(test)]
-mod tests {
-    use super::super::readiness::DependencyReadiness;
-    use super::*;
-    use rustfs_kms::{ProbeFailureKind, ProbeResult};
-    use serial_test::serial;
-    use temp_env::with_var;
-    use tokio::time::Instant;
-
-    const STALENESS_LIMIT: Duration = Duration::from_secs(180);
-
-    fn snapshot(result: ProbeResult, last_round_at: Option<Instant>, consecutive_failures: u32) -> ProbeStatus {
-        ProbeStatus {
-            result,
-            last_round_at,
-            last_success_at: last_round_at.filter(|_| result == ProbeResult::Success),
-            last_success_unix_secs: None,
-            consecutive_failures,
-        }
-    }
-
-    fn ready_report() -> DependencyReadinessReport {
-        DependencyReadinessReport {
-            readiness: DependencyReadiness {
-                storage_ready: true,
-                iam_ready: true,
-                lock_quorum_ready: true,
-                peer_health_ready: true,
-            },
-            degraded_reasons: Vec::new(),
-        }
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn a_fresh_successful_round_keeps_the_service_ready() {
-        let round_at = Instant::now();
-        tokio::time::advance(Duration::from_secs(1)).await;
-
-        let status = snapshot(ProbeResult::Success, Some(round_at), 0);
-        assert!(kms_ready_from_probe(true, Some(&status), STALENESS_LIMIT));
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn a_single_failed_round_does_not_withdraw_readiness() {
-        let round_at = Instant::now();
-        tokio::time::advance(Duration::from_secs(1)).await;
-
-        let status = snapshot(
-            ProbeResult::Failure(ProbeFailureKind::Decrypt),
-            Some(round_at),
-            KMS_PROBE_FAILURE_THRESHOLD - 1,
-        );
-        assert!(kms_ready_from_probe(true, Some(&status), STALENESS_LIMIT));
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn failures_reaching_the_threshold_withdraw_readiness() {
-        let round_at = Instant::now();
-        tokio::time::advance(Duration::from_secs(1)).await;
-
-        let status = snapshot(
-            ProbeResult::Failure(ProbeFailureKind::Generate),
-            Some(round_at),
-            KMS_PROBE_FAILURE_THRESHOLD,
-        );
-        assert!(!kms_ready_from_probe(true, Some(&status), STALENESS_LIMIT));
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn a_stale_snapshot_falls_back_to_the_status_bit() {
-        let round_at = Instant::now();
-        tokio::time::advance(STALENESS_LIMIT + Duration::from_secs(1)).await;
-
-        let status = snapshot(
-            ProbeResult::Failure(ProbeFailureKind::Mismatch),
-            Some(round_at),
-            KMS_PROBE_FAILURE_THRESHOLD * 10,
-        );
-        assert!(
-            kms_ready_from_probe(true, Some(&status), STALENESS_LIMIT),
-            "a snapshot nobody refreshed is unknown, not a failure"
-        );
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn an_unsupported_backend_is_not_a_failure() {
-        let round_at = Instant::now();
-        tokio::time::advance(Duration::from_secs(1)).await;
-
-        let status = snapshot(ProbeResult::Unsupported, Some(round_at), 0);
-        assert!(kms_ready_from_probe(true, Some(&status), STALENESS_LIMIT));
-    }
-
-    #[tokio::test(start_paused = true)]
-    async fn a_stopped_service_stays_not_ready_despite_a_successful_round() {
-        let round_at = Instant::now();
-        tokio::time::advance(Duration::from_secs(1)).await;
-
-        let status = snapshot(ProbeResult::Success, Some(round_at), 0);
-        assert!(!kms_ready_from_probe(false, Some(&status), STALENESS_LIMIT));
-    }
-
-    #[test]
-    fn a_service_without_a_probe_keeps_the_status_bit_verdict() {
-        assert!(kms_ready_from_probe(true, None, STALENESS_LIMIT));
-        assert!(!kms_ready_from_probe(false, None, STALENESS_LIMIT));
-    }
-
-    #[test]
-    fn a_probe_with_no_completed_round_keeps_the_service_ready() {
-        let status = snapshot(ProbeResult::Pending, None, 0);
-        assert!(kms_ready_from_probe(true, Some(&status), STALENESS_LIMIT));
-    }
-
-    #[test]
-    fn the_probe_interval_follows_the_worker_parsing_rules() {
-        assert_eq!(kms_probe_interval_from_env(None), DEFAULT_PROBE_INTERVAL);
-        assert_eq!(kms_probe_interval_from_env(Some("not-a-number")), DEFAULT_PROBE_INTERVAL);
-        assert_eq!(kms_probe_interval_from_env(Some("0")), DEFAULT_PROBE_INTERVAL);
-        assert_eq!(kms_probe_interval_from_env(Some(" 600 ")), Duration::from_secs(600));
-        assert_eq!(kms_probe_interval_from_env(Some("1")), MIN_PROBE_INTERVAL);
-    }
-
-    #[test]
-    #[serial]
-    fn the_staleness_bound_spans_three_probe_rounds() {
-        with_var(ENV_KMS_PROBE_INTERVAL_SECS, Some("30"), || {
-            assert_eq!(kms_probe_staleness_limit(), Duration::from_secs(90));
-        });
-    }
-
-    /// Flipping this default is a deployment behaviour change, not a code
-    /// change: it would start failing readiness on clusters that never asked
-    /// for the KMS to gate it. Pinned at compile time so the constant cannot
-    /// drift without this line being edited too.
-    const _: () = assert!(!rustfs_config::DEFAULT_HEALTH_COMPAT_KMS_READY_CHECK_ENABLE);
-
-    #[test]
-    #[serial]
-    fn a_withdrawn_kms_degrades_the_readiness_response() {
-        with_var(rustfs_config::ENV_HEALTH_MINIMAL_RESPONSE_ENABLE, Some("false"), || {
-            let report = ready_report();
-            let parts = build_health_response_parts(
-                Method::GET,
-                HealthProbe::Readiness,
-                Some(&report),
-                "rustfs-endpoint",
-                None,
-                Some(false),
-            );
-
-            assert_eq!(parts.status_code, StatusCode::SERVICE_UNAVAILABLE);
-            let payload = parts.payload.expect("GET should include payload");
-            assert_eq!(payload["details"]["kms"]["ready"], false);
-            assert_eq!(payload["degradedReasons"], json!(["kms_not_ready"]));
-        });
-    }
-
-    #[test]
-    #[serial]
-    fn a_disabled_check_leaves_the_readiness_response_untouched() {
-        with_var(rustfs_config::ENV_HEALTH_MINIMAL_RESPONSE_ENABLE, Some("false"), || {
-            let report = ready_report();
-            let parts =
-                build_health_response_parts(Method::GET, HealthProbe::Readiness, Some(&report), "rustfs-endpoint", None, None);
-
-            assert_eq!(parts.status_code, StatusCode::OK);
-            let payload = parts.payload.expect("GET should include payload");
-            assert!(payload["details"].get("kms").is_none());
-            assert_eq!(payload["degradedReasons"], json!([]));
-        });
-    }
-}
@@ -23,7 +23,6 @@ use crate::server::{
    MINIO_ADMIN_V3_PREFIX, MINIO_HEALTH_CLUSTER_PATH, MINIO_HEALTH_CLUSTER_READ_PATH, MINIO_HEALTH_LIVE_PATH,
    MINIO_HEALTH_READY_PATH, PROFILE_CPU_PATH, PROFILE_MEMORY_PATH, RPC_PREFIX, RUSTFS_ADMIN_PREFIX, active_http_requests,
    build_health_response_parts, collect_probe_readiness, has_path_prefix, is_admin_path, is_table_catalog_path,
-    kms_probe_staleness_limit, kms_ready_from_probe,
 };
 use crate::storage_api::server::layer::apply_cors_headers;
 use crate::storage_api::server::layer::request_context::{RequestContext, extract_request_id_from_headers, spawn_traced};
@@ -1282,9 +1281,7 @@ async fn health_kms_ready() -> bool {
        return true;
    };

-    let service_running = matches!(service_manager.get_status().await, rustfs_kms::KmsServiceStatus::Running);
-    let probe_status = service_manager.probe_status();
-    kms_ready_from_probe(service_running, probe_status.as_deref(), kms_probe_staleness_limit())
+    matches!(service_manager.get_status().await, rustfs_kms::KmsServiceStatus::Running)
 }

 async fn build_public_health_http_response<RestBody, GrpcBody>(
@@ -55,10 +55,7 @@ pub(crate) use health::{
    HealthPayloadContext, HealthReadinessSource, build_component_details, build_health_payload, health_check_state,
    readiness_source_for_probe,
 };
-pub(crate) use health::{
-    HealthProbe, build_health_response_parts, collect_probe_readiness, kms_probe_staleness_limit, kms_ready_from_probe,
-    probe_from_path,
-};
+pub(crate) use health::{HealthProbe, build_health_response_parts, collect_probe_readiness, probe_from_path};
 pub(crate) use http::HeaderMapCarrier;
 pub(crate) use http::active_http_requests;
 pub(crate) use layer::{RequestContextLayer, is_sts_query_request};
@@ -1,83 +0,0 @@
-#!/usr/bin/env bash
-# ci.yml's pull_request paths-ignore and ci-docs-only.yml's paths must be equal.
-#
-# ci-docs-only.yml exists to report the required checks for pull requests that
-# ci.yml skips. The two lists are the complement of each other, so any drift
-# breaks one of two ways, both silent:
-#
-#   - an entry only in ci.yml's paths-ignore: a PR touching only those files
-#     triggers neither workflow, nobody reports "Test and Lint" or "Quick
-#     Checks", and the PR waits on a required check forever;
-#   - an entry only in ci-docs-only.yml's paths: both workflows run, which is
-#     merely wasteful — but it also means the lists no longer describe the same
-#     intent, and the next edit is made against a wrong assumption.
-#
-# The push paths-ignore in ci.yml is deliberately NOT compared: no required
-# check is reported for push events, so it does not have to pair with anything.
-#
-# Also asserts ci-docs-only.yml still declares both companion job names, since a
-# rename there produces exactly the permanent-pending failure above.
-#
-# Usage: scripts/check_ci_paths_sync.sh
-set -euo pipefail
-
-cd "$(dirname "$0")/.."
-
-CI=".github/workflows/ci.yml"
-DOCS=".github/workflows/ci-docs-only.yml"
-
-# Print the quoted list items that follow $2 within the block introduced by $1.
-# Both files keep these as a flat list of quoted scalars, so no YAML parser is
-# needed and the script stays dependency-free like its check_* siblings.
-extract() {
-    local file="$1" event="$2" key="$3"
-    awk -v event="$event" -v key="$key" '
-        $0 ~ "^  " event ":[[:space:]]*$" { in_event = 1; next }
-        in_event && /^  [a-z_]+:[[:space:]]*$/ { in_event = 0 }
-        in_event && $0 ~ "^    " key ":[[:space:]]*$" { in_list = 1; next }
-        in_list {
-            if ($0 ~ /^      - /) {
-                item = $0
-                sub(/^      - /, "", item)
-                gsub(/^"|"$/, "", item)
-                print item
-                next
-            }
-            if ($0 !~ /^[[:space:]]*#/ && $0 !~ /^[[:space:]]*$/) in_list = 0
-        }
-    ' "$file" | sort
-}
-
-ci_list="$(extract "$CI" "pull_request" "paths-ignore")"
-docs_list="$(extract "$DOCS" "pull_request" "paths")"
-
-if [ -z "$ci_list" ] || [ -z "$docs_list" ]; then
-    echo "ERROR: could not read one of the path lists — did the file structure change?" >&2
-    echo "  $CI pull_request.paths-ignore: $(printf '%s' "$ci_list" | grep -c . || true) entries" >&2
-    echo "  $DOCS pull_request.paths: $(printf '%s' "$docs_list" | grep -c . || true) entries" >&2
-    exit 1
-fi
-
-status=0
-
-if ! diff_out="$(diff <(printf '%s\n' "$ci_list") <(printf '%s\n' "$docs_list"))"; then
-    echo "ERROR: $CI pull_request paths-ignore and $DOCS paths have drifted." >&2
-    echo "  '<' is only in $CI, '>' is only in $DOCS:" >&2
-    printf '%s\n' "$diff_out" | sed 's/^/    /' >&2
-    status=1
-fi
-
-for job_name in "Test and Lint" "Quick Checks"; do
-    if ! grep -q "name: ${job_name}\$" "$DOCS"; then
-        echo "ERROR: $DOCS no longer declares a job named '${job_name}'." >&2
-        echo "  It is a required status check; without a companion job here, a" >&2
-        echo "  docs-only PR waits on it forever." >&2
-        status=1
-    fi
-done
-
-if [ "$status" -ne 0 ]; then
-    exit 1
-fi
-
-echo "OK: ci.yml and ci-docs-only.yml path lists agree ($(printf '%s\n' "$ci_list" | wc -l | tr -d ' ') entries)"
@@ -27,9 +27,6 @@ checked_files=(
  "rustfs/src/storage/rpc/http_service.rs"
  "rustfs/src/storage/rpc/node_service.rs"
  "crates/kms/src/config.rs"
-  "crates/kms/src/audit.rs"
-  "crates/kms/src/manager.rs"
-  "crates/kms/src/deletion_worker.rs"
  "crates/audit/src/pipeline.rs"
  "crates/audit/src/system.rs"
  "crates/audit/src/global.rs"
@@ -1,41 +0,0 @@
-#!/usr/bin/env bash
-# The io_uring CI lane runs `cargo test -p rustfs-ecstore --lib uring_`.
-#
-# `--lib` is there to avoid compiling and linking the 7 integration binaries
-# under crates/ecstore/tests/, which selected zero tests for this filter. That is
-# only safe while it stays true: add a matching test under tests/ and `--lib`
-# would skip it silently, with CI staying green — the failure mode is invisible,
-# so it is asserted here instead.
-#
-# The pattern must use the same `uring_` substring semantics as libtest, which
-# also matches names containing `during_`. Narrowing it to `io_uring` would make
-# this guard disagree with the filter it is protecting.
-#
-# Usage: scripts/check_uring_lane_lib_only.sh
-set -euo pipefail
-
-cd "$(dirname "$0")/.."
-
-TESTS_DIR="crates/ecstore/tests"
-
-if [ ! -d "$TESTS_DIR" ]; then
-    echo "OK: $TESTS_DIR does not exist; nothing for --lib to miss"
-    exit 0
-fi
-
-hits="$(grep -rEn '^[[:space:]]*(pub[[:space:]]+)?(async[[:space:]]+)?fn[[:space:]]+[A-Za-z0-9_]*uring_' \
-        "$TESTS_DIR" || true)"
-
-if [ -n "$hits" ]; then
-    echo "ERROR: test functions matching the 'uring_' substring found under $TESTS_DIR:" >&2
-    printf '%s\n' "$hits" | sed 's/^/  /' >&2
-    echo "" >&2
-    echo "The io_uring lane in .github/workflows/ci.yml uses --lib, so these would" >&2
-    echo "never run and CI would stay green. Pick one:" >&2
-    echo "  - move them into a #[cfg(test)] mod under crates/ecstore/src, or" >&2
-    echo "  - drop --lib from that step (and pay the link cost for all 7 binaries), or" >&2
-    echo "  - add an explicit --test <name> for the binary and update this script." >&2
-    exit 1
-fi
-
-echo "OK: no 'uring_'-matching test functions under $TESTS_DIR; --lib is safe"
@@ -1,107 +0,0 @@
-#!/usr/bin/env bash
-# Background resource sampler for the Test and Lint lane (issue #5394).
-#
-# The post-mortem `pgrep` in ci.yml runs only after `timeout` has already TERM'd
-# the whole cargo process group, so it can never name a wedged process. This
-# samples every 60s instead; the last samples before a timeout show what was
-# stuck — rustc, the linker, a build script, memory pressure.
-#
-# WHY THE CGROUP READINGS MATTER
-#
-# The runners are ARC (Actions Runner Controller) pods, so /proc/loadavg,
-# /proc/pressure/*, `free` and `df` are all *node*-level: they include every
-# other runner pod scheduled on the same Kubernetes node. A sample showing high
-# I/O pressure says nothing about whether *this* job caused it. Measured
-# evidence: one sample reported loadavg 6.67 with 832 threads node-wide while
-# `ps` inside the pod showed about 10 processes.
-#
-# Only the /sys/fs/cgroup/* values and `ps` are attributable to this job, so
-# those are what any CARGO_BUILD_JOBS experiment must be judged on. The
-# node-level readings are kept — co-tenancy is itself a real cause of stalls,
-# and a 9m57s `git checkout` was traced to it — but labelled NODE-LEVEL so
-# nobody reads them as this pod's own load.
-#
-# Usage:
-#   scripts/ci/resource_sampler.sh start <phase>   # e.g. clippy, nextest, doctest
-#   scripts/ci/resource_sampler.sh stop
-#
-# Safe to call `stop` when nothing is running, and safe to `start` a new phase
-# while another is sampling — the previous one is stopped first. Never fails the
-# calling step: this is diagnostics, not a gate.
-set -uo pipefail
-
-# GNU date on the runners; the fallback keeps local smoke tests on macOS quiet.
-now() { date --utc --iso-8601=seconds 2>/dev/null || date -u +%Y-%m-%dT%H:%M:%S+00:00; }
-
-LOG_DIR="artifacts/test-and-lint"
-LOG_FILE="${LOG_DIR}/sampler.log"
-PID_FILE="${LOG_DIR}/.sampler.pid"
-INTERVAL="${SAMPLER_INTERVAL_SECS:-60}"
-
-stop_sampler() {
-    [ -f "$PID_FILE" ] || return 0
-    local pid
-    pid="$(cat "$PID_FILE" 2>/dev/null || true)"
-    if [ -n "${pid:-}" ]; then
-        kill "$pid" 2>/dev/null || true
-    fi
-    rm -f "$PID_FILE"
-}
-
-sample_once() {
-    echo "=== $(now)"
-
-    # Attributable to this pod: cgroup v2 accounting and our own process table.
-    echo "--- POD cpu/mem limits"
-    grep -H . /sys/fs/cgroup/cpu.max /sys/fs/cgroup/memory.max \
-              /sys/fs/cgroup/memory.peak /sys/fs/cgroup/memory.current 2>/dev/null || true
-    echo "--- POD pressure (cgroup v2, this pod only)"
-    grep -H . /sys/fs/cgroup/cpu.pressure /sys/fs/cgroup/io.pressure \
-              /sys/fs/cgroup/memory.pressure 2>/dev/null || true
-    echo "--- POD nproc"; nproc 2>/dev/null || true
-
-    # NODE-LEVEL: shared with every other runner pod on this Kubernetes node.
-    # Useful for spotting co-tenancy, useless for attributing load to this job.
-    echo "--- NODE-LEVEL load (shared with co-tenant runners)"; cat /proc/loadavg 2>/dev/null || true
-    echo "--- NODE-LEVEL psi (shared with co-tenant runners)"
-    grep -H . /proc/pressure/* 2>/dev/null || true
-    echo "--- NODE-LEVEL mem (shared with co-tenant runners)"; free -m 2>/dev/null || true
-    echo "--- NODE-LEVEL disk (shared with co-tenant runners)"
-    df -h / /home/runner 2>/dev/null || df -h / 2>/dev/null || true
-
-    echo "--- top-rss"
-    ps -eo pid,ppid,stat,etime,rss,pcpu,args --sort=-rss 2>/dev/null | head -15 || true
-    echo "--- build/test processes"
-    ps -eo pid,ppid,stat,etime,rss,pcpu,args 2>/dev/null \
-        | grep -E '[c]argo|[r]ustc|[n]extest|[c]ollect2|rust-ll[d]|[b]uild-script|deps[/]' || true
-    echo "--- d-state (uninterruptible IO)"
-    ps -eo pid,stat,etime,args 2>/dev/null | awk 'NR > 1 && $2 ~ /D/' || true
-    echo
-}
-
-case "${1:-}" in
-    start)
-        phase="${2:-unknown}"
-        mkdir -p "$LOG_DIR"
-        stop_sampler
-        {
-            echo "--- phase=${phase} started_at=$(now) runner=${RUNNER_NAME:-unknown}"
-        } >> "$LOG_FILE" 2>&1 || true
-        (
-            while true; do
-                sample_once >> "$LOG_FILE" 2>&1 || true
-                sleep "$INTERVAL"
-            done
-        ) &
-        echo $! > "$PID_FILE"
-        ;;
-    stop)
-        stop_sampler
-        ;;
-    *)
-        echo "usage: $0 start <phase> | stop" >&2
-        exit 2
-        ;;
-esac
-
-exit 0
@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-# Every `uses: ./.github/actions/setup` must state `cache-save-if` explicitly.
-#
-# The composite action's default is "false" (fail-safe: a forgotten input costs
-# a cold cache, not a slice of the repository-wide 10GB Actions cache quota).
-# But a silent default in either direction is how audit.yml ended up saving a
-# ~843MB PR-scoped entry on every dependency change, evicting the main-scoped
-# lanes that the expensive jobs restore from. Requiring the input to be spelled
-# out keeps the decision visible in review.
-#
-# Usage: scripts/security/check_cache_save_if.sh
-set -euo pipefail
-
-cd "$(dirname "$0")/../.."
-
-status=0
-
-for file in .github/workflows/*.yml .github/workflows/*.yaml; do
-    [ -e "$file" ] || continue
-
-    # Walk the file, and for every `uses: ./.github/actions/setup` scan the rest
-    # of that step for cache-save-if. `uses:` and `with:` are siblings at the
-    # same indentation, so the step ends only at a line indented *less* than the
-    # `uses:` line (the next `- name:` item, or a dedent out of the steps list).
-    awk -v file="$file" '
-        function flush() {
-            if (pending && !found) {
-                printf "%s:%d: `uses: ./.github/actions/setup` without an explicit `cache-save-if:`\n", file, uses_line > "/dev/stderr"
-                bad++
-            }
-            pending = 0; found = 0
-        }
-        {
-            line = $0
-            sub(/[[:space:]]+$/, "", line)
-            if (line ~ /^[[:space:]]*#/ || line ~ /^[[:space:]]*$/) next
-
-            match(line, /^[[:space:]]*/)
-            indent = RLENGTH
-
-            if (pending && indent < uses_indent) flush()
-
-            if (line ~ /uses:[[:space:]]*\.\/\.github\/actions\/setup[[:space:]]*$/) {
-                flush()
-                pending = 1; found = 0
-                uses_indent = indent
-                uses_line = NR
-                next
-            }
-
-            if (pending && line ~ /^[[:space:]]*cache-save-if:/) found = 1
-        }
-        END { flush(); exit (bad > 0) }
-    ' "$file" || status=1
-done
-
-if [ "$status" -ne 0 ]; then
-    echo "" >&2
-    echo "Add an explicit cache-save-if to each call above, e.g." >&2
-    echo "    cache-save-if: \${{ github.ref == 'refs/heads/main' }}   # this lane owns the key" >&2
-    echo "    cache-save-if: 'false'                                   # this lane only reads it" >&2
-    echo "Exactly one lane per shared-key may save; see rustfs/backlog#1600." >&2
-    exit 1
-fi
-
-echo "OK: every ./.github/actions/setup call states cache-save-if explicitly"
@@ -1,65 +0,0 @@
-#!/usr/bin/env bash
-# Every job that occupies a runner must declare timeout-minutes.
-#
-# GitHub's default is 360 minutes. This repository has a history of runners
-# stalling intermittently (#5394) and of a plain `git checkout` taking 9m57s
-# under node-level I/O contention, so an undeclared timeout means one wedged job
-# can hold a runner for six hours out of a pool of roughly 15-21.
-#
-# Only jobs with `runs-on` are checked: a job that calls a reusable workflow has
-# no runner of its own and cannot declare a timeout.
-#
-# Usage: scripts/security/check_job_timeouts.sh
-set -euo pipefail
-
-cd "$(dirname "$0")/../.."
-
-status=0
-
-for file in .github/workflows/*.yml .github/workflows/*.yaml; do
-    [ -e "$file" ] || continue
-
-    awk -v file="$file" '
-        function flush() {
-            if (job != "" && has_runs_on && !has_timeout) {
-                printf "%s:%d: job `%s` has runs-on but no timeout-minutes\n", file, job_line, job > "/dev/stderr"
-                bad++
-            }
-            job = ""; has_runs_on = 0; has_timeout = 0
-        }
-        /^jobs:[[:space:]]*$/ { in_jobs = 1; next }
-        {
-            line = $0
-            sub(/[[:space:]]+$/, "", line)
-            if (line ~ /^[[:space:]]*#/ || line ~ /^[[:space:]]*$/) next
-
-            # A non-indented key ends the jobs mapping.
-            if (in_jobs && line !~ /^[[:space:]]/) { flush(); in_jobs = 0 }
-            if (!in_jobs) next
-
-            if (line ~ /^  [a-zA-Z0-9_-]+:[[:space:]]*$/) {
-                flush()
-                job = line
-                sub(/^[[:space:]]*/, "", job)
-                sub(/:.*$/, "", job)
-                job_line = NR
-                next
-            }
-            if (job == "") next
-            if (line ~ /^    runs-on:/) has_runs_on = 1
-            if (line ~ /^    timeout-minutes:/) has_timeout = 1
-        }
-        END { flush(); exit (bad > 0) }
-    ' "$file" || status=1
-done
-
-if [ "$status" -ne 0 ]; then
-    echo "" >&2
-    echo "Add timeout-minutes to each job above. Rough budgets used in this repo:" >&2
-    echo "  10  echo-only and guard-script jobs" >&2
-    echo "  30  jobs that call the GitHub API, upload assets, or push over the network" >&2
-    echo "  90+ anything using ./.github/actions/setup (cold cache restore alone is 11-21 min)" >&2
-    exit 1
-fi
-
-echo "OK: every job with runs-on declares timeout-minutes"
@@ -1,72 +0,0 @@
-#!/usr/bin/env bash
-# Every actions/checkout must set persist-credentials: false, or carry an
-# explicit exemption comment.
-#
-# By default checkout writes its token into .git/config as an http extraheader,
-# where it stays for the rest of the job. On this repository that matters more
-# than usual: pull_request jobs run on self-hosted runners and execute the PR's
-# own build.rs, proc-macros and tests, any of which can read that file. The
-# Test and Lint job additionally holds actions: write, so its token can cancel
-# runs and delete the Actions caches the whole pipeline depends on.
-#
-# A checkout is exempt only when the token IS the credential the job needs —
-# helm-package pushes to rustfs/helm with it. Mark those with a comment
-# containing `persist-credentials-exempt` inside the step, so the decision is
-# visible in review instead of being an omission.
-#
-# Usage: scripts/security/check_persist_credentials.sh
-set -euo pipefail
-
-cd "$(dirname "$0")/../.."
-
-status=0
-
-for file in .github/workflows/*.yml .github/workflows/*.yaml .github/actions/*/action.yml; do
-    [ -e "$file" ] || continue
-
-    awk -v file="$file" '
-        function flush() {
-            if (pending && !found_pc && !found_exempt) {
-                printf "%s:%d: actions/checkout without `persist-credentials: false`\n", file, checkout_line > "/dev/stderr"
-                bad++
-            }
-            pending = 0; found_pc = 0; found_exempt = 0
-        }
-        {
-            line = $0
-            sub(/[[:space:]]+$/, "", line)
-            if (line ~ /^[[:space:]]*$/) next
-
-            match(line, /^[[:space:]]*/)
-            indent = RLENGTH
-
-            if (line ~ /uses:[[:space:]]*actions\/checkout@/) {
-                flush()
-                pending = 1
-                # `- uses:` puts the step keys two columns right of the dash.
-                checkout_indent = (line ~ /^[[:space:]]*- /) ? indent + 2 : indent
-                checkout_line = NR
-                next
-            }
-
-            if (!pending) next
-            if (indent < checkout_indent) { flush(); next }
-            if (line ~ /persist-credentials:/) found_pc = 1
-            if (line ~ /persist-credentials-exempt/) found_exempt = 1
-        }
-        END { flush(); exit (bad > 0) }
-    ' "$file" || status=1
-done
-
-if [ "$status" -ne 0 ]; then
-    echo "" >&2
-    echo "Add to each checkout above:" >&2
-    echo "        with:" >&2
-    echo "          persist-credentials: false" >&2
-    echo "" >&2
-    echo "If the job genuinely needs the token to push, keep it and say why in a" >&2
-    echo "comment containing 'persist-credentials-exempt'. See rustfs/backlog#1602." >&2
-    exit 1
-fi
-
-echo "OK: every actions/checkout clears its credentials or is explicitly exempt"