Merge branch 'fix/replication-check-ledger-probe' into fix/replication-orphaned-purge-lifecycle

Same one-line change as rustfs/rustfs#7366 (main is red with it under -D warnings); carried here so the stacked PRs' merge commits compile until that fix lands.

.agents/references/adversarial-validation.md

@@ -1,33 +0,0 @@
-# Adversarial Review Shape
-
-Use when root `AGENTS.md` triggers adversarial validation or for a substantial PR
-review. Paths below are repository-relative. The root finding standard and
-completion rule apply; selecting a lens does not require finding a defect.
-
-Risk and review shape:
-
-- **Exempt:** documentation, comments, formatting, or typos with no runtime,
-  build, test, or agent-execution effect.
-- **Mechanical:** renames, moves, test/tooling-only changes, and agent-rule
-  changes. Run correctness and simplicity lenses.
-- **Standard:** localized behavior changes. Run one integrated final-diff pass
-  covering correctness, simplicity, and test coverage; add only domain lenses
-  matched by the diff.
-- **High risk / substantial PR review:** high risk includes locking,
-  erasure/quorum/heal, replication, multipart, RPC, lifecycle/tiering,
-  persistence/fsync, IAM/KMS/auth, cryptography, on-disk/on-wire formats, and
-  S3-visible semantics. Cover all applicable lenses using exactly two
-  independent reviewers when delegation is explicitly authorized. Split the
-  lenses between them. Otherwise perform two fresh sequential passes.
-- **Outbound client defaults:** what `TargetClient`, `PutObjectOptions`, or
-  the remote SDK configuration sends to every replication or migration target
-  is high risk for every target class even when the change fixes one. Follow
-  the SOP in `docs/postmortems/2026-09-03-replication-checksum-default-regression.md`:
-  run the outbound target matrix, document each new env knob in the same PR,
-  and list verified and unverified target classes in the PR Impact section.
-
-Available domain lenses are security, concurrency/durability, compatibility,
-and performance. Select `.agents/skills/adversarial-validation/SKILL.md` for an
-explicit adversarial request, a high-risk change, or a substantial PR review;
-then read only its matching role references. A routine standard pass does not
-load the playbook unless the reviewer needs a RustFS-specific probe.

.agents/references/implementation.md

@@ -1,65 +0,0 @@
-# Implementation Rules
-
-Applies when changing code or running artifact-heavy work. Paths below
-are repository-relative. Read only the relevant sections during read-only review.
-
-## Worktree and Disk Hygiene
-
-- Start implementation from the latest `origin/main` and confirm the requested
-  change is not already present.
-- An existing clean, isolated task worktree is sufficient. Create another
-  worktree only when the current checkout is shared, dirty with unrelated work,
-  or belongs to another task.
-- Never commit from a shared checkout.
-- Use a task-specific branch named `<type>/<topic>`, such as `fix/...`,
-  `feat/...`, `test/...`, or `docs/...`, unless the user specifies a name.
-- Do not include agent, tool, contributor, account, or organization names in
-  branch names.
-- Push to the user-requested remote or the repository's configured push remote.
-  Do not hard-code or infer a remote from an account name.
-- Check free space before artifact-heavy builds, tests, coverage, or downloads.
-  Re-check before a broad gate when space is tight.
-- Remove only task-owned temporary/build artifacts. Never delete another task's
-  worktree or uncommitted data.
-- At handoff, mention disk or cleanup details only when they affected execution
-  or artifacts/worktrees remain intentionally.
-
-## Change Style
-
-- Preserve existing control flow unless changing it is required for correctness.
-- Prefer a direct local edit over new files, wrappers, managers, or speculative
-  abstractions.
-- Add a helper only when it removes current duplication, names a real domain
-  boundary, or isolates a non-trivial invariant.
-- Remove an in-scope path superseded by the change. If compatibility requires it,
-  adapt at the boundary to one canonical core and use the repository's
-  `RUSTFS_COMPAT_TODO` policy.
-- Comments explain non-obvious invariants or reasons. Do not narrate code or
-  record change history.
-- Mention unrelated problems when useful; do not fix them in a narrow task.
-
-## Reuse and Boundary Rules
-
-- Before adding helpers, constants, fixtures, or wrappers, search the touched
-  crate, the domain-owning crate, `crates/utils`, `crates/common`, and relevant
-  direct dependencies.
-- Reuse requires matching semantics: normalization, error types, deadlines,
-  durability, and compatibility must fit the call site. A narrowly named local
-  helper is better than forced reuse with different semantics.
-- Validate untrusted input at its trust boundary, then trust the validated type.
-  Values crossing disk, RPC, persistence, or version boundaries remain
-  untrusted at every consumer.
-- Re-check boundary values immediately before destructive actions such as
-  delete, overwrite, or quorum decisions.
-- Every new branch needs a concrete triggering input/state. For decoded or peer
-  data, corruption and mixed-version input are valid triggers.
-- Required values must return a typed error when absent or corrupt; do not use a
-  default that converts corruption into a plausible result.
-- Attach error context once where it is actionable. Do not erase typed errors
-  below aggregation or quorum layers.
-
-## Naming
-
-Use Rust API naming: `SCREAMING_SNAKE_CASE` constants/statics, `snake_case`
-functions/variables, and `PascalCase` types. Do not rename unrelated existing
-violations.

.agents/references/pull-requests.md

@@ -1,51 +0,0 @@
-# Git and Pull Request Rules
-
-Applies to commits, pushes, PRs, and issue/discussion actions. Paths below are
-repository-relative. User authorization and root `AGENTS.md` still govern scope.
-
-## Final PR Preflight
-
-Before creating or updating a PR, reuse completed review and verification:
-
-- Verify the actual base (normally `origin/main`) and the complete task diff,
-  including file names and whitespace. Exclude secrets, logs, generated
-  artifacts, and unrelated edits. Retain an existing PR's base unless requested.
-- Confirm the final diff passed the root verification tier; fix task-owned
-  failures and run missing scoped checks. Report unresolved required checks or
-  authority without expanding the task. Do not start another general review.
-- Keep the English Conventional Commit title at most 72 characters. Use the
-  template headings, actual checks, material risks, and rollback notes.
-- Immediately before writing to GitHub, confirm the head and task diff are
-  unchanged. Rerun only checks invalidated by edits or relevant state changes.
-
-## Pull Request Lifecycle
-
-- Creating or updating a PR includes one immediate snapshot of checks,
-  mergeability, reviews, and unresolved threads.
-- Unless the user explicitly requests monitoring, a release workflow requires
-  it, or an automation already owns it, hand off after the PR is open with the
-  current state and next event to watch. Do not delay ordinary handoff with
-  fixed quiet-period sleeps.
-- For requested monitoring, use event-driven or bounded waits. Report only state
-  changes, actionable failures, or a meaningful prolonged delay.
-- Investigate failures/comments before changing code. Fix task-attributable
-  issues, rerun affected verification, push, reply or resolve the thread, then
-  resume the requested monitor.
-- Never merge without required reviewer approval or explicit authority.
-- After an observed merge, verify the commit reached the base, then clean the
-  task worktree/branch when safe. Preserve unmerged work for closed PRs unless
-  deletion was explicitly authorized.
-
-## Git and PR Baseline
-
-- Follow Conventional Commits; keep the subject at most 72 characters.
-- Source comments, commits, PR titles, and PR bodies are in English.
-- Keep every heading from `.github/pull_request_template.md`; use `N/A` where
-  needed and include commands actually run.
-- Use `--body-file` for multiline `gh pr create`/`gh pr edit` content.
-- PR/issue/discussion content must not contain the literal sequence `\n` or
-  hard-wrapped prose paragraphs.
-- Do not include local absolute paths or tool-specific labels/prefixes in GitHub
-  content.
-- Resolve review threads after the underlying issue is fixed. If declining a
-  suggestion, reply with a short evidence-based reason.

.agents/skills/adversarial-validation/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: adversarial-validation
-description: Review RustFS diffs or designs for explicit adversarial requests, high-risk changes under the repository review policy, or substantial PR reviews. Skip ordinary questions, diagnosis, planning, status, routine low-risk implementation, and prose with no execution effect.
+description: Review a final RustFS diff adversarially when the user requests adversarial review, the root AGENTS.md classifies the change as high risk, or a substantial PR is being reviewed. Do not use for ordinary questions, diagnosis, planning, status, documentation-only work, or routine low-risk implementation.
 ---
 
 # RustFS Adversarial Validation
 
-Use the [repository risk tiers and review shape](../../references/adversarial-validation.md). This skill
+Use the risk tier and review shape defined in the root `AGENTS.md`. This skill
 routes a review to RustFS-specific probes without loading unrelated domains.
 
 ## Select Lenses
@@ -31,18 +31,15 @@ adversarial review.
 
 ## Review Protocol
 
-1. Freeze the exact final diff/head (or the design under review) and list the
-   selected lenses.
-2. Run the review shape required by the repository risk tier.
+1. Freeze the exact final diff/head and list the selected lenses.
+2. Run the review shape required by root `AGENTS.md`.
 3. For each selected lens, either report a concrete finding or a null verdict
    naming the attacks performed.
-4. Apply root `AGENTS.md`'s finding standard. Test each candidate against callers,
-   existing coverage, and invariants before accepting it; an adversarial role
-   does not have to produce a defect.
-5. Fix or rebut supported findings with code-path, test, or invariant evidence.
+4. A finding needs `file:line`, a triggering input/state/interleaving, the wrong
+   outcome, and a focused fix or missing regression check.
+5. Fix or rebut every finding with code-path, test, or invariant evidence.
 6. After a non-trivial edit, rerun only lenses affected by that edit against the
    new exact diff.
 
 Do not turn a null verdict into a long checklist. Record concise evidence that
-the relevant failure classes were attacked, then stop under the root completion
-rule. Keep the required per-lens verdicts for high-risk PRs.
+the relevant failure classes were attacked.

.agents/skills/adversarial-validation/references/test-coverage.md

@@ -3,10 +3,9 @@
 - For every behavior claim, name the focused test/check that fails if the
   changed hunk is reverted. If none is practical, require the reason and
   residual risk.
-- Confirm tests exercise the real production path and distinguish the intended
-  behavior from the named regression. A success, `is_err()`, or no-panic check
-  can be sufficient when that is the actual contract; require exact values,
-  bytes, state, or error variants when those distinctions matter to the change.
+- Confirm tests exercise the real production path and assert returned values,
+  exact bytes, stored state, or the specific error variant—not only success,
+  `is_err()`, or no panic.
 - For new flags/modes, verify each branch and ask which test fails if the branch
   is inverted.
 - For new error propagation, inject the failure and assert the caller observes

.agents/skills/arch-checks/SKILL.md

@@ -1,13 +1,12 @@
 ---
 name: arch-checks
-description: Diagnose failures from check_layer_dependencies.sh, check_architecture_migration_rules.sh, check_unsafe_code_allowances.sh, check_logging_guardrails.sh, check_doc_paths.sh, or check_no_planning_docs.sh. Use when one of these guards fails, not for every architecture question or documentation edit.
+description: Resolve failures from the repository's architecture guard scripts — check_layer_dependencies.sh, check_architecture_migration_rules.sh, check_unsafe_code_allowances.sh, check_logging_guardrails.sh, check_doc_paths.sh. Use when make pre-commit / pre-pr or CI fails on one of these checks.
 ---
 
 # Architecture Guard Checks
 
-Read only the section for the failing guard. Use `.config/make/` and the current
-workflow to verify its wiring; not every guard is part of every gate. Fix the
-cause and rerun the failed guard; never weaken a check to get green.
+All five run in `make pre-commit` / `make pre-pr` and in CI. Fix the cause;
+never weaken a check to get green.
 
 ## `check_layer_dependencies.sh` — layer DAG in `rustfs/src`
 
@@ -55,8 +54,7 @@ Instruction docs (`AGENTS.md`, `CLAUDE.md`, `ARCHITECTURE.md`) and every
 Markdown file under `docs/` (architecture, operations, testing, index) must not
 reference repo file paths that no longer exist. If your refactor moved code,
 update the docs that point at it — the error message lists `doc -> stale-path`
-pairs. In durable docs, cite paths plus symbol names rather than line numbers
-(see `docs/architecture/README.md`). Review findings still need `file:line`.
+pairs. Cite paths plus symbol names, never line numbers (see `docs/README.md`).
 
 ## `check_no_planning_docs.sh`
 

.agents/skills/code-change-verification/SKILL.md

@@ -8,11 +8,19 @@ description: Review a commit, PR, or merged patch when the user requests ordinar
 Use this skill for an ordinary requested review. If the root policy or user calls
 for adversarial validation, use `adversarial-validation` instead of running both.
 
+## Quick Start
+
+1. Read the scope: commit, PR, patch, or file list.
+2. Map each changed area by risk and user impact.
+3. Inspect each risky change in context.
+4. Report findings first, ordered by severity.
+5. Close with residual risks and verification recommendations.
+
 ## Core Workflow
 
 ### 1) Scope and assumptions
-- Derive the change source, target branch, and relevant runtime/version from the
-  supplied diff and metadata. Ask only when missing context could change the verdict.
+- Confirm change source (diff, commit, PR, files), target branch, language/runtime, and version.
+- If context is missing, state assumptions before deeper analysis.
 - Focus only on requested scope; avoid reviewing unrelated files.
 
 ### 2) Risk map
@@ -32,20 +40,43 @@ for adversarial validation, use `adversarial-validation` instead of running both
   - unchecked assumptions and null/empty/error-path handling
   - stale tests, fixtures, and configs
   - hidden coupling to shared helpers/constants/features
-- Apply root `AGENTS.md`'s finding standard: try to disprove a candidate before
-  reporting it. Mention an unresolved question only when it could materially
-  change the verdict; do not fill the report with speculative possibilities.
+- If a point is uncertain, mark it as an open question instead of guessing.
 
-#### Rust-specific checks
+#### Rust-specific checks (apply to all Rust changes)
 
-For changed Rust behavior, use the matching sections of [rust-code-quality](../rust-code-quality/SKILL.md). Reuse checks already performed by the selected review workflow. Comment-only or formatting-only Rust diffs do not require the full Rust checklist. Carry its P0–P3 ratings over unchanged and use this skill's output format.
+Run the full checklist in [rust-code-quality](../rust-code-quality/SKILL.md) — the canonical Rust review checklist for the unwrap/casting/cloning/locking/recursion/error-type/serde/test rules and the reuse-and-necessity checks (duplicated helpers, defensive branches without a nameable trigger, redundant error wrapping). Do not restate those rules here; carry its P0–P3 ratings over unchanged and use this skill's output format.
 
 ### 4) Findings-first output
-- Order supported findings by P0–P3 severity; preserve the Rust ratings above.
-  Include `path:line`, the failure and impact, a focused fix, and its validation.
-- If no supported issues remain, state `No findings` with the reviewed scope and
-  any material verification limitation. Do not append optional improvements to
-  make a clean review look productive.
+- Order findings by severity:
+  - P0: critical failure, security breach, or data loss risk
+  - P1: high-impact regression
+  - P2: medium risk correctness gap
+  - P3: low risk/quality debt
+- For each finding include:
+  - Severity
+  - `path:line` reference
+  - concise issue statement
+  - impact and likely failure mode
+  - specific fix or mitigation
+  - validation step to confirm
+- If no issues exist, explicitly state `No findings` and why.
 
-Close after the required review. Recommend additional verification only for an
-identified unresolved risk or required gate; reuse evidence for unchanged code.
+### 5) Close
+- Report assumptions and unknowns.
+- Suggest targeted checks (tests, canary checks, logs/metrics, migration validation).
+
+## Output Template
+
+1. Findings
+2. No findings (if applicable)
+3. Assumptions / Unknowns
+4. Recommended verification steps
+
+## Finding Template
+
+- `[P1] Missing timeout for downstream call`
+  - Location: `path/to/file.rs:123`
+  - Issue: ...
+  - Impact: ...
+  - Fix suggestion: ...
+  - Validation: ...

.agents/skills/issue-triage/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: issue-triage
-description: Assess whether a GitHub issue is fixed, needs implementation, or can be closed by checking related work and current code. Use for issue completion/triage requests. Status questions are read-only; comment, close, or change labels only when the conversation authorizes that action.
+description: Triage a GitHub issue — determine if it is already fixed, needs implementation, or should be closed. Searches related commits and PRs, verifies implementation status, and posts a triage comment or closes the issue. Use when the user provides an issue URL and asks whether it can be closed or needs work.
 ---
 
 # Issue Triage
@@ -20,8 +20,6 @@ Read the issue body to understand what was requested. Extract:
 - Any linked PRs or commits mentioned in the body or comments.
 - Any checklist items or sub-issues.
 
-Resolve the issue repository and implementation repository separately (for example, `rustfs/backlog` tracks work in `rustfs/rustfs`). Pass the implementation repository explicitly to PR queries; the current checkout may belong to another repository.
-
 ### 2. Search for related work
 
 Search git history for commits referencing the issue:
@@ -31,29 +29,26 @@ git log --oneline --all --grep="<N>" | head -30
 
 Search for related PRs:
 ```bash
-gh pr list --repo <implementation-repo> --search "<issue-url>" --state all --json number,title,state,mergedAt
+gh pr list --search "fixes #<N> OR closes #<N> OR #<N>" --state all --json number,title,state,mergedAt
 ```
 
-Also search qualified issue references and subject keywords; for same-repository
-issues, include `#<N>`. Follow explicit links even without a text match. A search
-page with no match does not prove the work is absent.
-
 If the issue mentions specific PRs, check their status:
 ```bash
-gh pr view <PR_N> --repo <implementation-repo> --json state,mergedAt,title,mergeCommit,baseRefName
+gh pr view <PR_N> --json state,mergedAt,title
 ```
 
 ### 3. Verify implementation
 
-Fetch the implementation repository's current base branch. For each merged candidate, verify its merge commit is present and inspect the current code for the claimed behavior; a commit message match alone is not proof:
+For each linked or related PR that is merged, verify the fix is actually present on the current main branch:
 ```bash
-git fetch <implementation-remote> <base-branch>
-git merge-base --is-ancestor <merge-commit> <implementation-remote>/<base-branch>
+git log --oneline main | grep -i "<keyword>"
+# or
+git log --oneline main --grep="<PR_N>"
 ```
 
-If the issue describes a specific defect, inspect the fetched base's code rather than assuming the current checkout contains it:
+If the issue describes a specific defect, check the relevant code to confirm the fix is in place:
 ```bash
-git show <implementation-remote>/<base-branch>:crates/<relevant>/src/<file>.rs
+grep -n "<pattern>" crates/<relevant>/src/<file>.rs
 ```
 
 For issues with checklists, verify each item individually. If sub-items are tracked as separate issues, check those too:
@@ -63,15 +58,13 @@ gh issue view <SUB_N> --repo <owner/repo> --json state
 
 ### 4. Determine verdict
 
-- **All items fixed and merged**: Recommend closing; name the verified PRs and behavior.
-- **Some items fixed, some remaining**: Keep open; report each remaining item.
-- **Not yet implemented**: Keep open; report what remains.
-- **Superseded or no longer relevant**: Recommend closing with evidence.
+- **All items fixed and merged**: Close with a summary comment listing what was fixed and which PRs.
+- **Some items fixed, some remaining**: Comment with status of each item. Do not close.
+- **Not yet implemented**: Comment with a summary of what remains. Do not close.
+- **Superseded or no longer relevant**: Close with explanation.
 
 ### 5. Take action
 
-For a status-only request, return the assessment without GitHub writes. If commenting, closing, or label edits are authorized, perform only those actions; do not ask again for authority already given. Prepare the final assessment before asking for any missing authority. Write `rustfs/backlog` issue content in Chinese.
-
 Close with comment:
 ```bash
 gh issue close <N> --repo <owner/repo> --comment "<body>"
@@ -82,9 +75,9 @@ Comment without closing:
 gh issue comment <N> --repo <owner/repo> --body-file /tmp/triage.md
 ```
 
-Update labels only when label changes are authorized, using existing repository labels; never add tool-specific labels:
+Update issue labels if needed:
 ```bash
-gh issue edit <N> --repo <owner/repo> --add-label "<existing-label>"
+gh issue edit <N> --repo <owner/repo> --add-label "completed" --remove-label "needs-triage"
 ```
 
 Always use `--body-file` for multiline content, never inline `--body`.
@@ -92,16 +85,27 @@ Always use `--body-file` for multiline content, never inline `--body`.
 ### 6. Handle multi-issue batches
 
 When the user asks to check multiple issues (e.g., "check all issues by user X" or "scan backlog for closable issues"):
-1. List the full requested scope with pagination (for example `gh api --paginate 'repos/<repo>/issues?state=open&per_page=100'`, excluding entries with `pull_request`). Add an author filter only when the user requested one; the default page/limit is not evidence that all issues were checked.
+1. List the issues: `gh issue list --repo <repo> --author <user> --state open --json number,title,updatedAt`
 2. For each issue, run steps 1-5 above.
 3. Report a summary table of all triaged issues with verdicts.
 
-## Report
+## Output format
 
-Identify the issue and current state, verified implementation/PR evidence,
-remaining items, verdict, and action actually taken. Use a table for batches;
-a single issue does not require a heading for each field. Follow step 4's
-verdicts without repeating the assessment in another template.
+### Issue Triage: #<N> — <title>
+
+**State**: OPEN / CLOSED
+**Linked PRs**: <list with merge status>
+
+#### Assessment
+<what was requested vs what is implemented>
+
+#### Verdict
+- Close — all items resolved by <PR list>
+- Keep open — <remaining items>
+- Not started — <what needs to be done>
+
+#### Action taken
+- Closed with comment / Commented / No action
 
 ## Notes
 

.agents/skills/plugin-contract-guard/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: plugin-contract-guard
-description: Guard changes to target-plugin manifests, extension schemas, admin catalog/instance contracts, secret redaction, and external-plugin install policy. Use when a diff changes those contracts in crates/targets, crates/extension-schema, or admin plugin/extension handlers; path membership alone, comments, and unrelated runtime internals do not trigger it.
+description: Invariants and change procedure for the target-plugin / extension system — plugin manifests, admin plugin/extension catalog and instance APIs, secret redaction, external-plugin install policy. Use when editing crates/targets (manifest, plugin, control_plane, catalog, runtime), crates/extension-schema, or rustfs/src/admin plugin_contract.rs / plugins_*.rs / extensions.rs / target_descriptor.rs.
 ---
 
 # Plugin & Extension Contract Guard

.agents/skills/pr-creation-checker/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: pr-creation-checker
+description: Perform the final RustFS PR preflight and draft compliant English title/body metadata immediately before creating or updating a PR. Do not use during implementation or as a second general code review.
+---
+
+# PR Creation Checker
+
+Use this skill only at the PR boundary. Reuse completed diff review and
+verification evidence; do not reread the repository or rerun equivalent checks.
+
+## Preflight
+
+1. Confirm the branch is based on current `origin/main` and contains only the
+   intended task diff.
+2. Inspect `git diff --stat`, `git diff --check`, and changed file names for
+   secrets, logs, generated artifacts, or unrelated edits.
+3. Confirm the checks selected by root `AGENTS.md` passed on the final diff.
+   Do not replace focused behavioral tests with a generic gate or rerun checks
+   already covered by an unchanged umbrella run.
+4. Read `.github/pull_request_template.md`. Consult `Makefile`, `.config/make/`,
+   or CI only when the required command/current gate is uncertain.
+5. Return `BLOCKED` for an unclean scope, missing required evidence, failed
+   required checks, or non-compliant metadata.
+
+## Metadata
+
+- Title: English Conventional Commit, at most 72 characters, with no tool
+  prefix.
+- Body: English, exact template headings, `N/A` where needed, concise rationale,
+  actual verification commands, and material risks/rollback notes.
+- Use repository-relative paths; never include local absolute paths.
+- Keep prose paragraphs on one logical line and never include the literal
+  sequence `\n`.
+- Use a temporary body file with `gh pr create --body-file` or
+  `gh pr edit --body-file`; never pass multiline Markdown inline.
+
+## Output
+
+- Status: `READY` or `BLOCKED`.
+- Title.
+- Complete PR body.
+- Verification commands and results.
+- Risks or `N/A`.
+
+Immediately before the GitHub write, repeat only the five preflight checks above
+against the final head.

.agents/skills/pr-creation-checker/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "PR Creation Checker"
+  short_description: "Draft RustFS-ready PRs with checks, template, and blockers."
+  default_prompt: "Use $pr-creation-checker for final PR preflight and compliant English title/body metadata."

.agents/skills/pr-review/SKILL.md

@@ -1,93 +1,147 @@
 ---
 name: pr-review
-description: Review a GitHub PR from a URL or number using its actual base/head and risk-appropriate code review. Use when the user asks for a PR review, not a status lookup or PR wording edit. Publish a review only when authorized; delegation and monitoring follow the requested scope and root AGENTS.md.
+description: Review a GitHub PR end-to-end from a URL or number — fetch metadata, inspect the diff, run multi-role adversarial review, check CI status, and post the review comment. Use when the user provides a PR link and asks to review it.
 ---
 
 # PR Review
 
-Use this skill for PR context and review delivery. An ordinary review request is read-only unless the conversation also authorizes posting or fixes. Reuse that authorization without asking again; prepare the review before requesting any missing publication approval.
+Use this skill when the user provides a GitHub PR URL or number and asks to review it. This covers the full review lifecycle: data gathering, code review, CI verification, and posting the result.
 
 ## Prerequisites
 
-- Follow root `AGENTS.md`; classify risk with the [review policy](../../references/adversarial-validation.md) and consult relevant [change-style and boundary rules](../../references/implementation.md).
-- Select `code-change-verification` for ordinary review or `adversarial-validation` for explicitly adversarial, substantial, or high-risk review; do not run both on the same diff.
+- Read `AGENTS.md` for the repository's adversarial validation policy and change-style rules.
+- The `adversarial-validation` skill handles the review role playbooks; this skill orchestrates the workflow around it.
 
 ## Workflow
 
 ### 1. Gather PR context
 
 ```bash
-gh pr view <N> --repo <owner/repo> --json title,author,state,body,additions,deletions,changedFiles,commits,baseRefName,headRefName,baseRefOid,headRefOid
-gh pr diff <N> --repo <owner/repo> --name-only
+gh pr view <N> --json title,author,state,body,additions,deletions,changedFiles,commits,baseRefName,headRefName
+gh pr diff <N> --name-only
 ```
 
 Read the PR body and linked issues to understand the change's purpose. If the PR references an issue, fetch that too:
 ```bash
-gh issue view <ISSUE> --repo <issue-owner/repo> --json title,body,state
+gh issue view <ISSUE> --json title,body,state
 ```
 
 ### 2. Fetch the diff and classify the change
 
 ```bash
-git fetch <repo-remote> <baseRefName> refs/pull/<N>/head
-git diff <baseRefOid>...<headRefOid> --stat
+git fetch origin pull/<N>/head:pr-<N>
+git diff main...pr-<N> --stat
 ```
 
-Resolve `<repo-remote>` to the PR repository; do not assume the current checkout's `origin` or `main` matches. Record the exact base/head used. If either moved during fetching, refresh the snapshot before reviewing. Classify using the repository review policy; instruction changes that affect agent execution are mechanical, not exempt.
+Classify the change by risk tier (per AGENTS.md):
+- **Exempt**: docs/comments/instruction-only, formatting, typos.
+- **Mechanical**: renames, file moves, test-only or tooling changes.
+- **Standard** (default): any behavior change.
+- **High risk**: locking, erasure coding, quorum/heal, replication, multipart, RPC, lifecycle/tiering, metadata formats, persistence/fsync, IAM/KMS/auth, on-disk/on-wire formats, S3 API-visible behavior.
 
-### 3. Review the changed behavior
+### 3. Cluster changed files and delegate review
 
-Group files by functional area to trace callers and invariants. Use the root risk tier's review shape and only matching lenses. File count does not authorize delegation. When delegation is explicitly authorized, high-risk/substantial reviews use exactly two independent reviewers with the applicable lenses split between them; otherwise use two fresh sequential passes. Reviewers do not spawn further agents.
+Group the changed files into logical clusters (by crate or functional area). For each cluster, spawn a subagent with a focused review prompt that includes:
+- The cluster's changed files and their diffs.
+- The applicable adversarial role probes (from the `adversarial-validation` skill).
+- The repository's AGENTS.md rules relevant to that domain.
 
-Findings need a concrete failure scenario with `file:line`; a null verdict briefly names the relevant probes. Reuse existing evidence and choose local checks from the final diff under the root verification policy.
+For standard-tier changes: correctness adversary + simplicity adversary + test-coverage skeptic, plus every role whose domain the diff touches.
+For high-risk changes: run all seven roles.
+
+Each subagent must produce findings (concrete failure scenario with file:line) or a null report ("attacked X, Y, Z — no break found").
 
 ### 4. Check CI status
 
 ```bash
-gh pr checks <N> --repo <owner/repo>
+gh pr checks <N>
 ```
 
-Investigate a failed check when it bears on a finding or the user requested CI diagnosis/merge readiness:
+If any checks fail, investigate:
 ```bash
-gh run view --repo <owner/repo> --log-failed --job=<JOB_ID>
+gh run view --log-failed --job=<JOB_ID>
 ```
 
-Use current evidence to distinguish pre-existing, flaky, and PR-caused failures. Do not classify them by guesswork or turn a code-only review into unrelated CI repair.
+Determine whether failures are pre-existing (on main), flaky, or caused by the PR.
 
 ### 5. Synthesize findings
 
-Report the PR, reviewed base/head, and risk tier, then summarize the assessment.
-Use the selected review's P0–P3 ratings and root finding standard: supported
-findings with `file:line`, failure scenario, and fix, or `No findings`.
-State the observed check status, including pending or unavailable checks, and
-the verdict (`APPROVE`, `REQUEST_CHANGES`, or `COMMENT`). Do not infer a pass
-from missing checks or add style nits to populate a clean review.
+Combine all subagent findings into a structured review:
+- **Summary**: one-paragraph overview of the change and overall assessment.
+- **Findings**: each finding with severity (critical/major/minor/nit), file:line, concrete failure scenario, and suggested fix.
+- **CI status**: pass/fail with notes on any failures.
+- **Verdict**: APPROVE, REQUEST_CHANGES, or COMMENT.
 
 ### 6. Post the review
 
-Only when posting is authorized, write the review body to a temp file and post via CLI. Refresh the PR head first; if it changed, review the delta and update the verdict before posting:
+Write the review body to a temp file and post via CLI:
 ```bash
 # Request changes
-gh pr review <N> --repo <owner/repo> --request-changes --body-file /tmp/pr_review.md
+gh pr review <N> --request-changes --body-file /tmp/pr_review.md
 
 # Approve
-gh pr review <N> --repo <owner/repo> --approve --body-file /tmp/pr_review.md
+gh pr review <N> --approve --body-file /tmp/pr_review.md
 
 # Comment only (no verdict)
-gh pr review <N> --repo <owner/repo> --comment --body-file /tmp/pr_review.md
+gh pr review <N> --comment --body-file /tmp/pr_review.md
 ```
 
-For authorized inline comments, use [the submission example](references/posting.md).
+For inline comments on specific lines, use the GitHub API:
+```bash
+cat > /tmp/pr_review.json <<'EOF'
+{
+  "body": "review body",
+  "event": "REQUEST_CHANGES",
+  "comments": [
+    {
+      "path": "crates/foo/src/bar.rs",
+      "line": 42,
+      "body": "finding description"
+    }
+  ]
+}
+EOF
+gh api --method POST /repos/{owner}/{repo}/pulls/<N>/reviews --input /tmp/pr_review.json
+```
 
 Always use `--body-file` or `--input`, never inline multiline `--body`.
 
 ### 7. Handle follow-up
 
-Follow the [PR lifecycle](../../references/pull-requests.md) and any explicit monitoring request. For follow-up, fetch the new head and compare the recorded reviewed SHA with the new SHA; revisit affected callers and findings. Never use an unfetched `origin/pull/<N>/head` ref as evidence. Update the posted review or resolve addressed threads only within existing authorization.
+If the review requests changes:
+- Monitor for new commits: `gh pr view <N> --json commits`
+- Re-review changed files only: `git diff pr-<N>..origin/pull/<N>/head`
+- Update the review when findings are addressed.
+
+If CI was failing due to pre-existing main breakage:
+- Comment on the PR noting the failure is pre-existing.
+- Suggest updating the branch: `gh pr update-branch <N>`
+
+## Output format
+
+### PR Review: #<N> — <title>
+
+**Author**: <author>
+**Risk tier**: exempt | mechanical | standard | high-risk
+**Changed files**: <count> across <cluster count> clusters
+
+#### Summary
+<one-paragraph overview>
+
+#### Findings
+| Severity | Location | Finding |
+|----------|----------|---------|
+| critical | file:line | concrete failure scenario |
+
+#### CI Status
+- All checks pass / Failing: <details>
+
+#### Verdict
+APPROVE / REQUEST_CHANGES / COMMENT
 
 ## Notes
 
 - The user may ask for review in Chinese; respond in the same language but keep the review body in English per AGENTS.md rules.
 - When the user asks for "多角色对抗 review", run the full adversarial validation protocol — this skill's step 3 covers that.
 - If the PR is from a fork, check `maintainerCanModify` before attempting to push fixes.
-- For very large PRs, batch the review by functional area while keeping the same bounded review shape.
+- For very large PRs (>50 files), cluster aggressively and delegate in parallel to keep review time reasonable.

.agents/skills/pr-review/references/posting.md

@@ -1,22 +0,0 @@
-# Inline PR Review Submission
-
-Read only when an inline review is authorized. Recheck the PR head before posting and bind the review to the reviewed commit.
-
-For inline comments on specific lines, use the GitHub API:
-```bash
-cat > /tmp/pr_review.json <<'EOF'
-{
-  "commit_id": "<reviewed-head-sha>",
-  "body": "review body",
-  "event": "REQUEST_CHANGES",
-  "comments": [
-    {
-      "path": "crates/foo/src/bar.rs",
-      "line": 42,
-      "body": "finding description"
-    }
-  ]
-}
-EOF
-gh api --method POST /repos/{owner}/{repo}/pulls/<N>/reviews --input /tmp/pr_review.json
-```

.agents/skills/rust-code-quality/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rust-code-quality
-description: Run a focused Rust quality review when the user requests one or a selected review workflow needs Rust-specific checks for changed behavior. Do not auto-load for every implementation edit, comment-only or formatting-only Rust diff, or repeat an already completed review.
+description: Run a focused Rust quality review when the user requests one, when reviewing a Rust PR/commit, or when another selected review workflow delegates Rust-specific checks. Do not auto-load for every implementation edit.
 ---
 
 # Rust Code Quality Gate
@@ -8,18 +8,12 @@ description: Run a focused Rust quality review when the user requests one or a s
 Use this skill for a dedicated Rust review to cover rules that `cargo clippy`
 does not catch.
 
-Search matches and checklist items are candidates, not findings. Apply the root
-finding standard; distinguish a demonstrated bug, an explicit rule violation,
-and an optional preference. P2/P3 suggestions do not need to be invented or
-included in an otherwise clean correctness review.
-
 ## Quick Start
 
 1. Identify changed `.rs` files.
-2. Run the matching candidate searches on changed files.
-3. Apply the manual checklist sections whose behavior the diff touches.
-4. Report or rebut every finding with evidence; P0/P1 findings block approval.
-   Fix them when implementation is authorized; a read-only review reports them.
+2. Run automated checks on changed files.
+3. Run manual review checklist on the diff.
+4. Resolve or rebut every finding with evidence; P0/P1 findings cannot be deferred.
 
 ## Automated Checks
 
@@ -41,7 +35,7 @@ rg -n 'Result<.*String>' <changed-files>
 rg -n 'Box<dyn.*Error' <changed-files>
 
 # 5. println/eprintln in production
-rg -n 'println!|eprintln!' <changed-files>
+rg -n 'println!\|eprintln!' <changed-files>
 
 # 6. Ordering::Relaxed usage (verify each is intentional)
 rg -n 'Ordering::Relaxed' <changed-files>
@@ -86,7 +80,7 @@ For the Rust diff under review, verify:
 - [ ] Test volume and line count are never treated as production-code growth
 
 ### Serde
-- [ ] Structs from untrusted input reject unknown fields where the compatibility contract permits; otherwise validate security-critical fields explicitly and test the supported input shape
+- [ ] Structs from untrusted input have `#[serde(deny_unknown_fields)]`
 - [ ] `#[serde(default)]` not used on security-critical fields without validation
 
 ### Code Hygiene
@@ -110,7 +104,20 @@ For the Rust diff under review, verify:
 
 ## Output Template
 
-Use the calling review's output format. For a standalone review, report supported
-findings with severity, location, impact, fix, and validation, or `No findings`.
-Include only material unverified checks. Candidate counts are not a quality
-metric and do not need a separate scan report.
+```
+## Rust Code Quality Report
+
+### Automated Scan
+- unwrap/expect candidates inspected: N
+- numeric-cast candidates inspected: N
+- error-type candidates inspected: N
+- output-macro candidates inspected: N
+
+### Findings
+- [P1] `path:line` — description
+  - Fix: ...
+  - Validation: ...
+
+### Verdict
+PASS / BLOCKED (list blocking findings)
+```

.agents/skills/rustfs-release-publish/SKILL.md

@@ -4,14 +4,9 @@ description: "Run the end-to-end RustFS console gate, version bump, preview vali
 ---
 # RustFS Release Publish (preview-validated pipeline)
 
-This skill orchestrates a full release. It wraps `rustfs-release-version-bump` (invoked here with the authorized commit/push/PR scope) with a mandatory preview-tag validation loop before the final tag is published.
+This skill orchestrates a full release. It wraps `rustfs-release-version-bump` (which only edits version files and opens the PR) with a mandatory preview-tag validation loop before the final tag is published.
 
-The binary reports its build tag (`build::TAG` via shadow_rs; `SHORT_VERSION` in
-`rustfs/src/config/cli.rs`), and `build.yml` derives asset names and preview
-classification from that tag. Cargo.toml supplies only the no-tag fallback.
-Preview and final tags must therefore share the validated source commit;
-their tag-dependent version and asset names differ. The channel and cleanup
-constraints are defined once under Preview tag naming and Hard rules below.
+Core design: **version files never carry a `-preview.N` suffix**. The preview suffix exists only in tag names. A preview tag creates a visible GitHub Release marked Prerelease and uploads versioned assets, but it never becomes GitHub Latest and never updates `*-latest`, `latest.json`, R2, Docker, or Helm channels. That Release is temporary: `build.yml` deletes it automatically once the final tag's Release is published, so the Releases page ends up carrying deliverables only while the `-preview.N` tags stay behind as the traceability record. This works because the binary self-reports the git tag it was built from (`build::TAG` via shadow_rs, see `rustfs/src/config/cli.rs` `SHORT_VERSION`), and `build.yml` derives artifact names and preview classification from the tag name — Cargo.toml's version is only a no-tag fallback. Therefore the preview tag and the final tag can (and MUST) point at the exact same commit: what you validated is byte-for-byte the source that ships.
 
 Pipeline shape:
 
@@ -34,9 +29,9 @@ On validation failure: fix lands on main via normal PR (version files are alread
 - Final target version, for example `1.0.0-beta.10`.
 - Preview iteration `N` (default: next unused preview tag for that target; check with `git tag -l '<target>-preview.*'` after `git fetch --tags`).
 
-If the target version is missing or ambiguous, collect the current release/tag baseline and ask before version edits or publication. Continue independent read-only preflight while the answer is pending (see the semver gate below).
+If the target version is missing or ambiguous, stop and ask before doing anything (see the semver gate below).
 
-## Semver gate — resolve the target before version edits or publication
+## Semver gate — confirm the target version before touching anything
 
 Versions follow [SemVer 2.0.0](https://semver.org/). Precedence reminder:
 
@@ -48,7 +43,7 @@ Numeric prerelease identifiers compare numerically (`beta.9 < beta.10`), not lex
 
 Rules:
 
-- A request like "发个版" / "release the next version" without an exact version string is ALWAYS ambiguous. Derive the current latest tag (`git tag --sort=-v:refname | head`), then ask the user to choose with concrete candidates, e.g. from `1.0.0-beta.10`: next prerelease `1.0.0-beta.11`, promote to `1.0.0-rc.1`, promote to stable `1.0.0`. Never guess between these — they have very different meanings (channel promotion vs. iteration) and different CI classification consequences.
+- A request like "发个版" / "release the next version" without an exact version string is ALWAYS ambiguous. Derive the current latest tag (`git tag --sort=-v:refname | head`), then ask the user to choose via AskUserQuestion with concrete candidates, e.g. from `1.0.0-beta.10`: next prerelease `1.0.0-beta.11`, promote to `1.0.0-rc.1`, promote to stable `1.0.0`. Never guess between these — they have very different meanings (channel promotion vs. iteration) and different CI classification consequences.
 - After a stable `X.Y.Z` exists, the next version must state which component bumps: patch `X.Y.(Z+1)` for fixes only, minor `X.(Y+1).0` for backward-compatible features, major `(X+1).0.0` for breaking changes. If the user names a bump type but not a number, compute it from the latest stable tag and echo the exact resulting version back for confirmation.
 - Echo the final confirmed version string verbatim in your first status report; every later phase must use exactly that string. If at any point the user's wording and the confirmed version diverge, stop and re-confirm.
 
@@ -82,7 +77,58 @@ Rules:
 
 ### Console release gate
 
-Read and complete [the Console gate](references/console-gate.md) before Phase 1. Verify the latest published Console asset and exact commit; if Console main is ahead, complete its release and asset verification first. A successful build alone does not satisfy this gate.
+Complete this gate before changing any RustFS version file or creating any RustFS tag. RustFS `build.yml` downloads the asset returned by `repos/rustfs/console/releases/latest`, so a successful Console build alone is insufficient.
+
+1. Read the latest published Console tag and compare it with Console `main`:
+
+```bash
+CONSOLE_REPO="rustfs/console"
+CONSOLE_LATEST=$(gh api "repos/${CONSOLE_REPO}/releases/latest" --jq .tag_name)
+gh api "repos/${CONSOLE_REPO}/compare/${CONSOLE_LATEST}...main" \
+  --jq '{status, ahead_by, behind_by, commits: [.commits[] | {sha, message: .commit.message}]}'
+```
+
+- `ahead_by == 0`: no merged Console change is waiting for release. Still verify the current latest asset using step 4, then continue to Phase 1.
+- `ahead_by > 0` and `behind_by == 0`: publish Console before continuing. Report the merged commits and select the next unused `vX.Y.Z` tag. Default to the next patch version when the changes are fixes or backward-compatible UI work; stop for confirmation if a minor/major bump is plausible.
+- Any diverged history or `behind_by > 0`: stop and resolve the Console release baseline explicitly. Do not guess a range or publish RustFS.
+
+2. Clone/fetch `rustfs/console` into a scratch directory and record its exact `main` commit. Before creating a tag, check for a `v*` tag or Release workflow already associated with that hash. If one is in progress, wait for it instead of creating another version:
+
+```bash
+CONSOLE_SCRATCH=$(mktemp -d)
+gh repo clone "$CONSOLE_REPO" "$CONSOLE_SCRATCH/console"
+git -C "$CONSOLE_SCRATCH/console" fetch origin main --tags
+CONSOLE_HASH=$(git -C "$CONSOLE_SCRATCH/console" rev-parse origin/main)
+git -C "$CONSOLE_SCRATCH/console" tag --points-at "$CONSOLE_HASH" 'v*'
+gh run list -R "$CONSOLE_REPO" --workflow release.yml --commit "$CONSOLE_HASH" --limit 5
+```
+
+If no release exists or is running for `CONSOLE_HASH`, create the selected annotated tag at that exact hash and push it:
+
+```bash
+git -C "$CONSOLE_SCRATCH/console" tag -a "<console-tag>" -m "Release <console-tag>" "$CONSOLE_HASH"
+git -C "$CONSOLE_SCRATCH/console" push origin "<console-tag>"
+```
+
+Console tags include the `v` prefix. Pushing the tag triggers `.github/workflows/release.yml` (`🚀 Release`). Remove `CONSOLE_SCRATCH` after the gate completes.
+
+3. Find the exact tag run and wait for completion:
+
+```bash
+gh run list -R "$CONSOLE_REPO" --workflow release.yml --branch "<console-tag>" --limit 1
+gh run watch -R "$CONSOLE_REPO" "<console-run-id>" --exit-status
+```
+
+4. Block until the published Release is non-draft, the latest endpoint returns the expected tag, and `rustfs-console-<console-tag>.zip` is uploaded, non-empty, and carries a `sha256:` digest:
+
+```bash
+gh release view -R "$CONSOLE_REPO" "<console-tag>" --json isDraft,isPrerelease,assets,url
+test "$(gh api "repos/${CONSOLE_REPO}/releases/latest" --jq .tag_name)" = "<console-tag>"
+test "$(gh api "repos/${CONSOLE_REPO}/releases/tags/<console-tag>" \
+  --jq '[.assets[] | select(.name == "rustfs-console-<console-tag>.zip" and .state == "uploaded" and .size > 0 and (.digest | startswith("sha256:")))] | length')" -eq 1
+```
+
+Treat a missing/mismatched asset, digest, latest tag, or failed/cancelled workflow as BLOCKED. Do not start Phase 1 until the Console gate passes. Record `CONSOLE_TAG`, `CONSOLE_HASH`, Console run URL, and Release URL for the final report.
 
 ## Phase 1 — Version bump to the final target (once)
 
@@ -118,9 +164,54 @@ On a restart (N+1), refresh `PREVIEW_HASH=$(git rev-parse origin/main)` first
 - Record `PREVIOUS_DELIVERABLE`, selected from published Releases by `publishedAt` after excluding the current tag and every `-preview.N` tag. Verify `gh release view "<preview-tag>" --json body --jq .body` contains `## What's Changed` and, when `PREVIOUS_DELIVERABLE` exists, `**Full Changelog**: https://github.com/rustfs/rustfs/compare/<PREVIOUS_DELIVERABLE>...<preview-tag>`. For a repository with no previous deliverable, verify a Full Changelog link exists and record the GitHub baseline fallback.
 - Confirm preview-triggered Docker and Helm jobs are skipped. Preview validation covers the built RustFS binaries, embedded console, and rc compatibility; Docker image construction and Helm publication are deferred to the final tag because the Dockerfiles consume GitHub Release assets.
 
-## Phases 4–5 — Local artifact, Console, and rc acceptance
+## Phase 4 — Run the artifact locally, verify the console
 
-Read and complete [preview acceptance](references/preview-acceptance.md): verify the downloaded binary's tag/SHA and readiness, exercise Console CRUD with byte-identical download, and pass the full latest-rc command matrix. Any failure blocks final publication. Retain the results for the confirmation gate below.
+Work inside the session scratchpad directory; never leave stray data dirs.
+
+```bash
+gh release download "<preview-tag>" -p "rustfs-macos-aarch64-v<preview-tag>.zip" -D "$SCRATCH"
+cd "$SCRATCH" && unzip -o rustfs-*.zip
+./rustfs --version        # must report the PREVIEW TAG (build::TAG), not the Cargo.toml version, plus expected short SHA
+mkdir -p data
+RUSTFS_ACCESS_KEY=rustfsadmin RUSTFS_SECRET_KEY=rustfsadmin ./rustfs ./data
+```
+
+Defaults: S3 endpoint `:9000`, embedded console `:9001`.
+
+Checks (all must pass):
+
+- `./rustfs --version` reports the preview tag name and the short SHA of `PREVIEW_HASH`. Reporting `<target>` without the `-preview.N` suffix means the build did not embed the tag — treat as FAIL and investigate before proceeding.
+- `curl -fsS http://localhost:9000/health/ready` returns ready.
+- Startup log shows the embedded console being served (this was the regression that `fix(release): require embedded console assets` guards).
+- Open `http://localhost:9001` in the browser: login with `rustfsadmin`/`rustfsadmin`; dashboard renders without JS console errors; create a bucket, upload a file, download it back (byte-identical), delete the object and bucket. Keep the server running for Phase 5.
+
+## Phase 5 — Validate with the latest rc client
+
+`rc` is the RustFS CLI client from <https://github.com/rustfs/cli>.
+
+- Ensure the latest release is installed: compare `rc --version` against `gh api repos/rustfs/cli/releases/latest --jq .tag_name`; update via `brew upgrade rustfs/tap/rc` (or download the release binary).
+- Point it at the preview server and run the command matrix, recording PASS/FAIL per command:
+
+```bash
+rc alias set preview http://localhost:9000 rustfsadmin rustfsadmin
+rc ls preview/
+rc mb preview/rel-check
+rc cp <local-file> preview/rel-check/
+rc stat preview/rel-check/<file>
+rc cat preview/rel-check/<file>          # matches source
+rc cp preview/rel-check/<file> ./out && cmp <local-file> ./out
+rc cp -r <local-dir>/ preview/rel-check/dir/
+rc find preview/rel-check --name "*"
+rc share download preview/rel-check/<file> --expire 1h   # presigned URL fetchable via curl
+rc rm preview/rel-check/<file> && rc rm -r --force preview/rel-check/dir
+rc rb preview/rel-check
+rc admin user list preview/
+rc admin user add preview/ relcheckuser relchecksecret12
+rc admin user remove preview/ relcheckuser
+rc alias remove preview
+```
+
+- Any FAIL blocks the release. Afterwards stop the server and delete the scratch data directory.
 
 ### Manual confirmation gate
 

.agents/skills/rustfs-release-publish/references/console-gate.md

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

.agents/skills/rustfs-release-publish/references/preview-acceptance.md

@@ -1,52 +0,0 @@
-# Preview Artifact Acceptance
-
-Read after Phase 3 succeeds. Complete every check below before the parent skill's manual confirmation gate. These checks cover the downloaded artifact, embedded Console, and latest rc client.
-
-## Phase 4 — Run the artifact locally, verify the console
-
-Work inside the session scratchpad directory; never leave stray data dirs.
-
-```bash
-gh release download "<preview-tag>" -p "rustfs-macos-aarch64-v<preview-tag>.zip" -D "$SCRATCH"
-cd "$SCRATCH" && unzip -o rustfs-*.zip
-./rustfs --version        # must report the PREVIEW TAG (build::TAG), not the Cargo.toml version, plus expected short SHA
-mkdir -p data
-RUSTFS_ACCESS_KEY=rustfsadmin RUSTFS_SECRET_KEY=rustfsadmin ./rustfs ./data
-```
-
-Defaults: S3 endpoint `:9000`, embedded console `:9001`.
-
-Checks (all must pass):
-
-- `./rustfs --version` reports the preview tag name and the short SHA of `PREVIEW_HASH`. Reporting `<target>` without the `-preview.N` suffix means the build did not embed the tag — treat as FAIL and investigate before proceeding.
-- `curl -fsS http://localhost:9000/health/ready` returns ready.
-- Startup log shows the embedded console being served (this was the regression that `fix(release): require embedded console assets` guards).
-- Open `http://localhost:9001` in the browser: login with `rustfsadmin`/`rustfsadmin`; dashboard renders without JS console errors; create a bucket, upload a file, download it back (byte-identical), delete the object and bucket. Keep the server running for Phase 5.
-
-## Phase 5 — Validate with the latest rc client
-
-`rc` is the RustFS CLI client from <https://github.com/rustfs/cli>.
-
-- Ensure the latest release is installed: compare `rc --version` against `gh api repos/rustfs/cli/releases/latest --jq .tag_name`; update via `brew upgrade rustfs/tap/rc` (or download the release binary).
-- Point it at the preview server and run the command matrix, recording PASS/FAIL per command:
-
-```bash
-rc alias set preview http://localhost:9000 rustfsadmin rustfsadmin
-rc ls preview/
-rc mb preview/rel-check
-rc cp <local-file> preview/rel-check/
-rc stat preview/rel-check/<file>
-rc cat preview/rel-check/<file>          # matches source
-rc cp preview/rel-check/<file> ./out && cmp <local-file> ./out
-rc cp -r <local-dir>/ preview/rel-check/dir/
-rc find preview/rel-check --name "*"
-rc share download preview/rel-check/<file> --expire 1h   # presigned URL fetchable via curl
-rc rm preview/rel-check/<file> && rc rm -r --force preview/rel-check/dir
-rc rb preview/rel-check
-rc admin user list preview/
-rc admin user add preview/ relcheckuser relchecksecret12
-rc admin user remove preview/ relcheckuser
-rc alias remove preview
-```
-
-- Any FAIL blocks the release. Afterwards stop the server and delete the scratch data directory.

.agents/skills/rustfs-release-version-bump/SKILL.md

@@ -4,16 +4,17 @@ description: "Prepare the version-file and release-asset bump for an exact RustF
 ---
 # RustFS Release Version Bump
 
-Use this skill to prepare and verify release version files. Commit, push, and PR steps apply only when included in the user's delivery scope; publishing release tags belongs to `rustfs-release-publish`.
+Use this skill to publish a RustFS release (alpha, beta, or stable) with a minimal, auditable diff and a complete ship flow (`edit -> verify -> commit -> push -> PR`).
 
 Validated baseline: release pattern used in PR `#2957`.
 
 ## Required inputs
 
 - Exact target version, for example `1.0.0-beta.4`.
-- Delivery scope: local (`edit/verify`), git (`commit/push`), or GitHub
-  (`commit/push/PR`). Derive it from the conversation; when unspecified, prepare
-  and verify locally without blocking on a delivery question.
+- Delivery scope:
+- Local only (`edit/verify`).
+- Local + git (`commit/push`).
+- Full GitHub flow (`commit/push/PR`).
 
 If target version is missing or ambiguous, stop and ask before editing.
 
@@ -22,7 +23,7 @@ Reject any target version containing `-preview`: preview identifiers are tag-onl
 ## Read before editing
 
 - `AGENTS.md` (root and nearest path-specific files).
-- `.github/pull_request_template.md` only when preparing a PR.
+- `.github/pull_request_template.md`.
 - Current branch status and diff against `origin/main`.
 
 ## Default release file scope
@@ -49,7 +50,8 @@ Only drop a file when the current repository release process clearly no longer r
 ## Step-by-step workflow
 
 1. Confirm intent and isolate scope
-- Use the exact target and delivery scope already supplied; ask only for a missing or ambiguous target or a material release-policy choice.
+- Confirm target version string exactly.
+- Confirm whether user requested local-only or full GitHub flow.
 - Inspect current branch and ensure only release-related files are touched for this task.
 
 2. Update workspace versions
@@ -80,18 +82,18 @@ Only drop a file when the current repository release process clearly no longer r
 4. Verify before shipping
 - Run:
 - `make pre-commit`
-- If `make pre-commit` fails, fix task-attributable failures and rerun affected checks. Report unresolved required checks as `BLOCKED`; do not silently widen scope to fix unrelated issues.
+- If `make pre-commit` fails, return `BLOCKED` with root cause and do not silently widen scope to fix unrelated issues unless user asks.
 
-5. Commit strategy (only when committing is authorized)
+5. Commit strategy
 - Preferred split when both parts changed:
 - `chore(release): prepare <version>` for `Cargo.toml` and `Cargo.lock`.
 - `chore(release): align release assets for <version>` for docs and packaging files.
 - If user asks for one commit, use one commit.
 - Stage only intended release files; do not include unrelated working tree changes.
 
-6. Push and PR (only for the authorized delivery scope)
+6. Push and PR
 - Push branch:
-- Use the user-requested or configured push remote: `git push -u <push-remote> <branch>` (first push), or `git push` when tracking is already configured.
+- `git push -u origin <branch>` (first push), or `git push` (tracking already exists).
 - Create PR with template headings unchanged:
 - `gh pr create --base main --head <branch> --title ... --body-file ...`
 - PR title/body must be English.

.agents/skills/security-advisory-lessons/SKILL.md

@@ -12,9 +12,8 @@ matched security surface, the concise security reference under
 ## Workflow
 
 1. Freeze the exact diff/head and identify the changed trust boundaries.
-2. Inspect the headings in [advisory-patterns.md](references/advisory-patterns.md),
-   then read the matching sections. Read the full map only for a broad security
-   audit. Useful headings are
+2. Read [advisory-patterns.md](references/advisory-patterns.md), then apply only
+   the matching sections. Useful headings are
    auth/admin, IAM/STS/OIDC, policy/plugins, S3/copy/multipart, protocols, paths,
    secrets/logging/RPC, browser/CORS/proxy, SSE, Object Lock, and serde.
 3. Trace unauthenticated, low-privilege, wrong-action/owner/bucket, malformed,

.agents/skills/security-advisory-lessons/references/advisory-patterns.md

@@ -108,9 +108,9 @@ Update this file only when an advisory adds or changes a reusable lesson, affect
 
 ### Serde deserialization and input validation
 
-- Reject unknown fields in untrusted S3 API XML/JSON, lifecycle, policy, and replication input where compatibility permits. Check the current type and supported payload fixtures; do not infer the repository's current coverage from an older audit. Where extra fields are part of the compatibility contract, validate security-critical values explicitly.
+- No `#[serde(deny_unknown_fields)]` found across the entire codebase. Lesson: all structs deserialized from untrusted input (S3 API XML/JSON, lifecycle rules, bucket policies, replication configs) should have `#[serde(deny_unknown_fields)]` to reject malformed or adversarial payloads.
 - `#[serde(default)]` on security-critical fields silently accepts missing values as zero/empty. Lesson: when a field has security implications (retention days, permissions, limits), validate the deserialized value explicitly rather than relying on defaults.
-- Integer fields deserialized from user input and cast with `as` (e.g., `i32 as u32`) can wrap negative values to large positives. Lesson: validate ranges before casting; use `try_into()` with a typed error, or clamp only when the domain explicitly requires saturation.
+- Integer fields deserialized from user input and cast with `as` (e.g., `i32 as u32`) can wrap negative values to large positives. Lesson: validate ranges before casting; use `try_into()` or clamp.
 - XML config typos (e.g., `"NoncurentDays"` instead of `"NoncurrentDays"`) are silently accepted when `deny_unknown_fields` is absent. Lesson: strict deserialization prevents silent misconfiguration that could cause data loss or unexpected retention behavior.
 
 ## Useful Search Seeds

.agents/skills/test-coverage-improver/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: test-coverage-improver
-description: Analyze a supplied coverage report or perform an explicitly requested RustFS coverage assessment, rank uncovered risks, and propose focused tests. Do not trigger for ordinary implementation verification, a single regression test, documentation wording, or release preparation without a coverage request.
+description: Run project coverage checks, rank high-risk gaps, and propose high-impact tests to improve regression confidence for changed and critical code paths before release.
 ---
 
 # Test Coverage Improver
@@ -9,49 +9,58 @@ Use this skill when you need a prioritized, risk-aware plan to improve tests fro
 
 ## Usage assumptions
 - Focus scope is either changed lines/files, a module, or the whole repository.
-- Reuse a supplied coverage artifact when its revision, scope, and format match.
+- Coverage artifact must be generated or provided in a supported format.
 - If required context is missing, call out assumptions explicitly before proposing work.
 
 ## Workflow
 
 1. Define scope and baseline
-   - Derive the revision and scope from the request, diff, or supplied report.
-   - Default to the affected files/module; whole-workspace coverage requires that
-     scope in the request. Ask only if a wrong scope would change the result.
+   - Confirm target language, framework, and branch.
+   - Confirm whether the scope is changed files only or full-repo.
 
-2. Obtain coverage evidence
-   - First inspect a matching existing artifact; do not regenerate it merely
-     because this skill was selected.
-   - If measurement is needed, read the Coverage section of
-     [the testing guide](../../../docs/testing/README.md#coverage), check disk
-     space/tool availability, and select package/test-scoped `cargo llvm-cov`
-     using the repository's nextest configuration. `make coverage` measures the
-     whole workspace (excluding E2E) and is only for that requested scope.
-   - Collect only metrics the report supports. Missing branch/changed-line
-     coverage is unknown, not zero.
-   - If measurement cannot run, continue with code-based test proposals and
-     mark measured coverage unverified; do not invent a coverage percentage.
+2. Produce coverage snapshot
+   - Rust: `cargo llvm-cov` (or `cargo tarpaulin`) with existing repo config.
+   - JavaScript/TypeScript: `npm test -- --coverage` and read `coverage/coverage-final.json`.
+   - Python: `pytest --cov=<pkg> --cov-report=json` and read `coverage.json`.
+   - Collect total, per-file, and changed-line coverage.
 
 3. Rank highest-risk gaps
    - Prioritize changed code, branch coverage gaps, and low-confidence boundaries.
    - Apply the risk rubric in [coverage-prioritization.md](references/coverage-prioritization.md).
-   - Report up to 5–8 evidenced gaps; do not pad a small scope.
+   - Keep shortlist to 5–8 gaps.
    - For each gap, capture: file, lines, uncovered branches, and estimated risk score.
 
 4. Propose high-impact tests
-   - For each gap, name the behavior and regression, distinguishing assertions,
-     relevant normal/edge/failure cases, necessary setup, and estimated effort.
-   - Include only scenarios and setup that apply; reuse shared fixture details.
+   - For each shortlisted gap, output:
+     - Intent and expected behavior.
+     - Normal, edge, and failure scenarios.
+     - Assertions and side effects to verify.
+     - Setup needs (fixtures, mocks, integration dependencies).
+     - Estimated effort (`S/M/L`).
 
 5. Close with validation plan
    - State which gaps remain after proposals.
-   - Give a scoped verification command and behavior-based acceptance criterion;
-     use a coverage threshold only when the task or repository requires one.
+   - Provide concrete verification command and acceptance threshold.
    - List assumptions or blockers (environment, fixtures, flaky dependencies).
 
-## Report
+## Output template
 
-Summarize the supported metrics, then combine each ranked gap with its proposed
-test and validation. Include source lines only when supplied or inspected;
-mark missing metrics or locations as unknown. Do not duplicate gaps and tests
-in separate templates or fill empty categories for an otherwise small report.
+### Coverage Snapshot
+- total / branch coverage
+- changed-file coverage
+- top missing regions by size
+
+### Top Gaps (ranked)
+- `path:line-range` | risk score | why critical
+
+### Test Proposals
+- `path:line-range`
+  - Test name
+  - scenarios
+  - assertions
+  - effort
+
+### Validation Plan
+- command
+- pass criteria
+- remaining risk

.agents/skills/test-coverage-improver/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Test Coverage Improver"
   short_description: "Find top uncovered risk areas and propose high-impact tests."
-  default_prompt: "Use $test-coverage-improver to analyze coverage for the requested scope, reuse matching reports, and propose tests for evidenced risks."
+  default_prompt: "Run coverage checks, identify largest gaps, and recommend highest-impact test cases to improve risk coverage."

.agents/skills/tier-debug/SKILL.md

@@ -5,11 +5,8 @@ description: Debug ILM tiering / lifecycle transition issues — NoSuchVersion o
 
 # Tier / ILM Debugging
 
-Playbook: [docs/operations/tier-ilm-debugging.md](../../../docs/operations/tier-ilm-debugging.md).
-Read the section matching the symptom: metadata/`xl.meta`, runtime versionId,
-manual jobs, or retained-record recovery. Read the local-first expiry invariant
-before changing cleanup ordering. Before a reconcile/disposition action, read
-its entire procedure and retain its exact-evidence and confirmation gates.
+Full playbook: [docs/operations/tier-ilm-debugging.md](../../../docs/operations/tier-ilm-debugging.md)
+— read it before changing tier code.
 
 Quick moves:
 

.codex/config.toml

@@ -1,5 +0,0 @@
-# Bound individual tool outputs retained in context; retrieve relevant ranges
-# from task-owned log files when more evidence is needed.
-# https://learn.chatgpt.com/docs/config-file/config-reference
-
-tool_output_token_limit = 4000

.config/e2e-full-selection.txt

@@ -1,2 +1,2 @@
-sha256-darwin=f0c78fdb93471575d9a64c5c46eae6c806bdd0bc10a6e33d7fb574aabd8db5a3
-sha256-linux=03ed7016cab672de9320e31375a0358eceacb4408b0e79cf063614fa7c878b87
+sha256-darwin=53b05ac745905809d3828c6994bdd8ecf9d20b2b61a8a9d80fe15eb62f932193
+sha256-linux=7c892afa4b9d1591b46bd79c976b647109a277284fddb3b98edced4b0297eda2

.config/e2e-repl-nightly-selection.txt

@@ -1 +1 @@
-sha256=0fe8408874ccec3620262a9812d67920ddd72dc9edf0e36e0d0aed3f8bad026e
+sha256=95c8adc016bbc0df9fb2afa24a108bcdf6567ec4d0518725a6cae301593ab556

.config/e2e-smoke-selection.txt

@@ -1 +1 @@
-sha256=6d18f9cce820c51d5589de944e8cc185f73eeca0ea9a9916651943e3759169d0
+sha256=5db88c6fec94d4f269c7d9cfc128bd2adc27b3d7021127e2fa0b1daccc5f900f

.config/make/tests.mak

@@ -47,7 +47,6 @@ script-tests: ## Run shell script tests
 	bash -n ./scripts/validate_object_data_cache_cold_stampede.sh
 	$(RUSTFS_PYTHON_BIN) ./scripts/check_object_data_cache_follower_samples.py --self-test
 	./scripts/validate_object_data_cache_cold_stampede.sh --self-test
-	./scripts/run_scanner_heal_evidence_case.sh --self-test
 
 .PHONY: test
 test: core-deps script-tests ## Run all tests (needs cargo-nextest; RUSTFS_ALLOW_CARGO_TEST_FALLBACK=1 to override)

.config/scanner-heal-required-tests.json

@@ -8,26 +8,10 @@
       "suite": "e2e_test",
       "name": "heal_erasure_disk_rebuild_test::tests::test_cluster_root_heal_recovers_remote_shards_after_background_target_restart",
       "oracle": "background-target-restart.json",
-      "evidence": "process-restart",
-      "unclean_shutdown_marker": false,
       "min_objects": 9,
       "max_objects": 65,
       "topology": {"nodes": 4, "drives_per_node": 1},
       "scope": "Target process restart, exact unversioned S3 bodies and replacement-disk shards; not power loss or EC8+4."
-    },
-    "background-target-crash": {
-      "gate": "G14",
-      "task": "W21",
-      "lane": "e2e-nightly",
-      "suite": "e2e_test",
-      "name": "heal_erasure_disk_rebuild_test::tests::test_cluster_root_heal_recovers_remote_shards_after_background_target_crash",
-      "oracle": "background-target-crash.json",
-      "evidence": "process-crash-restart",
-      "unclean_shutdown_marker": true,
-      "min_objects": 9,
-      "max_objects": 65,
-      "topology": {"nodes": 4, "drives_per_node": 1},
-      "scope": "Target process killed during partial background rebuild, real unclean-shutdown marker, exact unversioned S3 bodies and replacement-disk shards; not power loss or EC8+4."
     }
   },
   "release_pending": {

.config/security-smoke-floor.txt

@@ -9,4 +9,4 @@
 # if the selected count drops below this number, so a rename or removal that
 # thins the security smoke gate must update this file in the same PR.
 # Adding tests does not require a bump, but bumping keeps the guard tight.
-26
+18

.github/workflows/ci.yml

@@ -582,59 +582,13 @@ jobs:
           install-build-packaging-tools: 'false'
 
       - name: Build debug binary
-        run: |
-          python3 - <<'PYBUILD'
-          import hashlib
-          import json
-          import os
-          import pathlib
-          import subprocess
-
-          def git(*args):
-              return subprocess.check_output(["git", *args], text=True).strip()
-
-          def sha256(path):
-              digest = hashlib.sha256()
-              with pathlib.Path(path).open("rb") as source:
-                  for chunk in iter(lambda: source.read(1024 * 1024), b""):
-                      digest.update(chunk)
-              return digest.hexdigest()
-
-          argv = ["cargo", "build", "-p", "rustfs", "--bins", "--features", "e2e-test-hooks"]
-          commit, tree = git("rev-parse", "HEAD"), git("rev-parse", "HEAD^{tree}")
-          clean_before = not git("status", "--porcelain", "--untracked-files=normal")
-          if not clean_before:
-              raise SystemExit("hooks binary requires a clean build checkout")
-          lock_sha256 = sha256("Cargo.lock")
-          lock_git_blob = git("hash-object", "Cargo.lock")
-          rustc = subprocess.check_output(["rustc", "-vV"], text=True)
-          host = next(line.removeprefix("host: ") for line in rustc.splitlines() if line.startswith("host: "))
-          if os.environ.get("CARGO_BUILD_TARGET") or pathlib.Path(os.environ.get("CARGO_TARGET_DIR", "target")).resolve() != pathlib.Path("target").resolve():
-              raise SystemExit("this artifact requires the native target/debug output")
-          subprocess.run(argv, check=True)
-          clean_after = not git("status", "--porcelain", "--untracked-files=normal")
-          if not clean_after or commit != git("rev-parse", "HEAD") or tree != git("rev-parse", "HEAD^{tree}") or lock_sha256 != sha256("Cargo.lock"):
-              raise SystemExit("hooks binary source changed while building")
-          manifest = {
-              "schema": 1, "commit": commit, "tree": tree,
-              "clean_before": clean_before, "clean_after": clean_after,
-              "lock_sha256": lock_sha256, "lock_git_blob": lock_git_blob,
-              "argv": argv, "profile": "debug", "target": host,
-              "features": ["e2e-test-hooks"],
-              "rustc_verbose": rustc,
-              "build_flags": {key: os.environ[key] for key in ("RUSTFLAGS", "CARGO_ENCODED_RUSTFLAGS", "CARGO_BUILD_TARGET", "CARGO_TARGET_DIR", "RUSTUP_TOOLCHAIN") if key in os.environ},
-              "binary_sha256": sha256("target/debug/rustfs"),
-          }
-          pathlib.Path("target/debug/rustfs.e2e-startup-cas-build.json").write_text(json.dumps(manifest, indent=2) + "\n")
-          PYBUILD
+        run: cargo build -p rustfs --bins --features e2e-test-hooks
 
       - name: Upload debug binary
         uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
         with:
           name: rustfs-debug-binary
-          path: |
-            target/debug/rustfs
-            target/debug/rustfs.e2e-startup-cas-build.json
+          path: target/debug/rustfs
           if-no-files-found: error
           retention-days: 1
 
@@ -958,36 +912,6 @@ jobs:
       - name: Make binary executable
         run: chmod +x ./target/debug/rustfs
 
-      - name: Preserve startup CAS binary input
-        env:
-          STARTUP_CAS_INPUT: ${{ runner.temp }}/rustfs-startup-cas-input
-        run: |
-          python3 - <<'PYINPUT'
-          import hashlib
-          import json
-          import os
-          import pathlib
-          import shutil
-          import subprocess
-
-          source = pathlib.Path("target/debug/rustfs")
-          manifest_path = source.with_name("rustfs.e2e-startup-cas-build.json")
-          manifest = json.loads(manifest_path.read_text())
-          target = pathlib.Path(os.environ["STARTUP_CAS_INPUT"])
-          target.mkdir(parents=True, exist_ok=True)
-          binary = target / "rustfs"
-          shutil.copy2(source, binary)
-          digest = hashlib.sha256()
-          with binary.open("rb") as stream:
-              for chunk in iter(lambda: stream.read(1024 * 1024), b""):
-                  digest.update(chunk)
-          commit = subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip()
-          if manifest["binary_sha256"] != digest.hexdigest() or manifest["commit"] != commit:
-              raise SystemExit("downloaded hooks binary identity mismatch")
-          shutil.copy2(manifest_path, target / manifest_path.name)
-          binary.chmod(0o755)
-          PYINPUT
-
       - name: Verify e2e full membership
         env:
           NEXTEST_LISTING: ${{ runner.temp }}/rustfs-e2e-full-list.json
@@ -1000,10 +924,6 @@ jobs:
       # extend that filter, never add ad-hoc e2e jobs here. Reuses the downloaded
       # debug binary; each test spawns its own rustfs server on a random port.
       - name: Run e2e full suite
-        env:
-          RUSTFS_E2E_STARTUP_CAS_BINARY: ${{ runner.temp }}/rustfs-startup-cas-input/rustfs
-          RUSTFS_E2E_STARTUP_CAS_BUILD_MANIFEST: ${{ runner.temp }}/rustfs-startup-cas-input/rustfs.e2e-startup-cas-build.json
-          RUSTFS_E2E_STARTUP_CAS_ARTIFACT_DIR: ${{ runner.temp }}/rustfs-startup-cas-evidence
         run: cargo nextest run --profile e2e-full -p e2e_test
 
       - name: Upload junit
@@ -1016,17 +936,6 @@ jobs:
             ${{ runner.temp }}/rustfs-e2e-full-list.json
           retention-days: 7
 
-      - name: Upload startup CAS evidence
-        if: always()
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
-        with:
-          name: fresh-startup-cas-evidence-${{ github.run_number }}
-          path: |
-            ${{ runner.temp }}/rustfs-startup-cas-evidence
-            ${{ runner.temp }}/rustfs-startup-cas-input/rustfs.e2e-startup-cas-build.json
-          if-no-files-found: warn
-          retention-days: 7
-
   e2e-tests-rio-v2:
     name: End-to-End Tests (rio-v2)
     # Inherits the schedule/dispatch-only gate through needs: on every other

.github/workflows/e2e-upgrade.yml

@@ -82,14 +82,6 @@ jobs:
             cache_key: e2e-odm-config-rollback
             test: rc5_rollback_requires_restoring_odm_configuration
             artifact: odm-config-rollback
-          - name: Multipart layouts survive the rc.5 upgrade
-            cache_key: e2e-multipart-layout-upgrade
-            test: direct_upgrade_from_rc5_preserves_multipart_layouts
-            artifact: multipart-layout-upgrade
-          - name: rc.5 multipart replication baseline
-            cache_key: e2e-multipart-layout-baseline
-            test: rc5_baseline_replicates_multipart_layouts
-            artifact: multipart-layout-baseline
     runs-on: ubuntu-latest
     timeout-minutes: 60
     env:

.github/workflows/star-history.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: overtrue/repo-visuals-action@ee2c632f6ce617e851fb46ea935ee8af762ebb93 # v1.4.0
+      - uses: overtrue/repo-visuals-action@fd79cba437ecfac933d00a69add17eb95d3939c3 # v1.3.1
         with:
           github-token: ${{ github.token }}
           output-branch: star-history

AGENTS.md

@@ -7,11 +7,8 @@ This file contains repository-wide rules. Use the nearest subdirectory
 
 1. System/developer instructions.
 2. The current user request.
-3. Applicable `AGENTS.md` files, with the nearest file winning conflicts.
-4. Selected skills and reference documents.
-
-Nested instructions add to ancestor rules; they do not discard non-conflicting
-rules. A skill cannot expand the user's requested scope or grant authorization.
+3. The nearest `AGENTS.md`.
+4. This file.
 
 ## Operating Model
 
@@ -24,29 +21,63 @@ rules. A skill cannot expand the user's requested scope or grant authorization.
 - Do not load every skill or inspect unrelated modules preemptively. Select a
   skill only when its description directly matches the request or changed
   surface.
-- Resolve repository workflow skills under `.agents/skills/` when a global
-  skill has the same name, unless the user explicitly selects another path.
 - Avoid repeated reads and equivalent verification commands once enough
   evidence exists.
-- Search for relevant symbols/headings before reading long files; return only
-  matching ranges. If output is truncated, narrow the query instead of repeating
-  a full read. Keep reusable raw logs in task artifacts and report the evidence.
-- Reuse authorization already given in the conversation. Resolve routine choices
-  within that scope and continue independent work while a material question is
-  pending. Before requesting missing approval, prepare the concrete result that
-  is already authorized; retain explicit merge and release gates.
 
-## Task-Specific Guidance
+## Worktree and Disk Hygiene
 
-Read only the reference needed for the current task, once per unchanged context:
+- Start implementation from the latest `origin/main` and confirm the requested
+  change is not already present.
+- An existing clean, isolated task worktree is sufficient. Create another
+  worktree only when the current checkout is shared, dirty with unrelated work,
+  or belongs to another task.
+- Never commit from a shared checkout.
+- Use a task-specific branch named `<type>/<topic>`, such as `fix/...`,
+  `feat/...`, `test/...`, or `docs/...`, unless the user specifies a name.
+- Do not include agent, tool, contributor, account, or organization names in
+  branch names.
+- Push to the user-requested remote or the repository's configured push remote.
+  Do not hard-code or infer a remote from an account name.
+- Check free space before artifact-heavy builds, tests, coverage, or downloads.
+  Re-check before a broad gate when space is tight.
+- Remove only task-owned temporary/build artifacts. Never delete another task's
+  worktree or uncommitted data.
+- At handoff, mention disk or cleanup details only when they affected execution
+  or artifacts/worktrees remain intentionally.
 
-- Before code changes or artifact-heavy work, read [implementation rules](.agents/references/implementation.md).
-  For a read-only code review, use its change-style and boundary sections as needed.
-- Before commits, pushes, PR creation/updates, or posting to PRs/issues/discussions,
-  read [Git and PR rules](.agents/references/pull-requests.md).
-  Reuse existing authorization; a reference does not authorize posting, merging, or publishing.
-- Preserve unrelated work. Never commit from a shared checkout or delete another task's artifacts.
-- Source comments, commits, PR titles, and PR bodies are in English.
+## Change Style
+
+- Preserve existing control flow unless changing it is required for correctness.
+- Prefer a direct local edit over new files, wrappers, managers, or speculative
+  abstractions.
+- Add a helper only when it removes current duplication, names a real domain
+  boundary, or isolates a non-trivial invariant.
+- Remove an in-scope path superseded by the change. If compatibility requires it,
+  adapt at the boundary to one canonical core and use the repository's
+  `RUSTFS_COMPAT_TODO` policy.
+- Comments explain non-obvious invariants or reasons. Do not narrate code or
+  record change history.
+- Mention unrelated problems when useful; do not fix them in a narrow task.
+
+## Reuse and Boundary Rules
+
+- Before adding helpers, constants, fixtures, or wrappers, search the touched
+  crate, the domain-owning crate, `crates/utils`, `crates/common`, and relevant
+  direct dependencies.
+- Reuse requires matching semantics: normalization, error types, deadlines,
+  durability, and compatibility must fit the call site. A narrowly named local
+  helper is better than forced reuse with different semantics.
+- Validate untrusted input at its trust boundary, then trust the validated type.
+  Values crossing disk, RPC, persistence, or version boundaries remain
+  untrusted at every consumer.
+- Re-check boundary values immediately before destructive actions such as
+  delete, overwrite, or quorum decisions.
+- Every new branch needs a concrete triggering input/state. For decoded or peer
+  data, corruption and mixed-version input are valid triggers.
+- Required values must return a typed error when absent or corrupt; do not use a
+  default that converts corruption into a plausible result.
+- Attach error context once where it is actionable. Do not erase typed errors
+  below aggregation or quorum layers.
 
 ## Sources of Truth
 
@@ -116,25 +147,73 @@ requested adversarial/design reviews, and agent-instruction changes that alter
 execution. Ordinary questions, diagnoses, status reports, non-adversarial code
 reviews, and low-risk planning do not trigger it.
 
-For applicable work and substantial PR reviews, read the [risk tiers and review shape](.agents/references/adversarial-validation.md).
-Load only the matching domain probes; ordinary reviews do not become adversarial
-merely because this reference exists.
+Risk and review shape:
 
-A review has no finding quota; `No findings` is a complete outcome. A request to
-find problems is not evidence that a defect exists. Before reporting a candidate,
-check callers, invariants, and existing tests for evidence that disproves it.
-Findings need `file:line` and a concrete failure or violation of an explicit
-requirement. Missing required tests/checks are verification gaps, not proof of a
-runtime bug; name the unprotected behavior or unmet gate. Keep optional style or
-refactoring preferences out of defect findings unless that review was requested.
+- **Exempt:** documentation, comments, formatting, or typos with no runtime,
+  build, test, or agent-execution effect.
+- **Mechanical:** renames, moves, test/tooling-only changes, and agent-rule
+  changes. Run correctness and simplicity lenses.
+- **Standard:** localized behavior changes. Run one integrated final-diff pass
+  covering correctness, simplicity, and test coverage; add only domain lenses
+  matched by the diff.
+- **High risk / substantial PR review:** high risk includes locking,
+  erasure/quorum/heal, replication, multipart, RPC, lifecycle/tiering,
+  persistence/fsync, IAM/KMS/auth, cryptography, on-disk/on-wire formats, and
+  S3-visible semantics. Cover all applicable lenses using exactly two
+  independent reviewers when delegation is explicitly authorized. Split the
+  lenses between them. Otherwise perform two fresh sequential passes.
+- **Outbound client defaults:** what `TargetClient`, `PutObjectOptions`, or
+  the remote SDK configuration sends to every replication or migration target
+  is high risk for every target class even when the change fixes one. Follow
+  the SOP in `docs/postmortems/2026-09-03-replication-checksum-default-regression.md`:
+  run the outbound target matrix, document each new env knob in the same PR,
+  and list verified and unverified target classes in the PR Impact section.
 
-Fix or rebut supported findings within the authorized scope. Once the required
-passes are complete, stop. Reopen only for changed code, new evidence, an
-unresolved finding, or an explicit re-review request; an unchanged diff does not
-need another pass at every conversation turn or workflow handoff.
+Available domain lenses are security, concurrency/durability, compatibility,
+and performance. Select `.agents/skills/adversarial-validation/SKILL.md` for an
+explicit adversarial request, a high-risk change, or a substantial PR review;
+then read only its matching role references. A routine standard pass does not
+load the playbook unless the reviewer needs a RustFS-specific probe.
+
+A finding must name a concrete input/state/interleaving and wrong outcome, or a
+specific missing regression check, with `file:line`. Resolve it by fixing the
+diff or rebutting it with code-path/test/invariant evidence. After a non-trivial
+fix, rerun only affected lenses.
 
 For high-risk PRs, record one concise verdict per covered lens in the PR body.
 
+## Pull Request Lifecycle
+
+- Creating or updating a PR includes one immediate snapshot of checks,
+  mergeability, reviews, and unresolved threads.
+- Unless the user explicitly requests monitoring, a release workflow requires
+  it, or an automation already owns it, hand off after the PR is open with the
+  current state and next event to watch. Do not delay ordinary handoff with
+  fixed quiet-period sleeps.
+- For requested monitoring, use event-driven or bounded waits. Report only state
+  changes, actionable failures, or a meaningful prolonged delay.
+- Investigate failures/comments before changing code. Fix task-attributable
+  issues, rerun affected verification, push, reply or resolve the thread, then
+  resume the requested monitor.
+- Never merge without required reviewer approval or explicit authority.
+- After an observed merge, verify the commit reached the base, then clean the
+  task worktree/branch when safe. Preserve unmerged work for closed PRs unless
+  deletion was explicitly authorized.
+
+## Git and PR Baseline
+
+- Follow Conventional Commits; keep the subject at most 72 characters.
+- Source comments, commits, PR titles, and PR bodies are in English.
+- Keep every heading from `.github/pull_request_template.md`; use `N/A` where
+  needed and include commands actually run.
+- Use `--body-file` for multiline `gh pr create`/`gh pr edit` content.
+- PR/issue/discussion content must not contain the literal sequence `\n` or
+  hard-wrapped prose paragraphs.
+- Do not include local absolute paths or tool-specific labels/prefixes in GitHub
+  content.
+- Resolve review threads after the underlying issue is fixed. If declining a
+  suggestion, reply with a short evidence-based reason.
+
 ## Security Baseline
 
 - Never commit secrets, credentials, or key material.
@@ -171,6 +250,12 @@ Use `.agents/skills/rustfs-logging-governance/SKILL.md` for logging changes.
 - `DataUsageCacheInfo` and `DataUsageEntry` keep their hand-written map
   serialization and new fields remain `#[serde(default)]` for older readers.
 
+## Naming
+
+Use Rust API naming: `SCREAMING_SNAKE_CASE` constants/statics, `snake_case`
+functions/variables, and `PascalCase` types. Do not rename unrelated existing
+violations.
+
 ## Scoped Guidance
 
 Before editing, locate the nearest instructions with:
@@ -180,4 +265,4 @@ git ls-files '*AGENTS.md'
 ```
 
 The nearest file wins for domain invariants. Keep generic workflow and
-validation policy in this root file and its task-specific references.
+validation policy in this root file.

CHANGELOG.md

@@ -7,11 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Security
-- **Presigned URLs honour only signed headers** (GHSA-g8w9-qw9q-fghr): a SigV4 presigned request that carries an `x-amz-*` request header not listed in `X-Amz-SignedHeaders` is now rejected with `403 AccessDenied` ("There were headers present in the request which were not signed"), matching AWS S3. Previously the holder of a presigned `PutObject` URL could add unsigned `x-amz-tagging`, `x-amz-storage-class`, `x-amz-website-redirect-location`, ACL, metadata, Object Lock or SSE headers and have them applied. Presigners that intend a property must set it before signing so the SDK lists the header in `SignedHeaders`; `x-amz-cf-id` (CloudFront) remains tolerated unsigned. Header-signed SigV4 and SigV2 requests are unchanged.
-
 ### Fixed
-- **Multipart admission queue**: an `UploadPart` waiting for a foreground write permit now waits at most 10 s by default (`RUSTFS_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS`, previously 30 s), so a queued part returns S3 `SlowDown` before the client's socket write timeout drops the connection. Separately, the API listener no longer forces a 4 MiB `SO_RCVBUF` on every accepted socket (kernel autotuning applies; `RUSTFS_HTTP_SOCKET_RECV_BUFFER_BYTES` restores a fixed size), so a queued part no longer lets up to 8 MiB of unread body accumulate in kernel memory per connection, which is what throttled whole nodes under SDK-default multipart concurrency. Fixes #7385.
 - **Helm Ingress**: `customAnnotations` are now merged with class-specific annotations (nginx/traefik) instead of being ignored when `ingress.className` is set.
 - **Per-pool erasure parity**: Erasure parity (STANDARD and reduced-redundancy) is now resolved independently for every pool instead of reusing the first pool's value. A heterogeneous topology — for example a 4-drive pool plus a 2-drive pool created during expansion — previously inherited the first pool's parity and could resolve to zero data shards in the smaller pool, panicking Reed-Solomon construction on write. Automatic parity now resolves per pool (for example `2+2` in the 4-drive pool and `1+1` in the 2-drive pool). Fixes #4801.
 

CLAUDE.md

@@ -13,7 +13,7 @@ what Claude Code needs on top: commands and pointers.
 cargo build --release --bin rustfs   # production binary
 cargo check -p <crate>               # fast type-check one crate
 cargo test -p <crate>                # test one crate
-cargo fmt --all --check              # for Rust changes; see AGENTS.md verification tiers
+cargo fmt --all                      # format (required before PR)
 make pre-commit                      # fast gate: fmt + arch checks + quick-check (NO clippy/tests)
 make pre-pr                          # optional full gate for broad cross-module changes
 make build-docker BUILD_OS=ubuntu22.04
@@ -42,5 +42,5 @@ make build-docker BUILD_OS=ubuntu22.04
 
 Repo-wide domain invariants (dual internal metadata keys, defensive UUID
 reads, unversioned tier buckets) live in [AGENTS.md](AGENTS.md) under
-"Cross-Cutting Storage Invariants" — read them before touching metadata or
+"Cross-Cutting Domain Invariants" — read them before touching metadata or
 tiering code.

Cargo.lock

@@ -4057,7 +4057,6 @@ dependencies = [
  "sha1 0.11.0",
  "sha2 0.11.0",
  "suppaftp",
- "tempfile",
  "time",
  "tokio",
  "tokio-stream",
@@ -9907,7 +9906,6 @@ dependencies = [
  "regex",
  "rmp",
  "rmp-serde",
- "rustfs-config",
  "rustfs-utils",
  "s3s",
  "serde",

README.md

@@ -109,15 +109,6 @@ Star RustFS on GitHub and be instantly notified of new releases.
 
 ## Quickstart
 
-> [!IMPORTANT]
-> **Pool expansion notice:**
->
-> - A single-node single-drive (SNSD) deployment is supported only as a standalone local path. It cannot expand in place or be added as a Pool. To move to a multi-drive topology, create a new deployment and migrate data through S3.
-> - Keep an existing multi-drive Pool's endpoints and Erasure Set width unchanged; expand by appending a new Pool. With ellipsis-based expansion, every Pool argument must contain an ellipsis expression and expand to at least two drive endpoints.
-> - Single-node multi-drive Pools and multi-node Pools with one drive per node are allowed, subject to valid Erasure Set geometry and EC settings; acceptance does not guarantee host-failure tolerance.
->
-> These topology rules follow MinIO, but automatic parity selection differs between the projects. See the [Pool layout compatibility and regression tests](docs/testing/pool-layout-compatibility.md) before expanding a deployment.
-
 To get started with RustFS, follow these steps:
 
 ### 1. One-click Installation (Option 1)

README_ZH.md

@@ -89,15 +89,6 @@ RustFS 是一个基于 Rust 构建的高性能分布式对象存储系统。Rust
 
 ## 快速开始
 
-> [!IMPORTANT]
-> **Pool 扩容 Notice：**
->
-> - 单节点单盘（SNSD）部署仅支持使用本地路径独立运行，不支持原地扩容，也不能作为 Pool 加入集群。如需改为多盘拓扑，请创建新部署并通过 S3 迁移数据。
-> - 已有多盘 Pool 的端点和 Erasure Set 宽度应保持不变，扩容应追加新的 Pool。使用省略号表达式扩容时，每个 Pool 参数都必须包含省略号表达式，并展开为至少两个磁盘端点。
-> - 允许单节点多盘 Pool，也允许多节点、每节点一盘的 Pool，但必须满足 Erasure Set 布局和 EC 配置要求；配置合法不代表能够容忍整台主机故障。
->
-> 这些拓扑规则与 MinIO 一致，但两者的默认 parity 选择方式存在差异。扩容前请阅读 [Pool 布局兼容性与回归测试说明](docs/testing/pool-layout-compatibility.md)。
-
 请按照以下步骤快速上手 RustFS：
 
 ### 1. 一键安装脚本 (选项 1)

crates/AGENTS.md

@@ -33,11 +33,8 @@ Applies to all paths under `crates/`.
 
 ## Type Casting
 
-- Never use `as` for numeric conversions that may truncate or overflow. Use
-  `try_into()` with typed error handling; clamp or saturate only when the domain
-  explicitly requires it.
-- Before converting floating-point input to an integer, validate finiteness,
-  sign, and the destination range. A lower-bound clamp alone is insufficient.
+- Never use `as` for numeric conversions that may truncate or overflow. Use `try_into()` with explicit error handling, or clamp with `value.max(0) as usize` when the domain is bounded.
+- `f64 as usize` saturates but is fragile; clamp to `[0, usize::MAX as f64]` first.
 - Treat every `as` cast in a PR review as a potential bug; require justification.
 
 ## Testing

crates/common/src/mrf_channel.rs

@@ -90,61 +90,6 @@ pub struct MrfIntent {
     pub attempts: u8,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MrfDurableRepairAnchor {
-    pub kind: MrfKind,
-    pub bucket: Arc<str>,
-    pub object: Arc<str>,
-    pub version_id: Option<[u8; 16]>,
-    pub scope: Option<MrfScope>,
-    pub lease: MrfIngressLease,
-    pub bucket_incarnation_id: Uuid,
-}
-
-impl MrfDurableRepairAnchor {
-    /// Build a dischargeable anchor only when the caller supplies the storage
-    /// incarnation and the original ingress lease. Legacy replay records lack
-    /// both pieces and therefore remain fail-closed.
-    pub fn from_intent(intent: &MrfIntent, bucket_incarnation_id: Uuid) -> Option<Self> {
-        if bucket_incarnation_id.is_nil() {
-            return None;
-        }
-        let lease = intent.lease?;
-        let (version_id, scope) = canonical_identity(intent.kind, intent.version_id, intent.scope);
-        Some(Self {
-            kind: intent.kind,
-            bucket: intent.bucket.clone(),
-            object: intent.object.clone(),
-            version_id,
-            scope,
-            lease,
-            bucket_incarnation_id,
-        })
-    }
-
-    pub fn is_proven_by(&self, event: &MrfVerifiedRepairEvent) -> bool {
-        let Some(lease) = event.lease else {
-            return false;
-        };
-        self.kind == event.kind
-            && self.bucket == event.bucket
-            && self.object == event.object
-            && self.version_id == event.version_id
-            && self.scope == event.scope
-            && self.lease == lease
-            && self.bucket_incarnation_id == event.bucket_incarnation_id
-    }
-}
-
-/// Consume only anchors proven by a complete verified-repair identity. The
-/// caller remains responsible for persisting the resulting anchor set before
-/// deleting older replay files.
-pub fn consume_verified_mrf_repair_events(anchors: &mut Vec<MrfDurableRepairAnchor>, events: &[MrfVerifiedRepairEvent]) -> usize {
-    let before = anchors.len();
-    anchors.retain(|anchor| !events.iter().any(|event| anchor.is_proven_by(event)));
-    before.saturating_sub(anchors.len())
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct MrfScope {
     pub pool_index: u32,
@@ -441,27 +386,6 @@ pub fn try_send_mrf_intent_typed(
     }
 }
 
-/// Acquire a fresh process-local lease for one durable replay record.
-///
-/// Journal records deliberately do not persist leases. A replay consumer must
-/// call this before submitting the record so a later verified repair event can
-/// identify the exact replay admission. Replay does not reserve the live
-/// producer coalescer key: the replay queue first deduplicates legacy records,
-/// then manager admission owns task-level deduplication with live producers.
-pub fn try_rearm_mrf_replay_intent(intent: &mut MrfIntent) -> MrfIngressResult {
-    if intent.lease.is_some() {
-        return MrfIngressResult::Enqueued;
-    }
-    if intent.bucket.len() > MRF_MAX_IDENTITY_COMPONENT || intent.object.len() > MRF_MAX_IDENTITY_COMPONENT {
-        return MrfIngressResult::Dropped(MrfDropReason::OversizedIdentity);
-    }
-    let (version_id, scope) = canonical_identity(intent.kind, intent.version_id, intent.scope);
-    intent.version_id = version_id;
-    intent.scope = scope;
-    intent.lease = Some(MrfIngressLease::new(NEXT_MRF_LEASE.fetch_add(1, Ordering::Relaxed)));
-    MrfIngressResult::Enqueued
-}
-
 /// Release the ingress key once the consumer owns the intent.
 pub fn release_mrf_intent(intent: &MrfIntent) {
     release_mrf_identity(intent.kind, &intent.bucket, &intent.object, intent.version_id, intent.scope, intent.lease);
@@ -508,33 +432,12 @@ pub struct MrfRepairedEvent {
     pub version_id: Option<[u8; 16]>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MrfVerifiedRepairDisposition {
-    Repaired,
-    VerifiedHealthy,
-    AuthoritativelyAbsent,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MrfVerifiedRepairEvent {
-    pub kind: MrfKind,
-    pub bucket: Arc<str>,
-    pub object: Arc<str>,
-    pub version_id: Option<[u8; 16]>,
-    pub scope: Option<MrfScope>,
-    pub lease: Option<MrfIngressLease>,
-    pub bucket_incarnation_id: Uuid,
-    pub disposition: MrfVerifiedRepairDisposition,
-}
-
 /// Bound on the repaired-event backlog. Notices are best-effort hints; when
 /// the ring is full the oldest are dropped and the affected ledger entries
 /// simply expire through their own attempts/age limits.
 const MRF_REPAIRED_EVENT_CAP: usize = 4096;
 
 static MRF_REPAIRED_EVENTS: OnceLock<std::sync::Mutex<std::collections::VecDeque<MrfRepairedEvent>>> = OnceLock::new();
-static MRF_VERIFIED_REPAIR_EVENTS: OnceLock<std::sync::Mutex<std::collections::VecDeque<MrfVerifiedRepairEvent>>> =
-    OnceLock::new();
 
 /// Record a legacy notification for compatibility. This is not an
 /// acknowledgement of storage verification or durable repair completion.
@@ -575,43 +478,6 @@ pub fn take_mrf_repaired_events_for(bucket: &str) -> Vec<MrfRepairedEvent> {
     taken
 }
 
-/// Record a storage-owned MRF completion proof. Unlike the legacy repaired
-/// event, this identity is complete enough for future durable ledgers to make
-/// an exact responsibility decision.
-pub fn note_mrf_verified_repair(event: MrfVerifiedRepairEvent) {
-    let registry = MRF_VERIFIED_REPAIR_EVENTS.get_or_init(|| std::sync::Mutex::new(std::collections::VecDeque::new()));
-    let Ok(mut events) = registry.lock() else {
-        return;
-    };
-    if events.len() >= MRF_REPAIRED_EVENT_CAP {
-        events.pop_front();
-    }
-    events.push_back(event);
-}
-
-/// Take verified repair events recorded for `bucket`, leaving other buckets'
-/// proofs in place. Consumers still have to match kind, object, version, scope
-/// lease and incarnation before discharging durable responsibility.
-pub fn take_mrf_verified_repair_events_for(bucket: &str) -> Vec<MrfVerifiedRepairEvent> {
-    let Some(registry) = MRF_VERIFIED_REPAIR_EVENTS.get() else {
-        return Vec::new();
-    };
-    let Ok(mut events) = registry.lock() else {
-        return Vec::new();
-    };
-    let mut taken = Vec::new();
-    let mut retained = std::collections::VecDeque::with_capacity(events.len());
-    while let Some(event) = events.pop_front() {
-        if event.bucket.as_ref() == bucket {
-            taken.push(event);
-        } else {
-            retained.push_back(event);
-        }
-    }
-    *events = retained;
-    taken
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -680,147 +546,6 @@ mod tests {
         assert_eq!(metadata_scope, None);
     }
 
-    #[test]
-    fn durable_repair_anchor_requires_lease_and_bucket_incarnation() {
-        let mut intent = MrfIntent {
-            bucket: Arc::from("durable-anchor-bucket"),
-            object: Arc::from("object"),
-            version_id: Some([0; 16]),
-            kind: MrfKind::PartialWrite,
-            scope: Some(MrfScope {
-                pool_index: 1,
-                set_index: 2,
-            }),
-            lease: None,
-            enqueued_at_ms: 0,
-            attempts: 0,
-        };
-        assert!(
-            MrfDurableRepairAnchor::from_intent(&intent, Uuid::new_v4()).is_none(),
-            "legacy replay records without the ingress lease must remain anchored"
-        );
-
-        intent.lease = Some(MrfIngressLease::new(7));
-        assert!(
-            MrfDurableRepairAnchor::from_intent(&intent, Uuid::nil()).is_none(),
-            "nil bucket incarnation cannot prove durable successor ownership"
-        );
-
-        let anchor = MrfDurableRepairAnchor::from_intent(&intent, Uuid::new_v4())
-            .expect("complete identity should create a durable repair anchor");
-        assert_eq!(anchor.version_id, None, "nil UUID is canonicalized before matching");
-        assert_eq!(
-            anchor.scope,
-            Some(MrfScope {
-                pool_index: 1,
-                set_index: 2
-            })
-        );
-    }
-
-    #[test]
-    fn durable_replay_rearm_assigns_a_fresh_dischargeable_lease() {
-        let unique = Uuid::new_v4();
-        let mut intent = MrfIntent {
-            bucket: Arc::from(format!("replay-{unique}")),
-            object: Arc::from("object"),
-            version_id: Some([0; 16]),
-            kind: MrfKind::PartialWrite,
-            scope: Some(MrfScope {
-                pool_index: 2,
-                set_index: 3,
-            }),
-            lease: None,
-            enqueued_at_ms: 1,
-            attempts: 0,
-        };
-
-        assert_eq!(try_rearm_mrf_replay_intent(&mut intent), MrfIngressResult::Enqueued);
-        assert_eq!(intent.version_id, None, "nil versions remain canonical during replay");
-        assert!(intent.lease.is_some(), "replay admission must carry a fresh lease");
-        assert!(
-            MrfDurableRepairAnchor::from_intent(&intent, Uuid::new_v4()).is_some(),
-            "a rearmed replay record can participate in exact durable proof matching"
-        );
-        release_mrf_intent(&intent);
-    }
-
-    #[test]
-    fn verified_repair_events_consume_only_exact_durable_anchors() {
-        let bucket = Arc::<str>::from("proof-bucket");
-        let object = Arc::<str>::from("object");
-        let incarnation = Uuid::new_v4();
-        let lease = MrfIngressLease::new(11);
-        let anchor = MrfDurableRepairAnchor {
-            kind: MrfKind::PartialWrite,
-            bucket: bucket.clone(),
-            object: object.clone(),
-            version_id: Some([3; 16]),
-            scope: Some(MrfScope {
-                pool_index: 4,
-                set_index: 5,
-            }),
-            lease,
-            bucket_incarnation_id: incarnation,
-        };
-        let event = MrfVerifiedRepairEvent {
-            kind: anchor.kind,
-            bucket,
-            object,
-            version_id: anchor.version_id,
-            scope: anchor.scope,
-            lease: Some(lease),
-            bucket_incarnation_id: incarnation,
-            disposition: MrfVerifiedRepairDisposition::Repaired,
-        };
-
-        for rejected in [
-            MrfVerifiedRepairEvent {
-                lease: None,
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                lease: Some(MrfIngressLease::new(12)),
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                bucket_incarnation_id: Uuid::new_v4(),
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                version_id: Some([4; 16]),
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                scope: Some(MrfScope {
-                    pool_index: 4,
-                    set_index: 6,
-                }),
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                kind: MrfKind::DecodeFailure,
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                bucket: Arc::from("other-bucket"),
-                ..event.clone()
-            },
-            MrfVerifiedRepairEvent {
-                object: Arc::from("other"),
-                ..event.clone()
-            },
-        ] {
-            let mut retained = vec![anchor.clone()];
-            assert_eq!(consume_verified_mrf_repair_events(&mut retained, &[rejected]), 0);
-            assert_eq!(retained, vec![anchor.clone()]);
-        }
-
-        let mut retained = vec![anchor];
-        assert_eq!(consume_verified_mrf_repair_events(&mut retained, &[event]), 1);
-        assert!(retained.is_empty());
-    }
-
     #[tokio::test]
     async fn try_send_delivers_and_respects_capacity() {
         let mut receiver = init_mrf_channel().expect("first initialization should succeed");
@@ -885,32 +610,4 @@ mod tests {
         assert_eq!(flooded.len(), MRF_REPAIRED_EVENT_CAP);
         assert_eq!(flooded[0].object.as_ref(), "object-9", "the oldest notices past the cap are dropped");
     }
-
-    #[test]
-    fn verified_repair_events_preserve_full_identity_and_bucket_scope() {
-        let bucket_incarnation_id = Uuid::new_v4();
-        let event = MrfVerifiedRepairEvent {
-            kind: MrfKind::PartialWrite,
-            bucket: Arc::from("verified-bucket-a"),
-            object: Arc::from("object-a"),
-            version_id: Some([4u8; 16]),
-            scope: Some(MrfScope {
-                pool_index: 2,
-                set_index: 3,
-            }),
-            lease: Some(MrfIngressLease::new(42)),
-            bucket_incarnation_id,
-            disposition: MrfVerifiedRepairDisposition::Repaired,
-        };
-        note_mrf_verified_repair(event.clone());
-        note_mrf_verified_repair(MrfVerifiedRepairEvent {
-            bucket: Arc::from("verified-bucket-b"),
-            ..event.clone()
-        });
-
-        let taken = take_mrf_verified_repair_events_for("verified-bucket-a");
-        assert_eq!(taken, vec![event]);
-        assert!(take_mrf_verified_repair_events_for("verified-bucket-a").is_empty());
-        assert_eq!(take_mrf_verified_repair_events_for("verified-bucket-b").len(), 1);
-    }
 }

crates/config/README.md

@@ -66,11 +66,6 @@ Current guidance:
 
 - `RUSTFS_BROWSER_REDIRECT_URL` sets the externally reachable browser origin used for OIDC callback, console success redirect, and logout fallback URLs. Configure it to the public scheme and authority without a path, for example `https://console.example.com`. In load-balancer deployments, keep OIDC authorize and callback requests on the same backend node because the in-flight OIDC `state` is local to the RustFS node.
 
-## S3 API environment variables
-
-- `RUSTFS_API_OBJECT_MAX_VERSIONS` caps the number of retained versions for a single object. It defaults to `9223372036854775807`, matching MinIO's practical-unlimited default. Set a positive integer to enforce a lower per-object metadata bound.
-- `MINIO_API_OBJECT_MAX_VERSIONS` is accepted as a compatibility alias when the canonical RustFS variable is not set.
-
 ## Distributed endpoint locality
 
 - `RUSTFS_LOCAL_ENDPOINT_HOST` identifies this server's host in a distributed `RUSTFS_VOLUMES` topology without resolving every peer during startup. Set it to exactly one host, without a scheme, port, or path. It is accepted only for orchestrated URL topologies and must match at least one endpoint on the RustFS server port; invalid or unmatched values fail startup. Leave it unset to retain DNS-based locality discovery.
@@ -158,24 +153,14 @@ concurrently. Small direct PUTs stay on the legacy path.
   - default is `0`.
 - `RUSTFS_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS`
   - how long an `UploadPart` waits in the bounded queue for a permit before returning S3 `SlowDown`; `0` rejects immediately when the pool is full.
-  - default is `10000`. Parts wait before body ingest, so SDK-default clients that send every part of an upload concurrently drain through the pool instead of failing on a full pool.
-  - RustFS does not read the request body while a part is queued, so the client's socket write stalls for the whole wait and whatever timeout the client or an intermediary has configured competes with this value. Keep it with margin below the shortest such timeout in use (botocore applies its 60 s `connect_timeout` to the body write; the AWS SDK for Java v2 has a 30 s socket write timeout; reverse proxies add their own body timeouts); a wait that outlives the client timeout surfaces as a dropped connection instead of `SlowDown`.
+  - default is `30000`. Parts wait before body ingest, so SDK-default clients that send every part of an upload concurrently drain through the pool instead of failing.
 - `RUSTFS_PUT_MULTIPART_FOREGROUND_ADMISSION_MAX_PENDING`
   - maximum `UploadPart` requests waiting for a permit at once; parts beyond it return `SlowDown` without waiting.
   - default is `0`, which derives 16 times the permit limit (512 at stock settings).
-  - each queued HTTP/1 part holds whatever unread body the client already pushed into the connection's kernel receive buffer (an HTTP/2 part holds up to its flow-control window in process memory), so this depth also bounds that memory. RustFS leaves the receive buffer to kernel autotuning (see `RUSTFS_HTTP_SOCKET_RECV_BUFFER_BYTES` below), which keeps an unread connection at the kernel's initial size (128 KiB on current Linux).
 - `RUSTFS_PUT_FOREGROUND_ADMISSION_ENABLE`, `RUSTFS_PUT_FOREGROUND_ADMISSION_LIMIT`, `RUSTFS_PUT_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS`
   - experimental strict gate that applies to every foreground write regardless of size and replaces the pool above when enabled.
   - default is disabled; enabling it with limit `0` disables foreground write admission entirely.
 
-## HTTP listener socket environment variables
-
-- `RUSTFS_HTTP_SOCKET_RECV_BUFFER_BYTES`
-  - fixed `SO_RCVBUF` for the API listener, inherited by every accepted socket; `0` leaves the receive buffer to kernel autotuning.
-  - default is `0`. Earlier releases hard-coded 4 MiB, which Linux doubles to 8 MiB and which disables autotuning, so every connection whose body was not being read yet (a multipart part queued for a foreground write permit) could accumulate up to 8 MiB of unread body in kernel memory; at SDK-default multipart concurrency that was enough to push a node into TCP memory pressure.
-  - with autotuning the per-connection receive ceiling is the kernel's (`net.ipv4.tcp_rmem` max, 6 MiB on stock Linux) instead of the former fixed 8 MiB, so a single very high-bandwidth-delay connection may see a somewhat lower ceiling; raise `net.ipv4.tcp_rmem` first, and set this variable only on kernels without receive-buffer autotuning (illumos/Solaris) or where the sysctl cannot be changed.
-  - the send buffer stays fixed at 4 MiB because the stock Linux send autotuning ceiling (`net.ipv4.tcp_wmem` max, 4 MiB) is lower than a GB-level response stream needs.
-
 ## Remote tier timeout environment variables
 
 - `RUSTFS_TIER_REMOTE_CONNECT_TIMEOUT_SECS`

crates/config/src/constants/api.rs

@@ -90,20 +90,3 @@ pub const ENV_API_MAX_CONNECTIONS: &str = "RUSTFS_API_MAX_CONNECTIONS";
 
 /// Default for `RUSTFS_API_MAX_CONNECTIONS` (`0` = unlimited).
 pub const DEFAULT_API_MAX_CONNECTIONS: usize = 0;
-
-/// Maximum retained versions per object.
-///
-/// The default follows MinIO and is effectively unlimited for practical
-/// deployments. Operators can lower it to bound per-object metadata growth.
-/// Environment variable: RUSTFS_API_OBJECT_MAX_VERSIONS
-/// MinIO-compatible alias: MINIO_API_OBJECT_MAX_VERSIONS
-/// Example: RUSTFS_API_OBJECT_MAX_VERSIONS=50000
-pub const ENV_API_OBJECT_MAX_VERSIONS: &str = "RUSTFS_API_OBJECT_MAX_VERSIONS";
-
-/// Default and maximum accepted value for `RUSTFS_API_OBJECT_MAX_VERSIONS`.
-#[cfg(target_pointer_width = "64")]
-pub const DEFAULT_API_OBJECT_MAX_VERSIONS: usize = 9_223_372_036_854_775_807;
-
-/// Default and maximum accepted value for `RUSTFS_API_OBJECT_MAX_VERSIONS`.
-#[cfg(not(target_pointer_width = "64"))]
-pub const DEFAULT_API_OBJECT_MAX_VERSIONS: usize = usize::MAX;

crates/config/src/constants/object.rs

@@ -376,39 +376,21 @@ pub const DEFAULT_PUT_LARGE_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS: u64 = 250;
 ///
 /// SDK-default multipart clients send every part of an upload concurrently, so
 /// a single node routinely sees several times more parts in flight than the
-/// permit pool allows. A queued part waits before body ingest, so the pool
-/// still bounds the number of parts being written, but the wait is not free:
-/// RustFS does not read the request body while the part is queued (hyper only
-/// sends `100 Continue` once the body is first polled, and the AWS SDKs send
-/// the body after a 1-3 s `Expect: 100-continue` grace anyway), so the
-/// client's socket write stalls once the kernel buffers fill, and whatever
-/// timeout the client or an intermediary has configured decides the outcome.
-/// botocore applies its `connect_timeout` (60 s) to the body write, the AWS
-/// SDK for Java v2 has a 30 s socket write timeout, and MinIO bounds the same
-/// wait with a 10 s request deadline. The wait must leave margin under the
-/// shortest of those, not merely fall below an SDK default, so the part
-/// receives S3 `SlowDown`/503 for the client to retry instead of losing its
-/// connection (issue #7385). `0` rejects immediately when the pool is full.
+/// permit pool allows. Those parts have not ingested a body yet, so queueing
+/// them costs a connection rather than memory or internode streams; the pool
+/// still bounds the number of parts being written. The wait is long enough for
+/// an ordinary queue to drain on modest hardware, and a part that cannot get a
+/// permit within it fails with S3 `SlowDown`/503 for the client to retry.
+/// `0` rejects immediately when the pool is full.
 pub const ENV_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS: &str =
     "RUSTFS_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS";
-pub const DEFAULT_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS: u64 = 10_000;
-
-// A queued part holds the client's body write open for the whole wait. The
-// shortest write timeout among mainstream S3 SDKs is the AWS SDK for Java v2's
-// 30 s socket write timeout; keep the compiled default at no more than a third
-// of it. This locks only the default; the environment variable may still raise
-// the wait past any client timeout.
-const _: () = assert!(DEFAULT_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS * 3 <= 30_000);
+pub const DEFAULT_PUT_MULTIPART_FOREGROUND_ADMISSION_WAIT_TIMEOUT_MS: u64 = 30_000;
 
 /// Maximum multipart UploadPart requests waiting for a foreground write permit per process.
 ///
 /// Parts beyond this queue depth are rejected with S3 `SlowDown`/503 without
 /// waiting, so a genuinely saturated node still fails fast instead of holding
-/// an unbounded set of connections open for the whole wait timeout. Each
-/// queued HTTP/1 part also holds whatever unread body the client already
-/// pushed into that connection's kernel receive buffer, and a queued HTTP/2
-/// part holds up to its flow-control window in process memory, so the depth
-/// bounds socket and window memory as well as connections.
+/// an unbounded set of connections open for the whole wait timeout.
 /// `0` derives the depth from the permit limit.
 pub const ENV_PUT_MULTIPART_FOREGROUND_ADMISSION_MAX_PENDING: &str = "RUSTFS_PUT_MULTIPART_FOREGROUND_ADMISSION_MAX_PENDING";
 pub const DEFAULT_PUT_MULTIPART_FOREGROUND_ADMISSION_MAX_PENDING: usize = 0;

crates/config/src/constants/tls.rs

@@ -159,24 +159,6 @@ pub const DEFAULT_HTTP1_HEADER_READ_TIMEOUT: u64 = 75;
 pub const ENV_HTTP1_MAX_BUF_SIZE: &str = "RUSTFS_HTTP1_MAX_BUF_SIZE";
 pub const DEFAULT_HTTP1_MAX_BUF_SIZE: usize = 64 * 1024; // 64 KB
 
-/// Environment variable for a fixed kernel receive buffer (`SO_RCVBUF`, bytes)
-/// on the API listener. Default: 0, which leaves the buffer to kernel
-/// autotuning.
-///
-/// A fixed `SO_RCVBUF` is inherited by every accepted socket and disables
-/// receive-buffer autotuning, so a connection whose request body is not being
-/// read yet (a multipart part queued for a foreground write permit) lets up to
-/// the fixed size of unread body accumulate in kernel memory — Linux doubles
-/// the requested value, so the former hard-coded 4 MiB held up to 8 MiB per
-/// queued connection (issue #7385). Autotuning keeps an unread connection at
-/// the kernel's initial size and grows only connections that are being
-/// drained. Set this only on kernels without receive-buffer autotuning
-/// (illumos/Solaris) or on very high-bandwidth-delay links where the kernel's
-/// autotuning ceiling (`net.ipv4.tcp_rmem` on Linux) is too low and cannot be
-/// raised.
-pub const ENV_HTTP_SOCKET_RECV_BUFFER_BYTES: &str = "RUSTFS_HTTP_SOCKET_RECV_BUFFER_BYTES";
-pub const DEFAULT_HTTP_SOCKET_RECV_BUFFER_BYTES: usize = 0;
-
 /// Environment variable for the S3 request-body inter-chunk read timeout
 /// (seconds). Default: 300. Set to 0 to disable.
 ///

crates/e2e_test/Cargo.toml

@@ -144,6 +144,3 @@ russh = { workspace = true, features = ["serde"] }
 russh-sftp = { workspace = true }
 zip.workspace = true
 clap = { workspace = true, features = ["derive", "env"] }
-
-[dev-dependencies]
-tempfile.workspace = true

crates/e2e_test/src/admin_timeout_regression_test.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::common::{RustFSTestClusterEnvironment, init_logging, local_http_client, signal_process};
+use crate::common::{RustFSTestClusterEnvironment, init_logging, local_http_client};
 use aws_sdk_s3::primitives::ByteStream;
 use http::header::HOST;
 use reqwest::StatusCode;
@@ -22,6 +22,7 @@ use rustfs_signer::sign_v4;
 use s3s::Body;
 use serde::Deserialize;
 use std::error::Error;
+use std::process::Command;
 use tokio::time::{Duration, sleep, timeout};
 use uuid::Uuid;
 
@@ -81,6 +82,15 @@ async fn parse_json_response<T: serde::de::DeserializeOwned>(
     Ok(serde_json::from_slice(&body)?)
 }
 
+fn signal_process(pid: u32, signal: &str) -> Result<(), Box<dyn Error + Send + Sync>> {
+    let output = Command::new("kill").arg(format!("-{signal}")).arg(pid.to_string()).output()?;
+    if output.status.success() {
+        return Ok(());
+    }
+
+    Err(format!("kill -{signal} {pid} failed: {}", String::from_utf8_lossy(&output.stderr)).into())
+}
+
 fn offline_server_count(info: &InfoMessage) -> usize {
     info.servers
         .as_ref()

crates/e2e_test/src/common.rs

@@ -57,8 +57,6 @@ const RUSTFS_FULL_FEATURE: &str = "full";
 const TEST_PORT_MIN: u16 = 20_000;
 // Keep allocator ports below the ephemeral range used by bind(..., 0) test helpers.
 const TEST_PORT_RANGE: u16 = 10_000;
-const TEST_PORT_MIN_ENV: &str = "RUSTFS_E2E_TEST_PORT_MIN";
-const TEST_PORT_RANGE_ENV: &str = "RUSTFS_E2E_TEST_PORT_RANGE";
 const TEST_PORT_COUNTER_PATH: &str = "/tmp/rustfs_e2e_next_port";
 const TEST_PORT_LOCK_DIR: &str = "/tmp/rustfs_e2e_port_allocator.lock";
 const TEST_PORT_LOCK_STALE_AFTER: Duration = Duration::from_secs(30);
@@ -101,74 +99,22 @@ impl Drop for PortAllocatorGuard {
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-struct TestPortAllocatorConfig {
-    min: u16,
-    range: u16,
+fn advance_test_port(port: u16) -> u16 {
+    let offset = (port - TEST_PORT_MIN + 1) % TEST_PORT_RANGE;
+    TEST_PORT_MIN + offset
 }
 
-impl TestPortAllocatorConfig {
-    fn max_exclusive(self) -> u32 {
-        u32::from(self.min) + u32::from(self.range)
-    }
-
-    fn contains(self, port: &u16) -> bool {
-        (u32::from(self.min)..self.max_exclusive()).contains(&u32::from(*port))
-    }
+fn seeded_test_port() -> u16 {
+    let offset = (Uuid::new_v4().as_u128() % u128::from(TEST_PORT_RANGE)) as u16;
+    TEST_PORT_MIN + offset
 }
 
-fn parse_test_port_allocator_config(
-    min_override: Option<&str>,
-    range_override: Option<&str>,
-) -> Result<TestPortAllocatorConfig, Box<dyn std::error::Error + Send + Sync>> {
-    let min = match min_override {
-        Some(value) => value
-            .parse::<u16>()
-            .map_err(|err| format!("{TEST_PORT_MIN_ENV} must be a valid u16: {err}"))?,
-        None => TEST_PORT_MIN,
-    };
-    let range = match range_override {
-        Some(value) => value
-            .parse::<u16>()
-            .map_err(|err| format!("{TEST_PORT_RANGE_ENV} must be a valid u16: {err}"))?,
-        None => TEST_PORT_RANGE,
-    };
-    if range == 0 {
-        return Err(format!("{TEST_PORT_RANGE_ENV} must be greater than zero").into());
-    }
-    if min < 1024 {
-        return Err(format!("{TEST_PORT_MIN_ENV} must be at least 1024").into());
-    }
-    let max_exclusive = u32::from(min) + u32::from(range);
-    if max_exclusive > u32::from(u16::MAX) + 1 {
-        return Err(format!("{TEST_PORT_MIN_ENV} + {TEST_PORT_RANGE_ENV} exceeds u16 port space").into());
-    }
-    Ok(TestPortAllocatorConfig { min, range })
-}
-
-fn test_port_allocator_config() -> Result<TestPortAllocatorConfig, Box<dyn std::error::Error + Send + Sync>> {
-    parse_test_port_allocator_config(
-        std::env::var(TEST_PORT_MIN_ENV).ok().as_deref(),
-        std::env::var(TEST_PORT_RANGE_ENV).ok().as_deref(),
-    )
-}
-
-fn advance_test_port(port: u16, config: TestPortAllocatorConfig) -> u16 {
-    let offset = (port - config.min + 1) % config.range;
-    config.min + offset
-}
-
-fn seeded_test_port(config: TestPortAllocatorConfig) -> u16 {
-    let offset = (Uuid::new_v4().as_u128() % u128::from(config.range)) as u16;
-    config.min + offset
-}
-
-fn read_next_test_port(config: TestPortAllocatorConfig) -> u16 {
+fn read_next_test_port() -> u16 {
     stdfs::read_to_string(TEST_PORT_COUNTER_PATH)
         .ok()
         .and_then(|value| value.trim().parse::<u16>().ok())
-        .filter(|port| config.contains(port))
-        .unwrap_or_else(|| seeded_test_port(config))
+        .filter(|port| (TEST_PORT_MIN..TEST_PORT_MIN + TEST_PORT_RANGE).contains(port))
+        .unwrap_or_else(seeded_test_port)
 }
 
 fn remove_stale_port_allocator_lock() {
@@ -264,15 +210,6 @@ pub fn local_http_client() -> HttpClient {
         .expect("failed to build local reqwest client")
 }
 
-pub(crate) fn signal_process(pid: u32, signal: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    let output = Command::new("kill").arg(format!("-{signal}")).arg(pid.to_string()).output()?;
-    if output.status.success() {
-        return Ok(());
-    }
-
-    Err(format!("kill -{signal} {pid} failed: {}", String::from_utf8_lossy(&output.stderr)).into())
-}
-
 pub(crate) async fn signed_s3_request(
     method: http::Method,
     url: &str,
@@ -692,12 +629,11 @@ impl RustFSTestEnvironment {
     pub async fn find_available_port() -> Result<u16, Box<dyn std::error::Error + Send + Sync>> {
         use std::net::TcpListener;
         let _guard = PortAllocatorGuard::acquire().await?;
-        let config = test_port_allocator_config()?;
-        let mut next_port = read_next_test_port(config);
+        let mut next_port = read_next_test_port();
 
-        for _ in 0..config.range {
+        for _ in 0..TEST_PORT_RANGE {
             let port = next_port;
-            next_port = advance_test_port(next_port, config);
+            next_port = advance_test_port(next_port);
             write_next_test_port(next_port)?;
 
             if let Ok(listener) = TcpListener::bind(("127.0.0.1", port)) {
@@ -2172,35 +2108,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn e2e_port_allocator_uses_default_range() {
-        assert_eq!(
-            parse_test_port_allocator_config(None, None).expect("default port allocator config"),
-            TestPortAllocatorConfig {
-                min: TEST_PORT_MIN,
-                range: TEST_PORT_RANGE
-            }
-        );
-    }
-
-    #[test]
-    fn e2e_port_allocator_accepts_explicit_test_range() {
-        let config = parse_test_port_allocator_config(Some("31000"), Some("128")).expect("explicit port range");
-
-        assert_eq!(advance_test_port(31127, config), 31000);
-        assert!(config.contains(&31000));
-        assert!(config.contains(&31127));
-        assert!(!config.contains(&31128));
-    }
-
-    #[test]
-    fn e2e_port_allocator_rejects_invalid_override() {
-        assert!(parse_test_port_allocator_config(Some("1023"), Some("1")).is_err());
-        assert!(parse_test_port_allocator_config(Some("65000"), Some("1000")).is_err());
-        assert!(parse_test_port_allocator_config(Some("31000"), Some("0")).is_err());
-        assert!(parse_test_port_allocator_config(Some("not-a-port"), Some("128")).is_err());
-    }
-
     #[test]
     fn resolves_rustfs_binary_in_configured_cargo_target_directory() {
         let workspace = Path::new("workspace");

crates/e2e_test/src/distributed/observability_test.rs

@@ -12,10 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::harness::{
-    DistCluster, DistLayout, TestResult, assert_object_bytes, cluster_admin_ok, unique_bucket, wait_for_ready, wait_until,
-};
-use crate::common::{admin_request, init_logging, local_http_client, signal_process, signed_request};
+use super::harness::{DistCluster, DistLayout, TestResult, cluster_admin_ok, unique_bucket, wait_for_ready};
+use crate::common::{admin_request, init_logging, local_http_client};
 use aws_sdk_s3::operation::RequestId;
 use aws_sdk_s3::primitives::ByteStream;
 use bytes::Bytes;
@@ -26,7 +24,7 @@ use hyper::service::service_fn;
 use hyper::{Request, Response};
 use hyper_util::rt::TokioIo;
 use local_ip_address::local_ip;
-use rustfs_madmin::metrics::{HttpMetrics, RealtimeMetrics};
+use rustfs_madmin::metrics::RealtimeMetrics;
 use rustfs_utils::egress::ENV_OUTBOUND_ALLOW_ORIGINS;
 use serde_json::Value;
 use std::convert::Infallible;
@@ -128,7 +126,6 @@ async fn four_node_health_inventory_metrics_and_audit_delivery_are_consistent()
     let (audit_endpoint, mut audit_entries, collector) = spawn_audit_collector().await?;
     let audit_origin = reqwest::Url::parse(&audit_endpoint)?.origin().ascii_serialization();
     let audit_env = [
-        ("RUST_LOG", "warn"),
         ("RUSTFS_AUDIT_ENABLE", "true"),
         ("RUSTFS_AUDIT_WEBHOOK_ENABLE_DISTRIBUTED", "on"),
         ("RUSTFS_AUDIT_WEBHOOK_ENDPOINT_DISTRIBUTED", audit_endpoint.as_str()),
@@ -234,186 +231,6 @@ async fn four_node_health_inventory_metrics_and_audit_delivery_are_consistent()
         "audit entry leaked the root secret key"
     );
 
-    let result = verify_write_observations_during_peer_failure(&dist, &bucket).await;
     collector.abort();
-    result
-}
-
-async fn node_admin_body(dist: &DistCluster, node: usize, path: &str) -> TestResult<String> {
-    let (status, body) = timeout(
-        Duration::from_secs(30),
-        admin_request(
-            &dist.cluster.nodes[node].url,
-            Method::GET,
-            path,
-            None,
-            &dist.cluster.access_key,
-            &dist.cluster.secret_key,
-        ),
-    )
-    .await??;
-    assert!(status.is_success(), "node {node} admin request {path}: {status} {body}");
-    Ok(body)
-}
-
-async fn http_put_counts(dist: &DistCluster, node: usize) -> TestResult<[u64; 2]> {
-    let body = node_admin_body(dist, node, "/rustfs/admin/v3/metrics?types=512&by-host=true&n=1").await?;
-    let sample: RealtimeMetrics = serde_json::from_str(body.lines().next().ok_or("empty HTTP metrics stream")?)?;
-    assert!(sample.errors.is_empty(), "HTTP metrics returned errors: {:?}", sample.errors);
-    let http = sample.aggregated.http.ok_or("HTTP metrics missing at WARN log level")?;
-    let count = |http: &HttpMetrics, outcome: &str| {
-        http.requests
-            .iter()
-            .filter(|row| row.method == "PUT" && row.outcome == outcome)
-            .map(|row| row.total)
-            .sum::<u64>()
-    };
-    assert_eq!(sample.by_host.len(), 1, "HTTP admin metrics must remain node-local");
-    let host = sample.by_host.values().next().expect("one reporting host");
-    let host = host.http.as_ref().ok_or("by-host HTTP metrics missing")?;
-    let totals = [count(&http, "2xx"), count(&http, "5xx")];
-    assert_eq!(totals, [count(host, "2xx"), count(host, "5xx")]);
-    Ok(totals)
-}
-
-async fn observed_put(dist: &DistCluster, node: usize, bucket: &str, key: &str) -> TestResult<http::StatusCode> {
-    // One signed HTTP attempt: SDK retries must not change the expected denominator.
-    timeout(Duration::from_secs(90), async {
-        let response = signed_request(
-            Method::PUT,
-            &format!("{}/{bucket}/{key}", dist.cluster.nodes[node].url),
-            &dist.cluster.access_key,
-            &dist.cluster.secret_key,
-            Some(b"write-observation".to_vec()),
-            Some("application/octet-stream"),
-        )
-        .await?;
-        assert!(response.headers().contains_key("x-amz-request-id"), "PUT omitted correlation ID");
-        let status = response.status();
-        let body = response.text().await?;
-        assert!(!body.contains(&dist.cluster.secret_key), "PUT response leaked credentials");
-        Ok::<_, Box<dyn std::error::Error + Send + Sync>>(status)
-    })
-    .await?
-}
-
-struct SuspendedPeer<'a> {
-    // Borrowing the owned child keeps its PID from being reaped/reused before cleanup.
-    child: &'a std::process::Child,
-    suspended: bool,
-}
-
-impl<'a> SuspendedPeer<'a> {
-    fn suspend(dist: &'a DistCluster, node: usize) -> TestResult<Self> {
-        let child = dist.cluster.nodes[node].process.as_ref().ok_or("peer process missing")?;
-        signal_process(child.id(), "STOP")?;
-        Ok(Self { child, suspended: true })
-    }
-
-    fn resume(&mut self) -> TestResult {
-        signal_process(self.child.id(), "CONT")?;
-        self.suspended = false;
-        Ok(())
-    }
-}
-
-impl Drop for SuspendedPeer<'_> {
-    fn drop(&mut self) {
-        if self.suspended {
-            let _ = signal_process(self.child.id(), "CONT");
-        }
-    }
-}
-
-async fn verify_write_observations_during_peer_failure(dist: &DistCluster, bucket: &str) -> TestResult {
-    let mut baseline = Vec::new();
-    for node in 0..dist.cluster.nodes.len() {
-        let before = http_put_counts(dist, node).await?;
-        assert!(
-            observed_put(dist, node, bucket, &format!("healthy-{node}"))
-                .await?
-                .is_success()
-        );
-        let after = http_put_counts(dist, node).await?;
-        assert_eq!(after, [before[0] + 1, before[1]], "node {node} lost its successful PUT denominator");
-        baseline.push(after);
-    }
-
-    // Refresh provenance immediately before the first failed probe, within the cache age budget.
-    node_admin_body(dist, 0, "/rustfs/admin/v3/storageinfo").await?;
-    let mut suspended = [SuspendedPeer::suspend(dist, 2)?, SuspendedPeer::suspend(dist, 3)?];
-    let storage: Value = serde_json::from_str(&node_admin_body(dist, 0, "/rustfs/admin/v3/storageinfo").await?)?;
-    let observations = storage["info"]["observations"]
-        .as_array()
-        .ok_or("storageinfo omitted observations")?;
-    let disks = storage["info"]["disks"]
-        .as_array()
-        .ok_or("storageinfo omitted disks during peer failure")?;
-    assert_eq!(disks.len(), 16, "failed peers must not vanish from inventory");
-    for node in [2, 3] {
-        let endpoint = &dist.cluster.nodes[node].address;
-        let observation = observations
-            .iter()
-            .find(|item| item["endpoint"].as_str().is_some_and(|value| value.contains(endpoint)))
-            .ok_or_else(|| format!("missing failed peer observation {endpoint}: {storage}"))?;
-        assert_eq!(observation["status"], "failed", "suspension did not affect peer RPC: {observation}");
-        assert_eq!(observation["cached"], true, "first failure must identify the warm cache: {observation}");
-        assert!(observation["last_success_unix_millis"].as_u64().is_some());
-        assert!(observation["snapshot_age_seconds"].as_u64().is_some_and(|age| age < 60));
-        let peer_disks: Vec<_> = disks
-            .iter()
-            .filter(|disk| disk["endpoint"].as_str().is_some_and(|value| value.contains(endpoint)))
-            .collect();
-        assert_eq!(peer_disks.len(), 4, "failed peer lost its four drive identities: {storage}");
-        for disk in peer_disks {
-            assert_eq!(disk["state"], "unknown");
-            assert_eq!(disk["runtimeState"], "unknown");
-        }
-    }
-
-    let snapshot: Value = serde_json::from_str(&node_admin_body(dist, 0, "/rustfs/admin/v4/cluster/snapshot").await?)?;
-    let metadata = &snapshot["snapshot"]["pool_meta_write_gate"];
-    assert_eq!(
-        metadata["state"], "writable",
-        "peer probe failure must not invent a metadata latch: {snapshot}"
-    );
-    assert!(metadata.get("sinceUnixSecs").is_none());
-
-    for attempt in 0..2 {
-        let status = observed_put(dist, 0, bucket, &format!("unavailable-{attempt}")).await?;
-        assert!(status.is_server_error(), "sub-quorum write unexpectedly returned {status}");
-    }
-    assert_eq!(http_put_counts(dist, 0).await?, [baseline[0][0], baseline[0][1] + 2]);
-    assert_eq!(
-        http_put_counts(dist, 1).await?,
-        baseline[1],
-        "internal RPCs must not count as external PUTs"
-    );
-
-    for peer in &mut suspended {
-        peer.resume()?;
-    }
-    wait_until(
-        Duration::from_secs(90),
-        || async {
-            let storage: Value = serde_json::from_str(&node_admin_body(dist, 0, "/rustfs/admin/v3/storageinfo").await?)?;
-            let observations = storage["info"]["observations"]
-                .as_array()
-                .ok_or("recovery omitted observations")?;
-            Ok(observations.len() == 4
-                && observations
-                    .iter()
-                    .all(|item| item["status"] == "succeeded" && item["cached"] == false))
-        },
-        "peer probes recover to fresh successful observations",
-    )
-    .await?;
-    wait_for_ready(&dist.cluster).await?;
-    assert!(observed_put(dist, 0, bucket, "recovered").await?.is_success());
-    assert_eq!(http_put_counts(dist, 0).await?, [baseline[0][0] + 1, baseline[0][1] + 2]);
-    for node in 0..dist.cluster.nodes.len() {
-        assert_object_bytes(&dist.client(node)?, bucket, "healthy-0", b"write-observation").await?;
-        assert_object_bytes(&dist.client(node)?, bucket, "recovered", b"write-observation").await?;
-    }
     Ok(())
 }

crates/e2e_test/src/fake_s3_target/mod.rs

@@ -630,10 +630,6 @@ struct MultipartPart {
     body: Bytes,
     e_tag: String,
     digest: [u8; 16],
-    /// Plaintext length declared by an SSE-C passthrough sender
-    /// (`x-rustfs-replication-part-actual-size`); RustFS validates the 5 MiB
-    /// minimum against it rather than against the stored bytes.
-    actual_size: Option<usize>,
 }
 
 #[derive(Clone)]
@@ -2827,11 +2823,6 @@ impl S3 for FakeBackend {
 
     async fn upload_part(&self, req: S3Request<UploadPartInput>) -> S3Result<S3Response<UploadPartOutput>> {
         let fault = request_fault(&req);
-        let declared_actual_size = req
-            .headers
-            .get("x-rustfs-replication-part-actual-size")
-            .and_then(|value| value.to_str().ok())
-            .and_then(|value| value.parse::<usize>().ok());
         let _body_permit = timeout(MAX_FAULT_DURATION, Arc::clone(&self.body_limit).acquire_owned())
             .await
             .map_err(|_| s3s::s3_error!(RequestTimeout, "fake target body limiter wait exceeded 30 seconds"))?
@@ -2873,7 +2864,6 @@ impl S3 for FakeBackend {
                 body,
                 e_tag: e_tag.clone(),
                 digest,
-                actual_size: declared_actual_size,
             },
         );
         Ok(apply_response_fault(
@@ -2943,9 +2933,7 @@ impl S3 for FakeBackend {
                 if requested_etag != &stored.e_tag {
                     return Err(s3s::s3_error!(InvalidPart, "part ETag does not match"));
                 }
-                if index + 1 != requested_parts.len()
-                    && stored.actual_size.unwrap_or(stored.body.len()) < MIN_MULTIPART_PART_BYTES
-                {
+                if index + 1 != requested_parts.len() && stored.body.len() < MIN_MULTIPART_PART_BYTES {
                     return Err(s3s::s3_error!(EntityTooSmall, "non-final multipart part is smaller than 5 MiB"));
                 }
                 selected.push((*number, stored.clone()));

crates/e2e_test/src/heal_erasure_disk_rebuild_test.rs

@@ -58,22 +58,11 @@ mod tests {
     struct ScannerHealEvidenceCase {
         id: &'static str,
         oracle: &'static str,
-        evidence: &'static str,
-        unclean_shutdown_marker: bool,
     }
 
     const BACKGROUND_TARGET_RESTART_EVIDENCE: ScannerHealEvidenceCase = ScannerHealEvidenceCase {
         id: "background-target-restart",
         oracle: "background-target-restart.json",
-        evidence: "process-restart",
-        unclean_shutdown_marker: false,
-    };
-
-    const BACKGROUND_TARGET_CRASH_EVIDENCE: ScannerHealEvidenceCase = ScannerHealEvidenceCase {
-        id: "background-target-crash",
-        oracle: "background-target-crash.json",
-        evidence: "process-crash-restart",
-        unclean_shutdown_marker: true,
     };
 
     struct RestartEvidenceContext {
@@ -109,8 +98,6 @@ mod tests {
             || case.oracle.contains('/')
             || case.oracle.contains('\\')
             || case.oracle.contains("..")
-            || !matches!(case.evidence, "process-restart" | "process-crash-restart")
-            || (case.evidence == "process-crash-restart") != case.unclean_shutdown_marker
         {
             return Err("invalid scanner/heal evidence case".into());
         }
@@ -963,16 +950,6 @@ mod tests {
         .await?
     }
 
-    #[tokio::test(flavor = "multi_thread")]
-    async fn test_cluster_root_heal_recovers_remote_shards_after_background_target_crash()
-    -> Result<(), Box<dyn Error + Send + Sync>> {
-        timeout(
-            Duration::from_secs(420),
-            run_cluster_root_heal_interruption(InterruptionScenario::BackgroundTargetCrash),
-        )
-        .await?
-    }
-
     #[tokio::test(flavor = "multi_thread")]
     async fn test_cluster_root_heal_recovers_remote_shards_after_coordinator_restart() -> Result<(), Box<dyn Error + Send + Sync>>
     {
@@ -1009,27 +986,21 @@ mod tests {
     enum InterruptionScenario {
         IsolatedTargetRestart,
         BackgroundTargetRestart,
-        BackgroundTargetCrash,
         BackgroundCoordinatorRestart,
         TargetEndpointBlackhole,
     }
 
     async fn run_cluster_root_heal_interruption(scenario: InterruptionScenario) -> Result<(), Box<dyn Error + Send + Sync>> {
         let server_binary = rustfs_binary_path();
-        let evidence_run = match scenario {
-            InterruptionScenario::BackgroundTargetRestart => {
-                restart_evidence_run(&server_binary, BACKGROUND_TARGET_RESTART_EVIDENCE)?
-            }
-            InterruptionScenario::BackgroundTargetCrash => {
-                restart_evidence_run(&server_binary, BACKGROUND_TARGET_CRASH_EVIDENCE)?
-            }
-            _ => None,
+        let evidence_run = if scenario == InterruptionScenario::BackgroundTargetRestart {
+            restart_evidence_run(&server_binary, BACKGROUND_TARGET_RESTART_EVIDENCE)?
+        } else {
+            None
         };
         let mut evidence_objects = Vec::new();
         let (background_enabled, interruption_node, interruption_kind) = match scenario {
             InterruptionScenario::IsolatedTargetRestart => (false, 1, "target_restart"),
             InterruptionScenario::BackgroundTargetRestart => (true, 1, "background_target_restart"),
-            InterruptionScenario::BackgroundTargetCrash => (true, 1, "background_target_crash"),
             InterruptionScenario::BackgroundCoordinatorRestart => (true, 0, "coordinator_restart"),
             InterruptionScenario::TargetEndpointBlackhole => (false, 1, "target_endpoint_blackhole"),
         };
@@ -1047,8 +1018,6 @@ mod tests {
         let mut cluster = RustFSTestClusterEnvironment::new(4).await?;
         cluster.set_env("RUSTFS_UNSAFE_BYPASS_DISK_CHECK", "true");
         cluster.set_env("RUSTFS_HEAL_ENABLED", "true");
-        // Capture physical baselines after the PUT rename fanout has drained.
-        cluster.set_env("RUSTFS_PUT_RENAME_EARLY_ACK_ENABLE", "false");
         // Heal control uses the first lexicographically sorted grid host.
         // Keep that coordinator distinct from the remote target at index 1.
         cluster.nodes.sort_by(|left, right| left.url.cmp(&right.url));
@@ -1098,7 +1067,6 @@ mod tests {
             .unwrap_or(4 * 1024 * 1024)
             .clamp(1024 * 1024, 16 * 1024 * 1024);
         let mut expected_manifests = Vec::with_capacity(online_object_count);
-        let mut unclean_shutdown_marker_observed = None;
         for index in 0..online_object_count {
             let key = format!("cluster/online/object-{index:04}.bin");
             let payload_seed = u8::try_from(index + 1).expect("clamped object count must fit in u8");
@@ -1465,11 +1433,7 @@ mod tests {
                 "Restored target endpoint forwarding"
             );
         } else {
-            if scenario == InterruptionScenario::BackgroundTargetRestart {
-                cluster.stop_node_gracefully(interruption_node).await?;
-            } else {
-                cluster.stop_node(interruption_node)?;
-            }
+            cluster.stop_node(interruption_node)?;
             let stopped_count = metadata_count(&replaced_disk, bucket, &expected_manifests);
             assert!(
                 stopped_count > 0 && stopped_count < expected_manifests.len(),
@@ -1485,12 +1449,9 @@ mod tests {
                 .join(".rustfs.sys")
                 .join("unclean-shutdown");
             if background_enabled {
-                let marker_exists = unclean_shutdown_marker.is_file();
-                unclean_shutdown_marker_observed = Some(marker_exists);
-                let expected_marker = !matches!(scenario, InterruptionScenario::BackgroundTargetRestart);
                 assert!(
-                    marker_exists == expected_marker,
-                    "background restart/crash lane observed unexpected unclean-shutdown marker state"
+                    unclean_shutdown_marker.is_file(),
+                    "background restart must retain the real unclean-shutdown marker"
                 );
             } else {
                 match std::fs::remove_file(&unclean_shutdown_marker) {
@@ -1690,14 +1651,13 @@ mod tests {
                 "server build changed during restart"
             );
             let evidence = serde_json::json!({
-                "schema": 1, "case": evidence_context.case.id, "evidence": evidence_context.case.evidence,
+                "schema": 1, "case": evidence_context.case.id, "evidence": "process-restart",
                 "run_id": evidence_context.run.run_id, "source_revision": evidence_context.run.source_revision,
                 "test_build": compiled_test_identity(),
                 "binary_sha256": evidence_context.run.binary.sha256,
                 "test_binary_sha256": evidence_context.run.test_binary.sha256,
                 "topology": {"nodes": cluster.nodes.len(), "drives_per_node": cluster.nodes[0].data_dirs.len()},
                 "pid_before": target_pid, "pid_after": restarted_pid,
-                "unclean_shutdown_marker": unclean_shutdown_marker_observed.unwrap_or(false),
                 "objects": evidence_objects, "node_listings": node_listings,
             });
             let data = serde_json::to_vec(&evidence)?;

crates/e2e_test/src/inline_fast_path_cluster_test.rs

@@ -1676,8 +1676,6 @@ async fn four_node_inline_storage_and_get_boundaries() -> TestResult {
     let collector = OtlpMetricCollector::start().await?;
     let mut cluster = RustFSTestClusterEnvironment::new(4).await?;
     configure_reader_metric_cluster(&mut cluster, &collector);
-    // Inspect every disk only after the PUT rename fanout has drained.
-    cluster.set_env("RUSTFS_PUT_RENAME_EARLY_ACK_ENABLE", "false");
     cluster.start().await?;
 
     for (state_index, state) in [VersionState::Unversioned, VersionState::Enabled, VersionState::Suspended]
@@ -2234,6 +2232,7 @@ async fn four_node_manual_transition_distributed_admission_conflict_reports_stat
     let bucket = format!("distributed-admission-{}", Uuid::new_v4().simple());
     let prefix = "transition/distributed-admission/";
     hot_client.create_bucket().bucket(&bucket).send().await?;
+    put_lifecycle_with_transition_retry(&hot_client, &bucket, &tier_name).await?;
     for index in 0u8..64 {
         let key = format!("{prefix}object-{index:02}.bin");
         hot_client
@@ -2244,7 +2243,6 @@ async fn four_node_manual_transition_distributed_admission_conflict_reports_stat
             .send()
             .await?;
     }
-    put_lifecycle_with_transition_retry(&hot_client, &bucket, &tier_name).await?;
 
     let (node0, node1) = tokio::join!(
         start_manual_transition_job_on_node(&hot, 0, &bucket, prefix, &tier_name, false, 64),

crates/e2e_test/src/kms/kms_fault_recovery_test.rs

@@ -59,36 +59,6 @@ async fn test_kms_key_directory_unavailable() -> Result<(), Box<dyn std::error::
 
     assert_eq!(put_response.server_side_encryption(), Some(&ServerSideEncryption::Aes256));
 
-    // A missing key in the healthy store is a client error, unlike a store outage.
-    let missing_key_object = "test-missing-kms-key";
-    let missing_key_error = s3_client
-        .put_object()
-        .bucket(TEST_BUCKET)
-        .key(missing_key_object)
-        .body(aws_sdk_s3::primitives::ByteStream::from_static(b"must not be published"))
-        .server_side_encryption(ServerSideEncryption::AwsKms)
-        .ssekms_key_id("rustfs-e2e-test-missing-key")
-        .send()
-        .await
-        .expect_err("an unknown key in a healthy Local KMS store must reject the write");
-    assert_eq!(missing_key_error.raw_response().map(|response| response.status().as_u16()), Some(400));
-    assert_eq!(
-        missing_key_error.as_service_error().and_then(ProvideErrorMetadata::code),
-        Some("KMS.NotFoundException")
-    );
-    let missing_key_absence = s3_client
-        .get_object()
-        .bucket(TEST_BUCKET)
-        .key(missing_key_object)
-        .send()
-        .await
-        .expect_err("a write rejected by a missing KMS key must not publish an object");
-    assert_eq!(missing_key_absence.raw_response().map(|response| response.status().as_u16()), Some(404));
-    assert_eq!(
-        missing_key_absence.as_service_error().and_then(ProvideErrorMetadata::code),
-        Some("NoSuchKey")
-    );
-
     // Temporarily rename the key directory to simulate unavailability
     info!("🔧 Simulating key directory unavailability");
     let backup_dir = format!("{}.backup", kms_env.kms_keys_dir);

crates/e2e_test/src/presigned_negative_test.rs

@@ -356,238 +356,3 @@ async fn tampered_presigned_put_returns_signature_does_not_match() -> Result<(),
     );
     Ok(())
 }
-
-/// GHSA-g8w9-qw9q-fghr: a presigned PUT signed with `SignedHeaders=host` must
-/// not honour `x-amz-*` headers the uploader adds afterwards. The presign
-/// authorised one plain upload; the extra headers would set tags, storage
-/// class and a website redirect the presigner never covered. AWS S3 rejects
-/// this with 403 `AccessDenied`, and so must RustFS — and the object must not
-/// be stored at all, not merely stored without the properties.
-#[tokio::test]
-async fn ghsa_g8w9_presigned_put_rejects_unsigned_x_amz_headers() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    init_logging();
-    let mut env = RustFSTestEnvironment::new().await?;
-    setup(&mut env).await?;
-
-    let key = "presigned-put-unsigned-amz-headers.txt";
-    let pr = env
-        .create_s3_client()
-        .put_object()
-        .bucket(BUCKET)
-        .key(key)
-        .presigned(valid_config())
-        .await?;
-    assert!(
-        !pr.headers().any(|(name, _)| name.eq_ignore_ascii_case("x-amz-tagging")),
-        "fixture must presign a plain PutObject without tagging so the header below is unsigned"
-    );
-
-    let unsigned: Vec<(&str, &str)> = vec![
-        ("x-amz-tagging", "owner=attacker&classification=public"),
-        ("x-amz-website-redirect-location", "https://attacker.example/phish"),
-        ("x-amz-storage-class", "REDUCED_REDUNDANCY"),
-    ];
-    let headers = pr.headers().chain(unsigned.iter().copied());
-    let resp = send_raw(pr.method(), pr.uri(), headers, Some(b"should-not-be-stored".to_vec())).await?;
-    let status = resp.status();
-    let body = resp.text().await?;
-    assert_eq!(
-        status.as_u16(),
-        403,
-        "presigned PUT with unsigned x-amz-* headers must be 403, body:\n{body}"
-    );
-    assert_error_code(&body, "AccessDenied");
-    assert!(
-        body.contains("were not signed"),
-        "rejection must name unsigned headers as the cause, got:\n{body}"
-    );
-
-    let error = env
-        .create_s3_client()
-        .head_object()
-        .bucket(BUCKET)
-        .key(key)
-        .send()
-        .await
-        .expect_err("presigned PUT with unsigned x-amz-* headers must not store the object");
-    assert_eq!(
-        error.raw_response().map(|response| response.status().as_u16()),
-        Some(404),
-        "absence probe after the rejected upload must return HTTP 404, got {error:?}"
-    );
-    Ok(())
-}
-
-/// GHSA-g8w9-qw9q-fghr positive control: when the presigner itself sets the
-/// property, the SDK lists `x-amz-tagging` in `SignedHeaders`, the uploader
-/// replays it, and the upload succeeds with the tags applied. Without this the
-/// negative test above could pass because the server rejects every tagged
-/// presigned upload.
-#[tokio::test]
-async fn ghsa_g8w9_presigned_put_accepts_signed_x_amz_headers() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    init_logging();
-    let mut env = RustFSTestEnvironment::new().await?;
-    setup(&mut env).await?;
-
-    let key = "presigned-put-signed-tagging.txt";
-    let pr = env
-        .create_s3_client()
-        .put_object()
-        .bucket(BUCKET)
-        .key(key)
-        .tagging("owner=app")
-        .presigned(valid_config())
-        .await?;
-    assert!(
-        pr.headers().any(|(name, _)| name.eq_ignore_ascii_case("x-amz-tagging")),
-        "fixture must carry x-amz-tagging as a signed header"
-    );
-    assert!(
-        pr.uri().contains("x-amz-tagging"),
-        "X-Amz-SignedHeaders must list x-amz-tagging, uri: {}",
-        pr.uri()
-    );
-
-    let resp = send_presigned(&pr, Some(b"stored-with-signed-tagging".to_vec())).await?;
-    let status = resp.status();
-    let body = resp.text().await?;
-    assert!(
-        status.is_success(),
-        "presigned PUT with signed x-amz-tagging must succeed, got {status}, body:\n{body}"
-    );
-
-    let tags = env
-        .create_s3_client()
-        .get_object_tagging()
-        .bucket(BUCKET)
-        .key(key)
-        .send()
-        .await?;
-    let tag_set: Vec<(String, String)> = tags
-        .tag_set()
-        .iter()
-        .map(|tag| (tag.key().to_string(), tag.value().to_string()))
-        .collect();
-    assert_eq!(tag_set, vec![("owner".to_string(), "app".to_string())], "signed tagging must be applied");
-    info!("signed presigned tagging control passed");
-    Ok(())
-}
-
-/// GHSA-g8w9-qw9q-fghr on the read side: a presigned GET signed with
-/// `SignedHeaders=host` must not accept an unsigned SSE-C header. The header
-/// would otherwise select a decryption path the presigner never authorised.
-#[tokio::test]
-async fn ghsa_g8w9_presigned_get_rejects_unsigned_x_amz_headers() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    init_logging();
-    let mut env = RustFSTestEnvironment::new().await?;
-    setup(&mut env).await?;
-
-    let pr = env
-        .create_s3_client()
-        .get_object()
-        .bucket(BUCKET)
-        .key(CANONICAL_KEY)
-        .presigned(valid_config())
-        .await?;
-
-    let unsigned: Vec<(&str, &str)> = vec![("x-amz-server-side-encryption-customer-algorithm", "AES256")];
-    let headers = pr.headers().chain(unsigned.iter().copied());
-    let resp = send_raw(pr.method(), pr.uri(), headers, None).await?;
-    let status = resp.status();
-    let body = resp.text().await?;
-    assert_eq!(
-        status.as_u16(),
-        403,
-        "presigned GET with an unsigned x-amz-* header must be 403, body:\n{body}"
-    );
-    assert_error_code(&body, "AccessDenied");
-    assert!(
-        !body.contains(std::str::from_utf8(CANONICAL_BODY)?),
-        "rejected GET must not leak the object body"
-    );
-    Ok(())
-}
-
-/// GHSA-g8w9-qw9q-fghr: an unsigned `x-amz-copy-source` would turn a presigned
-/// PutObject into a CopyObject of an arbitrary readable key, since operation
-/// routing happens before authorization. The presigned upload must fail and
-/// leave nothing behind.
-#[tokio::test]
-async fn ghsa_g8w9_presigned_put_rejects_unsigned_copy_source() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    init_logging();
-    let mut env = RustFSTestEnvironment::new().await?;
-    setup(&mut env).await?;
-
-    let key = "presigned-put-unsigned-copy-source.txt";
-    let pr = env
-        .create_s3_client()
-        .put_object()
-        .bucket(BUCKET)
-        .key(key)
-        .presigned(valid_config())
-        .await?;
-
-    let copy_source = format!("/{BUCKET}/{CANONICAL_KEY}");
-    let unsigned: Vec<(&str, &str)> = vec![("x-amz-copy-source", copy_source.as_str())];
-    let headers = pr.headers().chain(unsigned.iter().copied());
-    let resp = send_raw(pr.method(), pr.uri(), headers, None).await?;
-    let status = resp.status();
-    let body = resp.text().await?;
-    assert_eq!(
-        status.as_u16(),
-        403,
-        "presigned PUT with an unsigned copy source must be 403, body:\n{body}"
-    );
-    assert_error_code(&body, "AccessDenied");
-
-    let error = env
-        .create_s3_client()
-        .head_object()
-        .bucket(BUCKET)
-        .key(key)
-        .send()
-        .await
-        .expect_err("rejected copy must not create the destination object");
-    assert_eq!(error.raw_response().map(|response| response.status().as_u16()), Some(404));
-    Ok(())
-}
-
-/// GHSA-g8w9-qw9q-fghr boundary control: the rule covers `x-amz-*` only. A
-/// plain `Content-Type` on a `SignedHeaders=host` presigned PUT is outside
-/// SigV4's signed-header requirement (AWS S3 accepts it too) and must keep
-/// working, so the negative tests above cannot pass by rejecting every
-/// unsigned header.
-#[tokio::test]
-async fn ghsa_g8w9_presigned_put_still_accepts_unsigned_non_amz_headers() -> Result<(), Box<dyn std::error::Error + Send + Sync>>
-{
-    init_logging();
-    let mut env = RustFSTestEnvironment::new().await?;
-    setup(&mut env).await?;
-
-    let key = "presigned-put-unsigned-content-type.txt";
-    let pr = env
-        .create_s3_client()
-        .put_object()
-        .bucket(BUCKET)
-        .key(key)
-        .presigned(valid_config())
-        .await?;
-
-    let unsigned: Vec<(&str, &str)> = vec![("content-type", "text/x-rustfs-test")];
-    let headers = pr.headers().chain(unsigned.iter().copied());
-    let resp = send_raw(pr.method(), pr.uri(), headers, Some(b"plain-header-upload".to_vec())).await?;
-    let status = resp.status();
-    let body = resp.text().await?;
-    assert!(
-        status.is_success(),
-        "presigned PUT with an unsigned Content-Type must succeed, got {status}, body:\n{body}"
-    );
-
-    let head = env.create_s3_client().head_object().bucket(BUCKET).key(key).send().await?;
-    assert_eq!(
-        head.content_type(),
-        Some("text/x-rustfs-test"),
-        "unsigned Content-Type must still be applied"
-    );
-    Ok(())
-}

crates/e2e_test/src/replication_extension_test.rs

@@ -9055,11 +9055,9 @@ async fn test_replication_check_flags_multipart_only_version_minting_target() ->
             .is_some_and(|error| error.contains("CreateMultipartUpload")),
         "the failure must name the multipart path: {payload}"
     );
-    // The PutObject leg mirrored, so it is the multipart probe that failed;
-    // the mutation phases address the id the PUT reported and still run.
+    // The PutObject leg mirrored, so it is the multipart probe that failed.
     assert_eq!(target_report["Phases"]["Put"]["Status"], "OK", "{payload}");
-    assert_eq!(target_report["Phases"]["DeleteMarker"]["Status"], "OK", "{payload}");
-    assert_eq!(target_report["Phases"]["VersionDelete"]["Status"], "OK", "{payload}");
+    assert_eq!(target_report["Phases"]["DeleteMarker"]["Status"], "SKIPPED", "{payload}");
     assert_eq!(target_report["Phases"]["Cleanup"]["Status"], "OK", "{payload}");
 
     let probe_key = target
@@ -9247,9 +9245,6 @@ async fn test_replication_check_flags_version_minting_target() -> TestResult {
     let target_bucket = "version-fidelity-dst";
     target.create_bucket(target_bucket);
     target.assign_own_version_ids(true);
-    // Wasabi shape: the probe version the VersionDelete phase removed answers
-    // NoSuchVersion to cleanup's second DELETE, which must count as clean.
-    target.reject_unknown_version_deletes(true);
 
     let mut source_env = RustFSTestEnvironment::new().await?;
     let mut env_vars = replication_fast_env();
@@ -10190,199 +10185,3 @@ async fn test_get_object_tagging_proxies_unreplicated_object_to_replication_targ
     target.shutdown().await;
     Ok(())
 }
-
-// ---------------------------------------------------------------------------
-// backlog#2363
-// ---------------------------------------------------------------------------
-
-/// Wait until the source reports a terminal replication status for `key`.
-async fn wait_terminal_replication_status(
-    client: &Client,
-    bucket: &str,
-    key: &str,
-    ssec: bool,
-    timeout: Duration,
-) -> Result<String, Box<dyn Error + Send + Sync>> {
-    let customer_key = BASE64_STANDARD.encode_to_string(REPL17_SSEC_KEY);
-    let customer_key_md5 = sse_customer_key_md5_base64(REPL17_SSEC_KEY);
-    let deadline = tokio::time::Instant::now() + timeout;
-    loop {
-        let request = client.head_object().bucket(bucket).key(key);
-        let head = if ssec {
-            request
-                .sse_customer_algorithm("AES256")
-                .sse_customer_key(&customer_key)
-                .sse_customer_key_md5(&customer_key_md5)
-                .send()
-                .await?
-        } else {
-            request.send().await?
-        };
-        let status = head.replication_status().map(|status| status.as_str().to_string());
-        if matches!(status.as_deref(), Some("COMPLETED") | Some("FAILED")) {
-            return Ok(status.unwrap_or_default());
-        }
-        if tokio::time::Instant::now() >= deadline {
-            return Err(format!("{bucket}/{key}: replication never reached a terminal status; last {status:?}").into());
-        }
-        sleep(Duration::from_millis(250)).await;
-    }
-}
-
-/// backlog#2363: SSE-C ciphertext passthrough of objects the source stored
-/// compressed. The replica on a RustFS target must decrypt to the original
-/// bytes for a single PUT and for a multipart upload.
-#[tokio::test]
-async fn test_bucket_replication_sse_c_compressed_passthrough() -> TestResult {
-    init_logging();
-    const PART_SIZE: usize = 5 * 1024 * 1024;
-
-    let mut source_env = RustFSTestEnvironment::new().await?;
-    let mut target_env = RustFSTestEnvironment::new().await?;
-    let mut source_process_env = replication_fast_env();
-    source_process_env.extend_from_slice(LOOPBACK_REPLICATION_TARGET_ENV);
-    source_process_env.extend_from_slice(FAST_SCANNER_ENV);
-    source_process_env.extend_from_slice(&[
-        ("NO_PROXY", "127.0.0.1,localhost"),
-        ("HTTP_PROXY", ""),
-        ("HTTPS_PROXY", ""),
-        ("RUSTFS_COMPRESSION_ENABLED", "true"),
-        ("RUSTFS_COMPRESSION_MULTIPART_ENABLED", "true"),
-    ]);
-    source_env.start_rustfs_server_with_env(vec![], &source_process_env).await?;
-    target_env
-        .start_rustfs_server_without_cleanup_with_env(&[
-            ("NO_PROXY", "127.0.0.1,localhost"),
-            ("HTTP_PROXY", ""),
-            ("HTTPS_PROXY", ""),
-        ])
-        .await?;
-
-    let source_bucket = "ssec-compressed-src";
-    let target_bucket = "ssec-compressed-dst";
-    let source_client = source_env.create_s3_client();
-    let target_client = target_env.create_s3_client();
-    source_client.create_bucket().bucket(source_bucket).send().await?;
-    target_client.create_bucket().bucket(target_bucket).send().await?;
-    enable_bucket_versioning(&source_env, source_bucket).await?;
-    enable_bucket_versioning(&target_env, target_bucket).await?;
-    let target_arn = set_replication_target(&source_env, source_bucket, &target_env, target_bucket).await?;
-    put_bucket_replication(&source_env, source_bucket, &target_arn).await?;
-
-    let customer_key = BASE64_STANDARD.encode_to_string(REPL17_SSEC_KEY);
-    let customer_key_md5 = sse_customer_key_md5_base64(REPL17_SSEC_KEY);
-    let text = |len: usize, seed: u32| -> Vec<u8> {
-        let mut out = Vec::with_capacity(len + 64);
-        let mut line = 0u64;
-        while out.len() < len {
-            out.extend_from_slice(format!("ssec compressed passthrough seed={seed} line={line} lorem ipsum dolor\n").as_bytes());
-            line += 1;
-        }
-        out.truncate(len);
-        out
-    };
-
-    let single_key = "ssec-compressed-single.txt";
-    let single_body = text(1024 * 1024 + 17, 1);
-    source_client
-        .put_object()
-        .bucket(source_bucket)
-        .key(single_key)
-        .content_type("text/plain")
-        .body(ByteStream::from(single_body.clone()))
-        .sse_customer_algorithm("AES256")
-        .sse_customer_key(&customer_key)
-        .sse_customer_key_md5(&customer_key_md5)
-        .send()
-        .await?;
-
-    let multipart_key = "ssec-compressed-multipart.txt";
-    let multipart_parts = [text(PART_SIZE, 2), text(1024 * 1024 + 4096, 3)];
-    let multipart_body: Vec<u8> = multipart_parts.concat();
-    let created = source_client
-        .create_multipart_upload()
-        .bucket(source_bucket)
-        .key(multipart_key)
-        .content_type("text/plain")
-        .sse_customer_algorithm("AES256")
-        .sse_customer_key(&customer_key)
-        .sse_customer_key_md5(&customer_key_md5)
-        .send()
-        .await?;
-    let upload_id = created.upload_id().ok_or("missing multipart upload id")?.to_string();
-    let mut completed = Vec::new();
-    for (index, part) in multipart_parts.iter().enumerate() {
-        let part_number = i32::try_from(index + 1)?;
-        let uploaded = source_client
-            .upload_part()
-            .bucket(source_bucket)
-            .key(multipart_key)
-            .upload_id(&upload_id)
-            .part_number(part_number)
-            .body(ByteStream::from(part.clone()))
-            .sse_customer_algorithm("AES256")
-            .sse_customer_key(&customer_key)
-            .sse_customer_key_md5(&customer_key_md5)
-            .send()
-            .await?;
-        completed.push(
-            CompletedPart::builder()
-                .part_number(part_number)
-                .set_e_tag(uploaded.e_tag().map(str::to_string))
-                .build(),
-        );
-    }
-    source_client
-        .complete_multipart_upload()
-        .bucket(source_bucket)
-        .key(multipart_key)
-        .upload_id(&upload_id)
-        .multipart_upload(CompletedMultipartUpload::builder().set_parts(Some(completed)).build())
-        .sse_customer_algorithm("AES256")
-        .sse_customer_key(&customer_key)
-        .sse_customer_key_md5(&customer_key_md5)
-        .send()
-        .await?;
-
-    let mut failures = Vec::new();
-    for (key, body) in [(single_key, &single_body), (multipart_key, &multipart_body)] {
-        let status = wait_terminal_replication_status(&source_client, source_bucket, key, true, Duration::from_secs(120)).await?;
-        if status != "COMPLETED" {
-            failures.push(format!("{key}: source reports {status}"));
-            continue;
-        }
-        let replica = target_client
-            .get_object()
-            .bucket(target_bucket)
-            .key(key)
-            .sse_customer_algorithm("AES256")
-            .sse_customer_key(&customer_key)
-            .sse_customer_key_md5(&customer_key_md5)
-            .send()
-            .await;
-        match replica {
-            Ok(replica) => {
-                let content_length = replica.content_length();
-                match replica.body.collect().await {
-                    Ok(collected) => {
-                        let bytes = collected.into_bytes();
-                        if bytes.as_ref() != body.as_slice() {
-                            failures.push(format!(
-                                "{key}: replica bytes differ (content_length={content_length:?}, got {} bytes, want {})",
-                                bytes.len(),
-                                body.len()
-                            ));
-                        }
-                    }
-                    Err(err) => failures.push(format!("{key}: replica body read failed: {err}")),
-                }
-            }
-            Err(err) => failures.push(format!("{key}: replica GET failed: {err}")),
-        }
-    }
-    assert!(
-        failures.is_empty(),
-        "SSE-C compressed passthrough replicas must decrypt to the source bytes: {failures:?}"
-    );
-    Ok(())
-}

crates/e2e_test/src/upgrade_compatibility_test.rs

@@ -1473,17 +1473,20 @@ fn layout_cases() -> Vec<LayoutCase> {
             true,
         ),
         // SSE-C passthrough replicates the stored ciphertext part by part; a
-        // compressible first part is stored well below 5 MiB, so the sender
-        // declares each part's plaintext length and the target validates the
-        // 5 MiB minimum against it (rustfs/backlog#2363). rc.5 as the sender
-        // still fails this layout (see `rc5_baseline_replicates_multipart_layouts`).
-        case(
-            LAYOUT_PLAIN_BUCKET,
-            "plain/ssec-compressed-multipart-2.txt",
-            two.clone(),
-            layout_text(total(&two), 7),
-            true,
-        ),
+        // compressible first part is stored well below 5 MiB and a standard
+        // target rejects it with EntityTooSmall. rc.5 fails the same way (see
+        // `rc5_baseline_replicates_multipart_layouts`), so the outcome is
+        // recorded rather than asserted here; tracked as rustfs/backlog#2363.
+        LayoutCase {
+            assert_replication: false,
+            ..case(
+                LAYOUT_PLAIN_BUCKET,
+                "plain/ssec-compressed-multipart-2.txt",
+                two.clone(),
+                layout_text(total(&two), 7),
+                true,
+            )
+        },
         case(
             LAYOUT_ENCRYPTED_BUCKET,
             "encrypted/single.bin",
@@ -1835,20 +1838,27 @@ async fn direct_upgrade_from_rc5_preserves_multipart_layouts() -> TestResult {
                 transport.uploaded_parts, expected,
                 "{label}: stored parts must replicate as the same multipart layout"
             );
-            // An object still PENDING when the next scanner cycle arrives is
-            // not driven a second time (rustfs/backlog#2362); the journal is
-            // logged so a duplicate round is visible if this ever regresses.
-            assert_eq!(
-                transport.completes, 1,
-                "{label}: exactly one CompleteMultipartUpload; journal {:?}",
-                transport.journal
-            );
+            // The current build can drive an existing object twice (two
+            // full CreateMultipartUpload/UploadPart/Complete rounds with
+            // distinct upload ids) while its status is still PENDING; the
+            // rc.5 baseline drives once. That is a scheduling difference,
+            // not a layout one, tracked as rustfs/backlog#2362.
+            assert!(transport.completes >= 1, "{label}: at least one CompleteMultipartUpload");
+            if transport.completes > 1 {
+                tracing::warn!(
+                    target: "e2e_test::upgrade_compatibility_test",
+                    object = %label,
+                    completes = transport.completes,
+                    journal = ?transport.journal,
+                    "existing-object replication drove the same object more than once (rustfs/backlog#2362)"
+                );
+            }
             assert_eq!(
                 transport.single_puts, 0,
                 "{label}: a multipart layout must not go out as a single PutObject"
             );
         } else {
-            assert_eq!(transport.single_puts, 1, "{label}: a single PUT replicates as exactly one PutObject");
+            assert!(transport.single_puts >= 1, "{label}: a single PUT replicates as PutObject");
             assert!(transport.uploaded_parts.is_empty(), "{label}: a single PUT must not go out as multipart");
         }
         if !case.ssec {
@@ -1918,59 +1928,3 @@ async fn rc5_baseline_replicates_multipart_layouts() -> TestResult {
     tracing::info!(target: "e2e_test::upgrade_compatibility_test", ?summary, "rc.5 baseline replication outcomes");
     Ok(())
 }
-
-/// backlog#2362 under the same conditions that reproduced it with the rc.5
-/// writer, but with the workspace build on both sides so it runs in the
-/// ordinary lane: every pre-existing layout is driven through exactly one
-/// upload round even though the scanner re-scans it every second while the
-/// first round is still in flight.
-#[tokio::test]
-async fn existing_object_replication_drives_each_layout_once() -> TestResult {
-    init_logging();
-    let server_env = layout_server_env();
-
-    let mut env = RustFSTestEnvironment::new().await?;
-    env.start_rustfs_server_with_env(vec![], &server_env).await?;
-    let writer = env.create_s3_client();
-    env.create_test_bucket(LAYOUT_PLAIN_BUCKET).await?;
-    env.create_test_bucket(LAYOUT_ENCRYPTED_BUCKET).await?;
-    enable_versioning(&writer, LAYOUT_PLAIN_BUCKET).await?;
-    enable_versioning(&writer, LAYOUT_ENCRYPTED_BUCKET).await?;
-    put_default_sse_s3_encryption(&writer, LAYOUT_ENCRYPTED_BUCKET).await?;
-
-    let mut cases = layout_cases();
-    for case in cases.iter_mut() {
-        layout_write(&writer, case).await?;
-        let head = layout_head(&writer, case).await?;
-        case.rc5_etag = head
-            .e_tag()
-            .ok_or_else(|| format!("{}: HEAD omitted the ETag", case.label()))?
-            .trim_matches('"')
-            .to_string();
-    }
-
-    // The objects come from an earlier process lifetime: the scanner starts
-    // cold and every object is a candidate at once.
-    env.restart_server_preserving_data(vec![], &server_env).await?;
-    let client = env.create_s3_client();
-    let (_target, transports) = replicate_layouts(&env, &client, &cases).await?;
-    let mut duplicates = Vec::new();
-    for (case, transport) in cases.iter().zip(&transports) {
-        assert_eq!(
-            transport.status,
-            "COMPLETED",
-            "{}: existing-object replication must complete",
-            case.label()
-        );
-        let rounds = if case.is_multipart_layout() {
-            transport.completes
-        } else {
-            transport.single_puts
-        };
-        if rounds != 1 {
-            duplicates.push(format!("{}: {rounds} upload rounds; journal {:?}", case.label(), transport.journal));
-        }
-    }
-    assert!(duplicates.is_empty(), "each existing object must be driven exactly once: {duplicates:?}");
-    Ok(())
-}

crates/ecstore/Cargo.toml

@@ -118,8 +118,6 @@ hotpath-cpu = [
 # injection, xl.meta transition assertions) via `api::tier::test_util`.
 # Enable only from `[dev-dependencies]` (rustfs/backlog#1148 ilm-6).
 test-util = []
-# Observes real startup CAS only in the dedicated E2E binary.
-e2e-test-hooks = []
 
 [dependencies]
 hotpath.workspace = true

crates/ecstore/src/api/mod.rs

@@ -33,7 +33,6 @@ pub mod bucket {
         pub use crate::bucket::bucket_target_sys::{
             AdvancedPutOptions, BucketTargetError, BucketTargetSys, PutObjectOptions, RemoveObjectOptions, S3ClientError,
             SsecPassthroughCapability, TargetClient, VersionIdentityCapability, append_version_id_query,
-            resolve_delete_api_version_id,
         };
     }
 
@@ -384,8 +383,6 @@ pub mod data_usage {
 pub mod disk {
     pub use crate::disk::disk_store::get_object_disk_read_timeout;
     pub use crate::disk::local::ScanGuard;
-    #[cfg(all(feature = "test-util", not(windows)))]
-    pub use crate::disk::os::{LocalPublicationPause, LocalPublicationStage};
     pub use crate::disk::{
         BATCH_READ_VERSION_MAX_ITEMS, BUCKET_META_PREFIX, BatchReadVersionItem, BatchReadVersionReq, BatchReadVersionResp,
         CheckPartsResp, ConditionalFileUpdate, DeleteOptions, Disk, DiskAPI, DiskInfo, DiskInfoOptions, DiskLocation, DiskOption,
@@ -418,8 +415,8 @@ pub mod disk {
 
 pub mod error {
     pub use crate::error::{
-        Error, PoolMetadataError, PoolMetadataFailure, Result, StorageError, classify_system_path_failure_reason,
-        is_err_bucket_not_found, is_err_object_not_found, is_err_version_not_found,
+        Error, Result, StorageError, classify_system_path_failure_reason, is_err_bucket_not_found, is_err_object_not_found,
+        is_err_version_not_found,
     };
 }
 
@@ -566,8 +563,8 @@ pub mod storage {
     pub use crate::core::pools::HealLifecycleExpiryContext;
     pub use crate::store::HealWalkVersion;
     pub use crate::store::{
-        BootstrapLocalTarget, ECStore, SCANNER_PUBLICATION_LEASE_TTL_MS, ScannerDataMovementPauseStatus, all_local_disk,
-        all_local_disk_path, find_local_disk_by_ref, init_local_disks, init_local_disks_with_instance_ctx, init_lock_clients,
+        ECStore, SCANNER_PUBLICATION_LEASE_TTL_MS, ScannerDataMovementPauseStatus, all_local_disk, all_local_disk_path,
+        find_local_disk_by_ref, init_local_disks, init_local_disks_with_instance_ctx, init_lock_clients,
         prewarm_local_disk_id_map, prewarm_local_disk_id_map_with_instance_ctx,
     };
 }

crates/ecstore/src/bucket/bucket_target_sys.rs

@@ -1425,12 +1425,7 @@ fn build_remove_object_headers(version_id: Option<&str>, opts: &RemoveObjectOpti
 /// and silently creates a delete marker instead of removing the version, while
 /// the source stamps `VersionPurgeStatus=Complete` (backlog#799 B8 / #857).
 /// Non-replication callers always pass the version through unchanged.
-/// The `versionId` a replicated DELETE puts on the wire: none for a
-/// delete-marker creation (the target mints the marker; the source version
-/// travels in the internal headers for RustFS peers), the addressed version
-/// otherwise. A generic S3 target given the version id on a marker-creation
-/// DELETE would permanently delete that version instead.
-pub fn resolve_delete_api_version_id(version_id: Option<String>, opts: &RemoveObjectOptions) -> Option<String> {
+fn resolve_delete_api_version_id(version_id: Option<String>, opts: &RemoveObjectOptions) -> Option<String> {
     if opts.replication_request && opts.replication_delete_marker {
         None
     } else {

crates/ecstore/src/bucket/lifecycle/bucket_lifecycle_ops.rs

@@ -4036,10 +4036,6 @@ impl ManualTransitionRunReport {
             || self.skipped_queue_timeout > 0
     }
 
-    fn has_enqueue_backpressure(&self) -> bool {
-        self.skipped_queue_full > 0 || self.skipped_queue_closed > 0 || self.skipped_queue_timeout > 0
-    }
-
     pub fn was_truncated(&self) -> bool {
         self.truncated_by_limit || self.truncated_by_duration || self.cancelled
     }
@@ -4255,7 +4251,7 @@ pub async fn enqueue_transition_for_existing_objects_scoped(
             }
             report.scanned = report.scanned.saturating_add(1);
             enqueue_transition_with_lifecycle_report(Some(api.clone()), object, &lc, &src, &options, &mut report).await;
-            if report.has_enqueue_backpressure() {
+            if report.has_partial_enqueue() {
                 report.next_marker.clone_from(&previous_marker);
                 report.next_version_idmarker.clone_from(&previous_version_marker);
                 report.continuation_token =
@@ -9954,18 +9950,6 @@ mod tests {
         assert_eq!(report.skipped_queue_closed, 0);
         assert_eq!(report.skipped_queue_timeout, 0);
         assert!(report.has_partial_enqueue());
-        assert!(report.has_enqueue_backpressure());
-    }
-
-    #[test]
-    fn manual_transition_in_flight_skip_does_not_stop_the_scan() {
-        let options = ManualTransitionRunOptions::default();
-        let mut report = ManualTransitionRunReport::new("bucket", &options);
-
-        report.record_enqueue_outcome(TransitionEnqueueOutcome::AlreadyInFlight);
-
-        assert!(report.has_partial_enqueue());
-        assert!(!report.has_enqueue_backpressure());
     }
 
     #[test]

crates/ecstore/src/bucket/metadata_sys.rs

@@ -54,9 +54,6 @@ pub type BucketConfigPublishHook = Box<dyn Fn(&str, &str, Option<(&[u8], OffsetD
 pub static BUCKET_CONFIG_PUBLISH_HOOK: std::sync::OnceLock<BucketConfigPublishHook> = std::sync::OnceLock::new();
 
 const BUCKET_METADATA_REFRESH_INTERVAL: Duration = Duration::from_secs(15 * 60);
-const LOG_COMPONENT_ECSTORE: &str = "ecstore";
-const LOG_SUBSYSTEM_BUCKET_METADATA: &str = "bucket_metadata";
-const EVENT_BUCKET_METADATA_LOAD_FAILED: &str = "bucket_metadata_load_failed";
 
 #[cfg(any(test, feature = "test-util"))]
 struct ConfigWriteLockProbeState {
@@ -1617,20 +1614,13 @@ impl BucketMetadataSys {
 
         let results = join_all(futures).await;
 
-        for (bucket, res) in buckets.iter().zip(results) {
+        for (idx, res) in results.into_iter().enumerate() {
             match res {
                 Ok(()) => {}
                 Err(e) => {
-                    if failed_buckets.insert(bucket.clone()) {
-                        error!(
-                            event = EVENT_BUCKET_METADATA_LOAD_FAILED,
-                            component = LOG_COMPONENT_ECSTORE,
-                            subsystem = LOG_SUBSYSTEM_BUCKET_METADATA,
-                            result = "retry_pending",
-                            bucket = %bucket,
-                            error_code = ?e.code(),
-                            "Unable to load bucket metadata; retry scheduled"
-                        );
+                    error!("Unable to load bucket metadata, will be retried: {:?}", e);
+                    if let Some(bucket) = buckets.get(idx) {
+                        failed_buckets.insert(bucket.clone());
                     }
                 }
             }
@@ -1657,19 +1647,12 @@ impl BucketMetadataSys {
             });
         }
         let results = join_all(futures).await;
-        for (bucket, result) in buckets.iter().zip(results) {
-            if let Err(err) = result
-                && failed_buckets.insert(bucket.clone())
-            {
-                error!(
-                    event = EVENT_BUCKET_METADATA_LOAD_FAILED,
-                    component = LOG_COMPONENT_ECSTORE,
-                    subsystem = LOG_SUBSYSTEM_BUCKET_METADATA,
-                    result = "retry_pending",
-                    bucket = %bucket,
-                    error_code = ?err.code(),
-                    "Unable to load bucket metadata; retry scheduled"
-                );
+        for (idx, result) in results.into_iter().enumerate() {
+            if let Err(err) = result {
+                error!("Unable to load bucket metadata, will be retried: {:?}", err);
+                if let Some(bucket) = buckets.get(idx) {
+                    failed_buckets.insert(bucket.clone());
+                }
             }
         }
     }

crates/ecstore/src/bucket/replication/replication_pool.rs

@@ -75,7 +75,6 @@ use tracing::{debug, info, instrument, warn};
 const EVENT_REPLICATION_WORKER_RESIZE_SKIPPED: &str = "replication_worker_resize_skipped";
 const EVENT_REPLICATION_WORKER_RESIZED: &str = "replication_worker_resized";
 const EVENT_REPLICATION_BACKPRESSURE: &str = "replication_backpressure";
-const EVENT_REPLICATION_IN_FLIGHT_SKIPPED: &str = "replication_in_flight_skipped";
 const EVENT_REPLICATION_RESYNC_LOAD_SKIPPED: &str = "replication_resync_load_skipped";
 const EVENT_REPLICATION_RESYNC_RECOVERED: &str = "replication_resync_recovered";
 const EVENT_REPLICATION_MRF_QUEUE_UNAVAILABLE: &str = "replication_mrf_queue_unavailable";
@@ -1090,9 +1089,6 @@ pub struct ReplicationPool<S: ReplicationStorage> {
     workers: RwLock<Vec<Sender<ReplicationOperation>>>,
     lrg_workers: RwLock<Vec<Sender<ReplicationOperation>>>,
 
-    /// Object versions queued or being replicated right now (backlog#2362).
-    in_flight: Arc<ReplicationInFlight>,
-
     // MRF (Most Recent Failures) channels
     mrf_replica_tx: Sender<ReplicationOperation>,
     // Shared among N MRF workers; Arc allows spawning more than one worker.
@@ -1151,7 +1147,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
             storage,
             workers: RwLock::new(Vec::new()),
             lrg_workers: RwLock::new(Vec::new()),
-            in_flight: Arc::new(ReplicationInFlight::default()),
             mrf_replica_tx,
             mrf_replica_rx: Arc::new(Mutex::new(mrf_replica_rx)),
             mrf_save_tx,
@@ -1207,13 +1202,12 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
             let active_counter = self.active_lrg_workers.clone();
             let storage = self.storage.clone();
             let stats = self.stats.clone();
-            let in_flight = self.in_flight.clone();
 
             let handle = tokio::spawn(async move {
                 let mut rx = rx;
                 while let Some(operation) = rx.recv().await {
                     let _active = ActiveWorkerGuard::new(active_counter.clone());
-                    process_replication_operation(operation, stats.clone(), storage.clone(), in_flight.clone()).await;
+                    process_replication_operation(operation, stats.clone(), storage.clone()).await;
                 }
             });
 
@@ -1267,13 +1261,12 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
             let active_counter = self.active_workers.clone();
             let stats = self.stats.clone();
             let storage = self.storage.clone();
-            let in_flight = self.in_flight.clone();
 
             let handle = tokio::spawn(async move {
                 let mut rx = rx;
                 while let Some(operation) = rx.recv().await {
                     let _active = ActiveWorkerGuard::new(active_counter.clone());
-                    process_replication_operation(operation, stats.clone(), storage.clone(), in_flight.clone()).await;
+                    process_replication_operation(operation, stats.clone(), storage.clone()).await;
                 }
             });
 
@@ -1312,7 +1305,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
             let active_counter = self.active_mrf_workers.clone();
             let stats = self.stats.clone();
             let storage = self.storage.clone();
-            let in_flight = self.in_flight.clone();
             let mrf_rx = Arc::clone(&self.mrf_replica_rx);
 
             let handle = tokio::spawn(async move {
@@ -1332,7 +1324,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                     let Some(operation) = operation else { break };
 
                     let _active = ActiveWorkerGuard::new(active_counter.clone());
-                    process_replication_operation(operation, stats.clone(), storage.clone(), in_flight.clone()).await;
+                    process_replication_operation(operation, stats.clone(), storage.clone()).await;
                 }
             });
             self.task_handles.lock().await.push(handle);
@@ -1462,24 +1454,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
 
     /// Queues a replica task
     pub async fn queue_replica_task(&self, ri: ReplicateObjectInfo) -> ReplicationQueueAdmission {
-        // A version that is already queued or being uploaded is not driven a
-        // second time: the scanner heal pass sees it as PENDING until the
-        // first upload lands and would otherwise re-queue it every cycle
-        // (backlog#2362). The key is released when the worker finishes, or
-        // below when no worker accepts the task.
-        if !self.in_flight.try_begin(&ri) {
-            debug!(
-                event = EVENT_REPLICATION_IN_FLIGHT_SKIPPED,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_REPLICATION,
-                bucket = %ri.bucket,
-                object = %ri.name,
-                version_id = ?ri.version_id,
-                op_type = ?ri.op_type,
-                "Replication task already in flight; not queued again"
-            );
-            return ReplicationQueueAdmission::Skipped;
-        }
         let target_arns = ri.dsc.replicate_target_arns();
         // If object is large, queue it to a static set of large workers
         if should_queue_large_object(ri.size) {
@@ -1510,9 +1484,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                     let resize = large_worker_backpressure_resize(existing, self.active_lrg_workers(), max_l_workers);
                     drop(lrg_workers);
 
-                    // Queue to MRF if worker is busy. The MRF replay re-enters
-                    // this function, so the version is no longer in flight.
-                    self.in_flight.finish(&ri);
+                    // Queue to MRF if worker is busy.
                     let admission = self.queue_mrf_save_admission(ri.to_mrf_entry(), "large_object").await;
 
                     if let Some(resize) = resize {
@@ -1521,7 +1493,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
                     return admission;
                 }
             }
-            self.in_flight.finish(&ri);
             return ReplicationQueueAdmission::Missed;
         }
 
@@ -1530,7 +1501,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
         let ch = self.worker_queue_channel(&ri.op_type, &ri.bucket, &ri.name, ri.size).await;
 
         let Some(channel) = ch else {
-            self.in_flight.finish(&ri);
             return ReplicationQueueAdmission::Missed;
         };
 
@@ -1542,9 +1512,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
         self.stats.dec_q(&ri.bucket, ri.size, ri.delete_marker, ri.op_type);
         self.stats.dec_target_q(&ri.bucket, &target_arns, ri.size);
 
-        // Queue to MRF if all workers are busy. The MRF replay re-enters this
-        // function, so the version is no longer in flight.
-        self.in_flight.finish(&ri);
+        // Queue to MRF if all workers are busy.
         let admission = self.queue_mrf_save_admission(ri.to_mrf_entry(), "object").await;
 
         // Try to scale up workers based on priority
@@ -1843,7 +1811,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
     ) {
         while let Some(operation) = rx.recv().await {
             let _active = ActiveWorkerGuard::new(active_counter.clone());
-            process_replication_operation(operation, stats.clone(), self.storage.clone(), self.in_flight.clone()).await;
+            process_replication_operation(operation, stats.clone(), self.storage.clone()).await;
         }
     }
 
@@ -1861,7 +1829,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
     ) {
         while let Some(operation) = rx.recv().await {
             let _active = ActiveWorkerGuard::new(active_counter.clone());
-            process_replication_operation(operation, stats.clone(), storage.clone(), self.in_flight.clone()).await;
+            process_replication_operation(operation, stats.clone(), storage.clone()).await;
         }
     }
 
@@ -1878,7 +1846,7 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
     ) {
         while let Some(operation) = rx.recv().await {
             let _active = ActiveWorkerGuard::new(active_counter.clone());
-            process_replication_operation(operation, stats.clone(), self.storage.clone(), self.in_flight.clone()).await;
+            process_replication_operation(operation, stats.clone(), self.storage.clone()).await;
         }
     }
 
@@ -2313,64 +2281,6 @@ impl<S: ReplicationStorage> ReplicationPool<S> {
     }
 }
 
-/// Object versions currently queued or being uploaded, keyed by bucket,
-/// object name and version. `queue_replica_task` admits a version only once
-/// while it is in flight; the scanner heal pass and MRF replays that arrive
-/// in the meantime are `Skipped` instead of driving a second complete upload
-/// (backlog#2362). Entries are removed when the worker finishes the task or
-/// when no worker accepted it.
-#[derive(Debug, Default)]
-pub(crate) struct ReplicationInFlight {
-    keys: std::sync::Mutex<std::collections::HashSet<(String, String, Option<uuid::Uuid>)>>,
-}
-
-impl ReplicationInFlight {
-    fn lock(&self) -> std::sync::MutexGuard<'_, std::collections::HashSet<(String, String, Option<uuid::Uuid>)>> {
-        self.keys.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
-    }
-
-    /// Claim `ri`; `false` when the same version is already in flight.
-    fn try_begin(&self, ri: &ReplicateObjectInfo) -> bool {
-        self.lock().insert((ri.bucket.clone(), ri.name.clone(), ri.version_id))
-    }
-
-    fn finish(&self, ri: &ReplicateObjectInfo) {
-        self.lock().remove(&(ri.bucket.clone(), ri.name.clone(), ri.version_id));
-    }
-
-    #[cfg(test)]
-    fn len(&self) -> usize {
-        self.lock().len()
-    }
-}
-
-/// Releases the in-flight claim when the worker is done with the task,
-/// including when replication panics.
-struct ReplicationInFlightGuard {
-    in_flight: Arc<ReplicationInFlight>,
-    key: ReplicateObjectInfo,
-}
-
-impl ReplicationInFlightGuard {
-    fn new(in_flight: Arc<ReplicationInFlight>, ri: &ReplicateObjectInfo) -> Self {
-        Self {
-            in_flight,
-            key: ReplicateObjectInfo {
-                bucket: ri.bucket.clone(),
-                name: ri.name.clone(),
-                version_id: ri.version_id,
-                ..Default::default()
-            },
-        }
-    }
-}
-
-impl Drop for ReplicationInFlightGuard {
-    fn drop(&mut self) {
-        self.in_flight.finish(&self.key);
-    }
-}
-
 struct ActiveWorkerGuard {
     counter: Arc<AtomicI32>,
 }
@@ -2432,12 +2342,10 @@ async fn process_replication_operation<S: ReplicationStorage>(
     operation: ReplicationOperation,
     stats: Arc<ReplicationStats>,
     storage: Arc<S>,
-    in_flight: Arc<ReplicationInFlight>,
 ) {
     match operation {
         ReplicationOperation::Object(obj_info) => {
             let _backlog = ReplicationBacklogGuard::for_object(stats, obj_info.as_ref());
-            let _in_flight = ReplicationInFlightGuard::new(in_flight, obj_info.as_ref());
             replicate_object(*obj_info, storage).await;
         }
         ReplicationOperation::Delete(del_info) => {
@@ -3175,7 +3083,7 @@ pub async fn queue_replication_heal(bucket: &str, oi: ObjectInfo, retry_count: u
         // A bucket without a configuration still owes its pending purges an
         // answer: the delete worker finishes them locally as abandoned, which
         // is what makes the bucket deletable again (rustfs/backlog#2340).
-        Ok(None) if owes_version_purge(&oi) => None,
+        Ok(None) if !oi.version_purge_status.is_empty() => None,
         Ok(None) => return ReplicationQueueAdmission::Skipped,
         Err(err) => {
             debug!(
@@ -3253,17 +3161,6 @@ pub async fn queue_replication_metadata(bucket: &str, oi: ObjectInfo, retry_coun
     }
 }
 
-/// A version purge the persisted state still owes to named targets. Without
-/// the target list nothing can be settled, so such a version keeps the
-/// ordinary "no configuration, nothing to heal" skip.
-fn owes_version_purge(oi: &ObjectInfo) -> bool {
-    !oi.version_purge_status.is_empty()
-        && oi
-            .version_purge_status_internal
-            .as_deref()
-            .is_some_and(|statuses| !statuses.trim().is_empty())
-}
-
 /// queue_replication_heal_internal enqueues objects that failed replication OR eligible for resyncing through
 /// an ongoing resync operation or via existing objects replication configuration setting.
 pub(crate) async fn queue_replication_heal_internal(
@@ -3286,7 +3183,7 @@ pub(crate) async fn queue_replication_heal_internal(
     // except a version purge the bucket still owes: its stored decision names
     // the targets, and the delete worker settles the ones no longer
     // configured as abandoned (rustfs/backlog#2340).
-    if (rcfg.config.is_none() || rcfg.remotes.is_none()) && !owes_version_purge(&oi) {
+    if (rcfg.config.is_none() || rcfg.remotes.is_none()) && oi.version_purge_status.is_empty() {
         return ReplicationHealQueueResult {
             object_info: roi,
             admission: ReplicationQueueAdmission::Skipped,
@@ -3821,7 +3718,6 @@ mod tests {
             stats: Arc::new(ReplicationStats::new()),
             workers: RwLock::new(Vec::new()),
             lrg_workers: RwLock::new(Vec::new()),
-            in_flight: Arc::new(ReplicationInFlight::default()),
             mrf_replica_tx,
             mrf_replica_rx: Arc::new(Mutex::new(mrf_replica_rx)),
             mrf_save_tx,
@@ -3888,90 +3784,6 @@ mod tests {
         assert_eq!(current_queue(&pool, "admission-bucket").await, (1, 4096));
     }
 
-    #[tokio::test]
-    async fn queue_replica_task_admits_a_version_once_while_it_is_in_flight() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        let (tx, _rx) = mpsc::channel(4);
-        pool.workers.write().await.push(tx);
-        let ri = ReplicateObjectInfo {
-            bucket: "in-flight-bucket".to_string(),
-            name: "object".to_string(),
-            version_id: Some(uuid::Uuid::new_v4()),
-            size: 4096,
-            op_type: ReplicationType::Object,
-            ..Default::default()
-        };
-
-        assert_eq!(pool.queue_replica_task(ri.clone()).await, ReplicationQueueAdmission::Queued);
-        // backlog#2362: the scanner heal pass sees the version as PENDING
-        // until the worker lands it; a second request must not drive it again.
-        assert_eq!(pool.queue_replica_task(ri.clone()).await, ReplicationQueueAdmission::Skipped);
-        assert_eq!(current_queue(&pool, "in-flight-bucket").await, (1, 4096));
-
-        // Another version of the same key is independent work.
-        let newer = ReplicateObjectInfo {
-            version_id: Some(uuid::Uuid::new_v4()),
-            ..ri.clone()
-        };
-        assert_eq!(pool.queue_replica_task(newer).await, ReplicationQueueAdmission::Queued);
-        assert_eq!(pool.in_flight.len(), 2);
-
-        // Once the worker finishes, the same version may be queued again
-        // (for example after a FAILED status).
-        pool.in_flight.finish(&ri);
-        assert_eq!(pool.queue_replica_task(ri).await, ReplicationQueueAdmission::Queued);
-        assert_eq!(current_queue(&pool, "in-flight-bucket").await, (3, 3 * 4096));
-    }
-
-    #[tokio::test]
-    async fn queue_replica_task_releases_the_version_when_no_worker_accepts_it() {
-        let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;
-        let ri = ReplicateObjectInfo {
-            bucket: "no-worker-bucket".to_string(),
-            name: "object".to_string(),
-            version_id: Some(uuid::Uuid::new_v4()),
-            size: 4096,
-            op_type: ReplicationType::Object,
-            ..Default::default()
-        };
-
-        // No worker channel: the task is missed and must not stay claimed.
-        assert_eq!(pool.queue_replica_task(ri.clone()).await, ReplicationQueueAdmission::Missed);
-        assert_eq!(pool.in_flight.len(), 0);
-        assert_eq!(pool.queue_replica_task(ri.clone()).await, ReplicationQueueAdmission::Missed);
-
-        // A full worker channel hands the task to the MRF save path; the MRF
-        // replay re-enters the queue, so the claim is released here too.
-        let (tx, _rx) = mpsc::channel(1);
-        pool.workers.write().await.push(tx);
-        assert_eq!(pool.queue_replica_task(ri.clone()).await, ReplicationQueueAdmission::Queued);
-        let overflow = ReplicateObjectInfo {
-            version_id: Some(uuid::Uuid::new_v4()),
-            ..ri
-        };
-        assert_eq!(pool.queue_replica_task(overflow).await, ReplicationQueueAdmission::Queued);
-        assert_eq!(pool.in_flight.len(), 1, "only the version held by the worker channel stays in flight");
-    }
-
-    #[test]
-    fn in_flight_guard_releases_the_version_on_drop() {
-        let in_flight = Arc::new(ReplicationInFlight::default());
-        let ri = ReplicateObjectInfo {
-            bucket: "guard-bucket".to_string(),
-            name: "object".to_string(),
-            version_id: Some(uuid::Uuid::new_v4()),
-            ..Default::default()
-        };
-        assert!(in_flight.try_begin(&ri));
-        assert!(!in_flight.try_begin(&ri));
-        {
-            let _guard = ReplicationInFlightGuard::new(in_flight.clone(), &ri);
-            assert_eq!(in_flight.len(), 1);
-        }
-        assert_eq!(in_flight.len(), 0);
-        assert!(in_flight.try_begin(&ri));
-    }
-
     #[tokio::test]
     async fn regular_worker_admission_counts_target_backlog_before_receive() {
         let pool = new_test_replication_pool(Arc::new(LoadResyncNodeStore::new("node-a", empty_resync_shared_state()))).await;

crates/ecstore/src/bucket/replication/replication_resyncer.rs

@@ -94,14 +94,12 @@ use rustfs_utils::{DEFAULT_SIP_HASH_KEY, get_env_usize, sip_hash};
 use s3s::dto::ReplicationConfiguration;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Display;
-use std::pin::Pin;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, LazyLock, Mutex as StdMutex};
-use std::task::{Context, Poll};
 use std::time::Instant;
 use time::OffsetDateTime;
 use time::format_description::well_known::Rfc3339;
-use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
+use tokio::io::AsyncRead;
 use tokio::sync::{OwnedSemaphorePermit, RwLock, Semaphore};
 use tokio::task::{JoinHandle, JoinSet};
 use tokio::time::Duration as TokioDuration;
@@ -4538,6 +4536,7 @@ impl ReplicateObjectInfoExt for ReplicateObjectInfo {
 
         let source_version_id = self.version_id;
         let assigned_version_id = if is_multipart {
+            drop(gr);
             replicate_object_with_multipart(MultipartReplicationContext {
                 storage: storage.clone(),
                 cli: tgt_client.clone(),
@@ -4548,7 +4547,6 @@ impl ReplicateObjectInfoExt for ReplicateObjectInfo {
                 obj_opts: &obj_opts,
                 arn: &rinfo.arn,
                 put_opts,
-                full_stream: Some(gr.stream),
             })
             .await
         } else {
@@ -5285,6 +5283,7 @@ async fn replicate_all_payload_to_target<S: ReplicationObjectIO>(
     }
 
     if ctx.is_multipart {
+        drop(gr);
         replicate_object_with_multipart(MultipartReplicationContext {
             storage: ctx.storage.clone(),
             cli: ctx.tgt_client.clone(),
@@ -5295,7 +5294,6 @@ async fn replicate_all_payload_to_target<S: ReplicationObjectIO>(
             obj_opts: ctx.obj_opts,
             arn: ctx.arn,
             put_opts: ctx.put_opts,
-            full_stream: Some(gr.stream),
         })
         .await
     } else {
@@ -5367,15 +5365,11 @@ struct MultipartReplicationContext<'a, S: ReplicationObjectIO> {
     obj_opts: &'a ObjectOptions,
     arn: &'a str,
     put_opts: PutObjectOptions,
-    full_stream: Option<Box<dyn AsyncRead + Unpin + Send + Sync>>,
 }
 
 async fn replicate_object_with_multipart<S: ReplicationObjectIO>(
-    mut ctx: MultipartReplicationContext<'_, S>,
+    ctx: MultipartReplicationContext<'_, S>,
 ) -> std::io::Result<Option<String>> {
-    if ctx.obj_opts.raw_data_movement_read || !ctx.object_info.is_compressed() {
-        ctx.full_stream = None;
-    }
     let mut attempts = 1;
     let upload_id = loop {
         match ctx
@@ -5563,21 +5557,6 @@ struct MultipartReplicationReadPlan {
     next_offset: i64,
 }
 
-#[derive(Clone)]
-struct SharedReplicationReader(Arc<StdMutex<Box<dyn AsyncRead + Unpin + Send + Sync>>>);
-
-impl AsyncRead for SharedReplicationReader {
-    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<std::io::Result<()>> {
-        // UploadPart owns its body, but successive parts consume one source.
-        // The mutex only covers polling; no guard survives an await.
-        let mut reader = self
-            .0
-            .lock()
-            .map_err(|_| std::io::Error::other("replication source stream lock poisoned"))?;
-        Pin::new(&mut **reader).poll_read(cx, buf)
-    }
-}
-
 fn multipart_replication_read_plan(
     object_info: &ObjectInfo,
     obj_opts: &ObjectOptions,
@@ -5636,10 +5615,8 @@ async fn replicate_multipart_parts_and_complete<S: ReplicationObjectIO>(
         obj_opts,
         arn,
         put_opts,
-        full_stream,
     } = ctx;
 
-    let full_stream = full_stream.map(|reader| SharedReplicationReader(Arc::new(StdMutex::new(reader))));
     let mut uploaded_parts: Vec<CompletedPart> = Vec::new();
 
     let mut header_size = replication_put_object_header_size(&put_opts);
@@ -5658,13 +5635,7 @@ async fn replicate_multipart_parts_and_complete<S: ReplicationObjectIO>(
         )?;
         offset = part_plan.next_offset;
 
-        let byte_stream = if let Some(reader) = &full_stream {
-            let limit = u64::try_from(part_plan.part_size)
-                .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidData, "negative multipart replication part size"))?;
-            let part_stream =
-                wrap_with_bandwidth_monitor_with_header(Box::new(reader.clone().take(limit)), src_bucket, arn, header_size);
-            async_read_to_bytestream(part_stream)
-        } else if let Some(range_spec) = part_plan.range {
+        let byte_stream = if let Some(range_spec) = part_plan.range {
             let part_reader = storage
                 .get_object_reader(src_bucket, object, Some(range_spec), HeaderMap::new(), obj_opts)
                 .await
@@ -5676,17 +5647,6 @@ async fn replicate_multipart_parts_and_complete<S: ReplicationObjectIO>(
         };
         header_size = 0;
 
-        // Passthrough parts are the stored bytes; the replica learns each
-        // part's plaintext length from this header (backlog#2363).
-        let mut part_options = PutObjectPartOptions::default();
-        if obj_opts.raw_data_movement_read && part_info.actual_size > 0 {
-            rustfs_utils::http::insert_header(
-                &mut part_options.custom_header,
-                rustfs_utils::http::SUFFIX_REPLICATION_PART_ACTUAL_SIZE,
-                part_info.actual_size.to_string(),
-            );
-        }
-
         let object_part = cli
             .put_object_part(
                 dst_bucket,
@@ -5695,7 +5655,7 @@ async fn replicate_multipart_parts_and_complete<S: ReplicationObjectIO>(
                 part_plan.part_number,
                 part_plan.part_size,
                 byte_stream,
-                &part_options,
+                &PutObjectPartOptions { ..Default::default() },
             )
             .await
             .map_err(|e| std::io::Error::other(e.to_string()))?;
@@ -5710,25 +5670,6 @@ async fn replicate_multipart_parts_and_complete<S: ReplicationObjectIO>(
         );
     }
 
-    if let Some(mut reader) = full_stream {
-        // Range planning also trusts the recorded logical part boundaries.
-        // A full decoded stream avoids repeating or skipping bytes when those
-        // boundaries are stale, and its EOF must precede publication.
-        let expected_size = object_info
-            .get_actual_size()
-            .map_err(|err| std::io::Error::other(err.to_string()))?;
-        let mut remaining = [0_u8; 1];
-        if offset != expected_size || reader.read(&mut remaining).await? != 0 {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                "compressed replication part lengths do not cover the complete source",
-            ));
-        }
-        // Releasing the reader also releases the source read lock, before
-        // CompleteMultipartUpload or replication status writes can run.
-        drop(reader);
-    }
-
     let actual_size = replication_multipart_complete_actual_size(&object_info.user_defined);
 
     let completed = cli
@@ -8302,222 +8243,73 @@ mod tests {
 
         #[tokio::test]
         async fn multipart_transport_preserves_legacy_zero_actual_sizes() {
-            run_transport(4096, None, false).await;
+            run_transport(4096, None).await;
         }
 
         #[tokio::test]
         async fn multipart_transport_uploads_an_empty_last_part_without_reading_a_range() {
-            run_transport(0, None, false).await;
+            run_transport(0, None).await;
         }
 
         #[tokio::test]
         async fn multipart_transport_preserves_transformed_unknown_nonempty_parts() {
             for unknown_part in [(0, 0), (1, 0), (0, -1), (1, -1)] {
-                run_transport(4096, Some(unknown_part), false).await;
+                run_transport(4096, Some(unknown_part)).await;
             }
         }
 
         #[tokio::test]
         async fn multipart_transport_preserves_transformed_empty_tail() {
-            run_transport(0, Some((1, 0)), false).await;
+            run_transport(0, Some((1, 0))).await;
         }
 
-        /// SSE-C passthrough of a compressed object: the stored bytes go out
-        /// as-is and every UploadPart declares the part's plaintext length
-        /// (backlog#2363).
-        #[tokio::test]
-        async fn multipart_transport_declares_passthrough_part_lengths() {
-            run_transport(4096, None, true).await;
-        }
-
-        #[tokio::test]
-        async fn multipart_transport_checks_positive_compressed_part_totals() {
-            const MIB: i64 = 1024 * 1024;
-            for etag_present in [true, false] {
-                run_compressed_transport([5 * MIB, MIB], etag_present, true, None).await;
-                run_compressed_transport([5 * MIB, MIB / 2], etag_present, false, None).await;
-            }
-        }
-
-        #[tokio::test]
-        async fn multipart_transport_checks_positive_compressed_part_boundaries() {
-            const MIB: i64 = 1024 * 1024;
-            for etag_present in [true, false] {
-                run_compressed_transport([5 * MIB + MIB / 2, MIB / 2], etag_present, false, None).await;
-            }
-        }
-
-        #[derive(Clone, Copy)]
-        enum SourceReadFault {
-            Short,
-            Extra,
-        }
-
-        #[tokio::test]
-        async fn multipart_transport_requires_complete_compressed_stream() {
-            const MIB: i64 = 1024 * 1024;
-            for fault in [SourceReadFault::Short, SourceReadFault::Extra] {
-                run_compressed_transport([5 * MIB, MIB], true, false, Some(fault)).await;
-            }
-        }
-
-        async fn run_compressed_transport(
-            actual_sizes: [i64; 2],
-            etag_present: bool,
-            valid_layout: bool,
-            fault: Option<SourceReadFault>,
-        ) {
-            use crate::io_support::rio::TryGetIndex as _;
-            use rustfs_utils::CompressionAlgorithm;
-            use tokio::io::AsyncReadExt as _;
-
-            const MIB: usize = 1024 * 1024;
-            let body = Bytes::from([vec![0x11; 5 * MIB], vec![0x22; MIB / 2], vec![0x33; MIB / 2]].concat());
-            let mut stored = Vec::new();
-            let mut parts = Vec::new();
-            for (index, plaintext) in [body.slice(..5 * MIB), body.slice(5 * MIB..)].into_iter().enumerate() {
-                let mut compressor = crate::io_support::rio::compression_reader(
-                    std::io::Cursor::new(plaintext),
-                    CompressionAlgorithm::default(),
-                    false,
-                );
-                let mut compressed = Vec::new();
-                compressor.read_to_end(&mut compressed).await.expect("compress source part");
-                parts.push(ObjectPartInfo {
-                    number: index + 1,
-                    size: compressed.len(),
-                    actual_size: actual_sizes[index],
-                    index: compressor
-                        .try_get_index()
-                        .map(crate::io_support::rio::compression_index_storage_bytes),
-                    ..Default::default()
-                });
-                stored.extend_from_slice(&compressed);
-            }
-            let mut metadata = HashMap::new();
-            rustfs_utils::http::insert_str(
-                &mut metadata,
-                rustfs_utils::http::SUFFIX_COMPRESSION,
-                crate::io_support::rio::compression_metadata_value(CompressionAlgorithm::default()),
-            );
-            rustfs_utils::http::insert_str(&mut metadata, rustfs_utils::http::SUFFIX_ACTUAL_SIZE, body.len().to_string());
+        async fn run_transport(tail_size: usize, unknown_part: Option<(usize, i64)>) {
+            const FIRST_SIZE: usize = 5 * 1024 * 1024;
+            let body = Bytes::from([vec![0x35; FIRST_SIZE], vec![0xa7; tail_size]].concat());
+            let etag = faster_hex::hex_string(rustfs_utils::hash::HashAlgorithm::Md5.hash_encode(&body).as_ref());
             let source = Arc::new(Source {
                 info: ObjectInfo {
-                    bucket: "source".to_string(),
-                    name: "object".to_string(),
-                    size: i64::try_from(stored.len()).expect("stored size"),
-                    actual_size: i64::try_from(body.len()).expect("plaintext size"),
-                    etag: etag_present
-                        .then(|| faster_hex::hex_string(rustfs_utils::hash::HashAlgorithm::Md5.hash_encode(&body).as_ref())),
+                    size: i64::try_from(body.len() + if unknown_part.is_some() { 16 } else { 0 }).expect("stored size"),
+                    actual_size: i64::try_from(body.len()).expect("body size"),
+                    etag: Some(etag.clone()),
                     version_id: Some(Uuid::new_v4()),
-                    user_defined: Arc::new(metadata),
-                    parts: Arc::new(parts),
+                    user_defined: Arc::new(if unknown_part.is_some() {
+                        HashMap::from([("x-amz-server-side-encryption".to_string(), "AES256".to_string())])
+                    } else {
+                        HashMap::new()
+                    }),
+                    parts: Arc::new(vec![
+                        ObjectPartInfo {
+                            number: 1,
+                            size: FIRST_SIZE + if unknown_part.is_some() { 8 } else { 0 },
+                            actual_size: if let Some((0, size)) = unknown_part {
+                                size
+                            } else if unknown_part.is_some() || tail_size == 0 {
+                                i64::try_from(FIRST_SIZE).expect("first part size")
+                            } else {
+                                0
+                            },
+                            ..Default::default()
+                        },
+                        ObjectPartInfo {
+                            number: 2,
+                            size: tail_size + if unknown_part.is_some() { 8 } else { 0 },
+                            actual_size: if let Some((1, size)) = unknown_part {
+                                size
+                            } else if unknown_part.is_some() {
+                                i64::try_from(tail_size).expect("tail logical size")
+                            } else {
+                                0
+                            },
+                            ..Default::default()
+                        },
+                    ]),
                     ..Default::default()
                 },
                 body: body.clone(),
                 ranges: StdMutex::new(Vec::new()),
                 full_reads: std::sync::atomic::AtomicUsize::new(0),
             });
-            let opts = ObjectOptions {
-                version_id: source.info.version_id.map(|id| id.to_string()),
-                ..Default::default()
-            };
-            let mut full = source
-                .get_object_reader("source", "object", None, HeaderMap::new(), &opts)
-                .await
-                .expect("open complete compressed source");
-            let decoded = full.read_all().await.expect("decode complete source");
-            assert!(
-                decoded.as_slice() == body.as_ref(),
-                "the independent full GET must match every source byte"
-            );
-
-            let (target, journal, server) = start_transport_target().await;
-            let (put_opts, is_multipart) = replication_put_object_options("STANDARD", &source.info).expect("replication options");
-            let mut reader = source
-                .get_object_reader("source", "object", None, HeaderMap::new(), &opts)
-                .await
-                .expect("open replication source");
-            match fault {
-                Some(SourceReadFault::Short) => {
-                    reader.stream = Box::new(
-                        reader
-                            .stream
-                            .take(u64::try_from(body.len() - 1).expect("short stream length")),
-                    );
-                }
-                Some(SourceReadFault::Extra) => {
-                    reader.stream = Box::new(reader.stream.chain(std::io::Cursor::new(vec![0x44])));
-                }
-                None => {}
-            }
-            let result = tokio::time::timeout(
-                std::time::Duration::from_secs(30),
-                replicate_all_payload_to_target(
-                    ReplicateAllPayloadContext {
-                        storage: &source,
-                        tgt_client: &target,
-                        bucket: "source",
-                        object: "object",
-                        object_info: &source.info,
-                        obj_opts: &opts,
-                        arn: &target.arn,
-                        transfer_size: i64::try_from(body.len()).expect("plaintext size"),
-                        is_multipart,
-                        put_opts,
-                    },
-                    reader,
-                ),
-            )
-            .await;
-            server.abort();
-            assert!(server.await.expect_err("fixture server is stopped").is_cancelled());
-            let result = result.expect("replication must finish");
-            let requests = journal.lock().expect("request journal lock");
-            let completes: Vec<_> = requests
-                .iter()
-                .filter(|request| request.method == http::Method::POST && request.query.contains_key("uploadId"))
-                .collect();
-            if result.is_err() {
-                assert!(!valid_layout, "valid compressed layout must replicate: {result:?}");
-                assert!(completes.is_empty(), "failed replication must not publish a partial object");
-                assert!(
-                    requests
-                        .iter()
-                        .any(|request| request.method == http::Method::DELETE && request.query.contains_key("uploadId")),
-                    "failed multipart upload must be aborted"
-                );
-                return;
-            }
-            assert!(fault.is_none(), "a short or oversized source must fail before Complete");
-            assert_eq!(requests.len(), 4, "initiate, two parts and complete without retries");
-            assert_eq!(completes.len(), 1, "publish the replica once");
-            let mut replica = Vec::new();
-            for number in [1, 2] {
-                let part = requests
-                    .iter()
-                    .find(|request| request.query.get("partNumber") == Some(&number.to_string()))
-                    .expect("completed source part");
-                assert_eq!(part.method, http::Method::PUT);
-                replica.extend_from_slice(&part.body);
-                let complete_xml = std::str::from_utf8(&completes[0].body).expect("complete XML");
-                assert!(complete_xml.contains(&format!("<PartNumber>{number}</PartNumber>")));
-            }
-            assert!(
-                replica.as_slice() == body.as_ref(),
-                "replica differs from complete GET: sizes={actual_sizes:?}, source={}, replica={}",
-                body.len(),
-                replica.len()
-            );
-            if let Some(etag) = &source.info.etag {
-                assert_eq!(
-                    rustfs_utils::http::get_header(&completes[0].headers, rustfs_utils::http::SUFFIX_SOURCE_ETAG).as_deref(),
-                    Some(etag.as_str())
-                );
-            }
-        }
-
-        async fn start_transport_target() -> (Arc<TargetClient>, Arc<StdMutex<Vec<RequestRecord>>>, tokio::task::JoinHandle<()>) {
             let journal = Arc::new(StdMutex::new(Vec::<RequestRecord>::new()));
             let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
                 .await
@@ -8537,13 +8329,7 @@ mod tests {
                                     let query: HashMap<String, String> = url::form_urlencoded::parse(
                                         request.uri.query().unwrap_or_default().as_bytes(),
                                     ).into_owned().collect();
-                                    let body = match body.collect().await {
-                                        Ok(body) => body.to_bytes(),
-                                        Err(_) => return Ok::<_, Infallible>(hyper::Response::builder()
-                                            .status(http::StatusCode::BAD_REQUEST)
-                                            .body(Full::new(Bytes::new()))
-                                            .expect("incomplete upload response")),
-                                    };
+                                    let body = body.collect().await.expect("read complete multipart request body").to_bytes();
                                     let response = if request.method == http::Method::POST && query.contains_key("uploads") {
                                         "<InitiateMultipartUploadResult><Bucket>target-bucket</Bucket><Key>object</Key><UploadId>upload-1</UploadId></InitiateMultipartUploadResult>"
                                     } else if request.method == http::Method::PUT {
@@ -8585,85 +8371,9 @@ mod tests {
                 .force_path_style(true)
                 .build();
             Arc::get_mut(&mut target).expect("unshared test target").client = Arc::new(aws_sdk_s3::Client::from_conf(config));
-            (target, journal, server)
-        }
-
-        async fn run_transport(tail_size: usize, unknown_part: Option<(usize, i64)>, passthrough: bool) {
-            const FIRST_SIZE: usize = 5 * 1024 * 1024;
-            // The stored (compressed ciphertext) bytes of a passthrough part
-            // are shorter than the plaintext they represent.
-            const PASSTHROUGH_PLAINTEXT_FACTOR: usize = 4;
-            let body = Bytes::from([vec![0x35; FIRST_SIZE], vec![0xa7; tail_size]].concat());
-            let etag = faster_hex::hex_string(rustfs_utils::hash::HashAlgorithm::Md5.hash_encode(&body).as_ref());
-            let mut user_defined = if unknown_part.is_some() {
-                HashMap::from([("x-amz-server-side-encryption".to_string(), "AES256".to_string())])
-            } else {
-                HashMap::new()
-            };
-            if passthrough {
-                user_defined.insert(rustfs_utils::http::SSEC_ALGORITHM_HEADER.to_string(), "AES256".to_string());
-                rustfs_utils::http::insert_str(
-                    &mut user_defined,
-                    rustfs_utils::http::SUFFIX_COMPRESSION,
-                    "klauspost/compress/s2".to_string(),
-                );
-            }
-            let plaintext_len = |stored: usize| {
-                i64::try_from(if passthrough {
-                    stored * PASSTHROUGH_PLAINTEXT_FACTOR
-                } else {
-                    stored
-                })
-                .expect("plaintext size")
-            };
-            let source = Arc::new(Source {
-                info: ObjectInfo {
-                    size: i64::try_from(body.len() + if unknown_part.is_some() { 16 } else { 0 }).expect("stored size"),
-                    actual_size: plaintext_len(body.len()),
-                    etag: Some(etag.clone()),
-                    version_id: Some(Uuid::new_v4()),
-                    user_defined: Arc::new(user_defined),
-                    parts: Arc::new(vec![
-                        ObjectPartInfo {
-                            number: 1,
-                            size: FIRST_SIZE + if unknown_part.is_some() { 8 } else { 0 },
-                            actual_size: if let Some((0, size)) = unknown_part {
-                                size
-                            } else if passthrough {
-                                plaintext_len(FIRST_SIZE)
-                            } else if unknown_part.is_some() || tail_size == 0 {
-                                i64::try_from(FIRST_SIZE).expect("first part size")
-                            } else {
-                                0
-                            },
-                            ..Default::default()
-                        },
-                        ObjectPartInfo {
-                            number: 2,
-                            size: tail_size + if unknown_part.is_some() { 8 } else { 0 },
-                            actual_size: if let Some((1, size)) = unknown_part {
-                                size
-                            } else if passthrough {
-                                plaintext_len(tail_size)
-                            } else if unknown_part.is_some() {
-                                i64::try_from(tail_size).expect("tail logical size")
-                            } else {
-                                0
-                            },
-                            ..Default::default()
-                        },
-                    ]),
-                    ..Default::default()
-                },
-                body: body.clone(),
-                ranges: StdMutex::new(Vec::new()),
-                full_reads: std::sync::atomic::AtomicUsize::new(0),
-            });
-            let (target, journal, server) = start_transport_target().await;
             let (put_opts, is_multipart) = replication_put_object_options("STANDARD", &source.info).expect("replication options");
             let opts = ObjectOptions {
                 version_id: source.info.version_id.map(|id| id.to_string()),
-                raw_data_movement_read: passthrough,
                 ..Default::default()
             };
             let reader = source
@@ -8746,36 +8456,6 @@ mod tests {
                     requests[index].headers.get("content-length").expect("part content length"),
                     expected.len().to_string().as_str()
                 );
-                let declared = rustfs_utils::http::get_header(
-                    &requests[index].headers,
-                    rustfs_utils::http::SUFFIX_REPLICATION_PART_ACTUAL_SIZE,
-                );
-                if passthrough {
-                    assert_eq!(
-                        declared.as_deref(),
-                        Some(plaintext_len(expected.len()).to_string().as_str()),
-                        "passthrough parts declare their plaintext length"
-                    );
-                } else {
-                    assert!(declared.is_none(), "decrypted transport carries no passthrough part length");
-                }
-            }
-            if passthrough {
-                let create = &requests[0];
-                assert_eq!(
-                    rustfs_utils::http::get_header(&create.headers, rustfs_utils::http::SUFFIX_REPLICATION_COMPRESSION)
-                        .as_deref(),
-                    Some("klauspost/compress/s2"),
-                    "the session carries the source's compression scheme"
-                );
-                assert_eq!(
-                    rustfs_utils::http::get_header(
-                        &create.headers,
-                        rustfs_utils::http::SUFFIX_REPLICATION_COMPRESSION_ACTUAL_SIZE
-                    )
-                    .as_deref(),
-                    Some(plaintext_len(body.len()).to_string().as_str())
-                );
             }
             let complete = &requests[3];
             assert_eq!(complete.method, http::Method::POST);

crates/ecstore/src/bucket/replication/replication_target_boundary.rs

@@ -247,23 +247,6 @@ pub(crate) fn replication_put_object_options(sc: &str, object_info: &ObjectInfo)
         meta.insert(key.to_string(), value.to_string());
     }
 
-    // A compressed SSE-C object passes through as its stored bytes. The target
-    // cannot infer the compression layout from ciphertext, so the scheme and
-    // the plaintext size travel as transport headers; each UploadPart carries
-    // its own plaintext length (backlog#2363).
-    if is_ssec && let Some(scheme) = get_str(&object_info.user_defined, rustfs_utils::http::SUFFIX_COMPRESSION) {
-        insert_header_map(&mut meta, rustfs_utils::http::SUFFIX_REPLICATION_COMPRESSION, scheme);
-        if let Ok(actual_size) = object_info.get_actual_size()
-            && actual_size >= 0
-        {
-            insert_header_map(
-                &mut meta,
-                rustfs_utils::http::SUFFIX_REPLICATION_COMPRESSION_ACTUAL_SIZE,
-                actual_size.to_string(),
-            );
-        }
-    }
-
     // Managed SSE replicates as plaintext (the replication reader decrypts via
     // the object-encryption resolver) and re-encrypts on the target with the
     // target's own KMS. Send only the encryption intent — never the source
@@ -643,59 +626,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn compressed_ssec_objects_declare_their_compression_layout_on_the_wire() {
-        use rustfs_utils::http::{
-            SUFFIX_ACTUAL_SIZE, SUFFIX_COMPRESSION, SUFFIX_REPLICATION_COMPRESSION, SUFFIX_REPLICATION_COMPRESSION_ACTUAL_SIZE,
-            insert_str,
-        };
-
-        let mut ssec_compressed = HashMap::from([(SSEC_ALGORITHM_HEADER.to_string(), "AES256".to_string())]);
-        insert_str(&mut ssec_compressed, SUFFIX_COMPRESSION, "klauspost/compress/s2".to_string());
-        insert_str(&mut ssec_compressed, SUFFIX_ACTUAL_SIZE, "6295552".to_string());
-        let object_info = ObjectInfo {
-            etag: Some("0123456789abcdef0123456789abcdef-2".to_string()),
-            size: 4321,
-            actual_size: 6295552,
-            user_defined: Arc::new(ssec_compressed),
-            ..Default::default()
-        };
-
-        // SSE-C passthrough sends stored bytes: the scheme and the plaintext
-        // size travel as transport headers, never as the internal key
-        // (backlog#2363).
-        let (options, _) = replication_put_object_options("STANDARD", &object_info).expect("ssec put options");
-        assert_eq!(
-            get_header_map(&options.user_metadata, SUFFIX_REPLICATION_COMPRESSION).as_deref(),
-            Some("klauspost/compress/s2")
-        );
-        assert_eq!(
-            get_header_map(&options.user_metadata, SUFFIX_REPLICATION_COMPRESSION_ACTUAL_SIZE).as_deref(),
-            Some("6295552")
-        );
-        assert!(
-            !options
-                .user_metadata
-                .keys()
-                .any(|key| rustfs_utils::http::is_internal_key(key)),
-            "internal metadata never leaves the source as plain metadata: {:?}",
-            options.user_metadata
-        );
-
-        // A compressed object that is not SSE-C is decompressed by the
-        // replication reader and travels as plaintext: no layout headers.
-        let mut plain_compressed = HashMap::new();
-        insert_str(&mut plain_compressed, SUFFIX_COMPRESSION, "klauspost/compress/s2".to_string());
-        insert_str(&mut plain_compressed, SUFFIX_ACTUAL_SIZE, "6295552".to_string());
-        let plain = ObjectInfo {
-            user_defined: Arc::new(plain_compressed),
-            ..object_info
-        };
-        let (options, _) = replication_put_object_options("STANDARD", &plain).expect("plain put options");
-        assert!(get_header_map(&options.user_metadata, SUFFIX_REPLICATION_COMPRESSION).is_none());
-        assert!(get_header_map(&options.user_metadata, SUFFIX_REPLICATION_COMPRESSION_ACTUAL_SIZE).is_none());
-    }
-
     #[test]
     fn legacy_transformed_single_put_parts_keep_the_previous_replication_route() {
         let [_, (_, compressed), (_, encrypted), (_, ssec)] = replication_route_metadata();

crates/ecstore/src/config/storageclass.rs

@@ -747,27 +747,18 @@ mod tests {
         let mut kvs = KVS::new();
         kvs.insert(CLASS_STANDARD.to_string(), "EC:2".to_string());
 
-        for drives in [2, 3] {
-            let err = lookup_config_for_pools_with_env(&kvs, &[4, drives], no_env_overrides())
-                .expect_err("EC:2 must be rejected by a pool with fewer than four drives per set");
-            assert!(
-                err.to_string().contains("pool 1") && err.to_string().contains(&format!("{drives} drives")),
-                "error must identify the rejecting pool: {err}"
-            );
-        }
-
-        let cfg =
-            lookup_config_for_pools_with_env(&kvs, &[4, 4], no_env_overrides()).expect("EC:2 is valid for both four-drive pools");
-        assert_eq!(cfg.parities_for_sc(STANDARD), Some(vec![2, 2]));
+        let err = lookup_config_for_pools_with_env(&kvs, &[4, 2], no_env_overrides())
+            .expect_err("EC:2 must be rejected by the two-drive pool");
+        assert!(
+            err.to_string().contains("pool 1") && err.to_string().contains("2 drives"),
+            "error must identify the rejecting pool: {err}"
+        );
 
         kvs.insert(CLASS_STANDARD.to_string(), "EC:1".to_string());
-        for drives in [2, 3, 4] {
-            let cfg =
-                lookup_config_for_pools_with_env(&kvs, &[4, drives], no_env_overrides()).expect("EC:1 is valid for both pools");
-            assert_eq!(cfg.parity_for_sc(STANDARD, 4), Some(1));
-            assert_eq!(cfg.parity_for_sc(STANDARD, drives), Some(1));
-            assert_eq!(cfg.get_parity_for_sc(STANDARD), Some(1));
-        }
+        let cfg = lookup_config_for_pools_with_env(&kvs, &[4, 2], no_env_overrides()).expect("EC:1 is valid for both pools");
+        assert_eq!(cfg.parity_for_sc(STANDARD, 4), Some(1));
+        assert_eq!(cfg.parity_for_sc(STANDARD, 2), Some(1));
+        assert_eq!(cfg.get_parity_for_sc(STANDARD), Some(1));
     }
 
     #[test]

crates/ecstore/src/core/pools_test.rs

@@ -39,7 +39,6 @@ mod capacity_dedup_tests {
                 ..Default::default()
             },
             disks: disks.clone(),
-            ..Default::default()
         };
 
         let total = get_total_usable_capacity(&disks, &info);
@@ -74,7 +73,6 @@ mod capacity_dedup_tests {
                 ..Default::default()
             },
             disks: disks.clone(),
-            ..Default::default()
         };
 
         let total = get_total_usable_capacity(&disks, &info);
@@ -152,7 +150,6 @@ mod capacity_dedup_tests {
                 ..Default::default()
             },
             disks: disks.clone(),
-            ..Default::default()
         };
 
         let total = get_total_usable_capacity(&disks, &info);

crates/ecstore/src/disk/error.rs

@@ -425,7 +425,6 @@ impl From<rustfs_filemeta::Error> for DiskError {
             rustfs_filemeta::Error::FileVersionNotFound => DiskError::FileVersionNotFound,
             rustfs_filemeta::Error::FileCorrupt => DiskError::FileCorrupt,
             rustfs_filemeta::Error::MethodNotAllowed => DiskError::MethodNotAllowed,
-            rustfs_filemeta::Error::MaxVersionsExceeded => DiskError::MaxVersionsExceeded,
             e => DiskError::other(e),
         }
     }

crates/ecstore/src/disk/os.rs

@@ -263,7 +263,7 @@ pub(crate) mod fsync_dir_recorder {
 }
 
 /// Pause a real namespace mutation inside its physical executor.
-#[cfg(all(any(test, feature = "test-util"), not(windows)))]
+#[cfg(all(test, not(windows)))]
 pub(crate) mod prepared_publication_test_hooks {
     use super::*;
 
@@ -272,9 +272,7 @@ pub(crate) mod prepared_publication_test_hooks {
         PreparedRename,
         Rename,
         Remove,
-        #[cfg(test)]
         Rollback,
-        #[cfg(test)]
         DirFsync,
     }
 
@@ -290,7 +288,6 @@ pub(crate) mod prepared_publication_test_hooks {
         }
     }
 
-    #[cfg(test)]
     pub(crate) fn install(path: &Path, hook: impl FnOnce() + Send + 'static) -> Guard {
         install_at(Stage::PreparedRename, path, hook)
     }
@@ -349,51 +346,6 @@ pub(crate) mod prepared_publication_test_hooks {
     }
 }
 
-/// Controlled application-test pause at an existing physical executor boundary.
-#[cfg(all(feature = "test-util", not(windows)))]
-pub struct LocalPublicationPause {
-    _hook: prepared_publication_test_hooks::Guard,
-    entered: oneshot::Receiver<()>,
-    _release: std::sync::mpsc::Sender<()>,
-}
-
-#[cfg(all(feature = "test-util", not(windows)))]
-#[derive(Clone, Copy)]
-pub enum LocalPublicationStage {
-    PreparedRename,
-    Rename,
-    Remove,
-}
-
-#[cfg(all(feature = "test-util", not(windows)))]
-impl LocalPublicationPause {
-    pub fn install(disk: &crate::disk::Disk, volume: &str, path: &str, stage: LocalPublicationStage) -> Result<Self> {
-        let path = disk
-            .get_object_path_for_io_if_local(volume, path)
-            .ok_or(DiskError::DiskNotFound)??;
-        let stage = match stage {
-            LocalPublicationStage::PreparedRename => prepared_publication_test_hooks::Stage::PreparedRename,
-            LocalPublicationStage::Rename => prepared_publication_test_hooks::Stage::Rename,
-            LocalPublicationStage::Remove => prepared_publication_test_hooks::Stage::Remove,
-        };
-        let (entered_tx, entered) = oneshot::channel();
-        let (release, release_rx) = std::sync::mpsc::channel::<()>();
-        let hook = prepared_publication_test_hooks::install_at(stage, &path, move || {
-            let _ = entered_tx.send(());
-            let _ = release_rx.recv();
-        });
-        Ok(Self {
-            _hook: hook,
-            entered,
-            _release: release,
-        })
-    }
-
-    pub async fn entered(&mut self) -> std::result::Result<(), oneshot::error::RecvError> {
-        (&mut self.entered).await
-    }
-}
-
 #[cfg(all(test, windows))]
 pub(crate) mod windows_rename_test_hooks {
     use super::*;
@@ -2024,7 +1976,7 @@ pub(crate) async fn remove_file_with_owner(
     let path = path.as_ref().to_path_buf();
     let lease = acquire_namespace_mutation_lease_with_owner(&path, namespace_owner).await;
     run_blocking_namespace_operation(lease, move || {
-        #[cfg(all(any(test, feature = "test-util"), not(windows)))]
+        #[cfg(all(test, not(windows)))]
         prepared_publication_test_hooks::run(prepared_publication_test_hooks::Stage::Remove, &path);
         std::fs::remove_file(path)
     })
@@ -2284,7 +2236,7 @@ pub(crate) async fn rename_all_with_prepared_source(
         move || {
             validate_prepared_rename_source(&prepared_source, &src_file_path)?;
             let preparation = prepare_rename_with_retry(&src_file_path, &dst_file_path, &base_dir, &publication_root)?;
-            #[cfg(any(test, feature = "test-util"))]
+            #[cfg(test)]
             prepared_publication_test_hooks::run(prepared_publication_test_hooks::Stage::PreparedRename, &dst_file_path);
             rename_prepared(&src_file_path, &dst_file_path, &preparation)
         }
@@ -2417,7 +2369,7 @@ async fn reliable_rename_inner_with_lease(
             let preparation = prepare_rename_with_retry(&src_file_path, &dst_file_path, &base_dir, &publication_root)?;
             #[cfg(all(test, not(windows)))]
             prepared_publication_test_hooks::run_rename_destination(&src_file_path, &dst_file_path);
-            #[cfg(all(any(test, feature = "test-util"), not(windows)))]
+            #[cfg(all(test, not(windows)))]
             {
                 prepared_publication_test_hooks::run(prepared_publication_test_hooks::Stage::Rename, &src_file_path);
                 prepared_publication_test_hooks::run(prepared_publication_test_hooks::Stage::Rename, &dst_file_path);

crates/ecstore/src/erasure/coding/encode.rs

@@ -431,7 +431,7 @@ impl<'a> MultiWriter<'a> {
             errs = ?self.errs,
             "Erasure encode write quorum unavailable: {summary_text}"
         );
-        Err(write_err.into())
+        Err(std::io::Error::other(format!("Failed to write data: {summary_text}")))
     }
 
     async fn shutdown_writer(writer_opt: &mut Option<BitrotWriterWrapper>, err: &mut Option<Error>) {
@@ -503,7 +503,7 @@ impl<'a> MultiWriter<'a> {
             errs = ?self.errs,
             "Erasure encode shutdown quorum unavailable: {summary_text}"
         );
-        Err(write_err.into())
+        Err(std::io::Error::other(format!("Failed to shutdown writers: {summary_text}")))
     }
 }
 
@@ -1002,7 +1002,6 @@ impl Erasure {
 mod tests {
     use super::*;
     use crate::erasure::coding::{BitrotWriterWrapper, CustomWriter};
-    use crate::error::StorageError;
     use rustfs_rio::HardLimitReader;
     use rustfs_utils::HashAlgorithm;
     use std::future::Future;
@@ -1452,14 +1451,7 @@ mod tests {
             Ok(_) => panic!("writer quorum failure should fail the encode pipeline"),
             Err(err) => err,
         };
-        let err = StorageError::from(err);
-        assert!(matches!(
-            &err,
-            StorageError::Io(source)
-                if source.kind() == std::io::ErrorKind::Other
-                    && source.to_string() == "injected write failure after producer blocks"
-        ));
-        assert!(!err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to write data"));
         tokio::time::timeout(Duration::from_secs(1), reader_dropped)
             .await
             .expect("writer failure should abort the blocked producer")
@@ -1652,7 +1644,7 @@ mod tests {
 
     #[tokio::test]
     async fn multi_writer_short_write_fails_before_shutdown() {
-        let mut writers = vec![Some(bitrot_writer(ShortWriteWriter, 32))];
+        let mut writers = vec![Some(bitrot_writer(ShortWriteWriter, 16))];
         let err = {
             let mut writer = MultiWriter::new(&mut writers, 1);
             writer
@@ -1661,93 +1653,63 @@ mod tests {
                 .expect_err("short writes must fail the shard writer")
         };
 
-        let err = StorageError::from(err);
-        assert!(matches!(&err, StorageError::Io(source) if source.kind() == std::io::ErrorKind::WriteZero));
-        assert!(!err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to write data"));
         assert!(writers[0].is_none(), "short-write shard must be removed before commit");
     }
 
     #[tokio::test]
     async fn multi_writer_reports_fallback_summary_when_only_offline_writers_remain() {
         let mut writers = vec![None, None];
-        let (err, summary) = {
+        let err = {
             let mut writer = MultiWriter::new(&mut writers, 1);
-            let err = writer
+            writer
                 .write(vec![Bytes::from_static(b"offline-a"), Bytes::from_static(b"offline-b")])
                 .await
-                .expect_err("offline writers cannot satisfy write quorum");
-            let summary = build_write_quorum_failure_summary(&writer.errs, OBJECT_OP_IGNORED_ERRS, writer.write_quorum);
-            (err, format_write_quorum_failure(&summary))
+                .expect_err("offline writers cannot satisfy write quorum")
         };
 
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
-        assert!(summary.contains("offline-disks=2/2"));
-        assert!(summary.contains("required=1"));
+        let err = err.to_string();
+        assert!(err.contains("Failed to write data"));
+        assert!(err.contains("offline-disks=2/2"));
+        assert!(err.contains("required=1"));
 
-        let (shutdown_err, summary) = {
+        let shutdown_err = {
             let mut writer = MultiWriter::new(&mut writers, 1);
-            let err = writer
+            writer
                 .shutdown()
                 .await
-                .expect_err("offline writers cannot satisfy shutdown quorum");
-            let summary = build_write_quorum_failure_summary(&writer.errs, OBJECT_OP_IGNORED_ERRS, writer.write_quorum);
-            (err, format_write_quorum_failure(&summary))
+                .expect_err("offline writers cannot satisfy shutdown quorum")
         };
 
-        assert_eq!(
-            shutdown_err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let shutdown_err = StorageError::from(shutdown_err);
-        assert_eq!(shutdown_err, StorageError::ErasureWriteQuorum);
-        assert!(shutdown_err.is_quorum_error());
-        assert!(summary.contains("offline-disks=2/2"));
-        assert!(summary.contains("required=1"));
+        let shutdown_err = shutdown_err.to_string();
+        assert!(shutdown_err.contains("Failed to shutdown writers"));
+        assert!(shutdown_err.contains("offline-disks=2/2"));
+        assert!(shutdown_err.contains("required=1"));
     }
 
     #[tokio::test]
     async fn multi_writer_reports_quorum_failure_when_quorum_exceeds_writer_count() {
         let committed = Arc::new(Mutex::new(Vec::new()));
-        let mut writers = vec![Some(bitrot_writer(DeferredCommitWriter::new(committed), 32))];
+        let mut writers = vec![Some(bitrot_writer(DeferredCommitWriter::new(committed), 16))];
         let mut writer = MultiWriter::new(&mut writers, 2);
 
         let err = writer
             .write(vec![Bytes::from_static(b"quorum impossible")])
             .await
             .expect_err("write quorum above writer count must fail");
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
-        let summary = build_write_quorum_failure_summary(&writer.errs, OBJECT_OP_IGNORED_ERRS, writer.write_quorum);
-        let summary = format_write_quorum_failure(&summary);
-        assert!(summary.contains("required=2"));
-        assert!(summary.contains("erasure write quorum"));
+        let err = err.to_string();
+        assert!(err.contains("Failed to write data"));
+        assert!(err.contains("required=2"));
+        assert!(err.contains("erasure write quorum"));
 
         let shutdown_err = writer
             .shutdown()
             .await
             .expect_err("shutdown quorum above writer count must fail");
-        assert_eq!(
-            shutdown_err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let shutdown_err = StorageError::from(shutdown_err);
-        assert_eq!(shutdown_err, StorageError::ErasureWriteQuorum);
-        assert!(shutdown_err.is_quorum_error());
-        let summary = build_write_quorum_failure_summary(&writer.errs, OBJECT_OP_IGNORED_ERRS, writer.write_quorum);
-        let summary = format_write_quorum_failure(&summary);
-        assert!(summary.contains("required=2"));
-        assert!(summary.contains("erasure write quorum"));
+        let shutdown_err = shutdown_err.to_string();
+        assert!(shutdown_err.contains("Failed to shutdown writers"));
+        assert!(shutdown_err.contains("required=2"));
+        assert!(shutdown_err.contains("erasure write quorum"));
     }
 
     // The production wiring (`MultiWriter::new`) must arm a real deadline by
@@ -1832,13 +1794,7 @@ mod tests {
             .write(four_shards())
             .await
             .expect_err("two stalled writers must fail the write quorum instead of hanging");
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to write data"));
     }
 
     // A small object whose bytes were fully buffered leaves `write` succeeding
@@ -1883,13 +1839,7 @@ mod tests {
             .shutdown()
             .await
             .expect_err("two shutdown stalls must fail the shutdown quorum instead of hanging");
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to shutdown writers"));
     }
 
     // A slow-but-honest writer that keeps completing shards (delay < stall
@@ -2171,13 +2121,7 @@ mod tests {
             .await
             .expect_err("streaming encode must fail when write quorum is unavailable");
 
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to write data"));
     }
 
     #[tokio::test]
@@ -2201,13 +2145,7 @@ mod tests {
             .await
             .expect_err("write quorum failure must fail the inline encode");
 
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to write data"));
         assert!(
             committed.lock().expect("committed buffer should be lockable").is_empty(),
             "successful writer must not be committed when write quorum fails before shutdown"
@@ -2235,13 +2173,7 @@ mod tests {
             .await
             .expect_err("shutdown quorum failure must fail the inline encode");
 
-        let err = StorageError::from(err);
-        assert!(matches!(
-            &err,
-            StorageError::Io(source)
-                if source.kind() == std::io::ErrorKind::Other && source.to_string() == "injected shutdown failure"
-        ));
-        assert!(!err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to shutdown writers"));
         assert!(
             !committed.lock().expect("committed buffer should be lockable").is_empty(),
             "the successful writer should have committed before shutdown quorum failure was reported"
@@ -2463,13 +2395,7 @@ mod tests {
             .await
             .expect_err("batched encode must fail when write quorum is unavailable");
 
-        assert_eq!(
-            err.get_ref().and_then(|source| source.downcast_ref::<Error>()),
-            Some(&Error::ErasureWriteQuorum),
-        );
-        let err = StorageError::from(err);
-        assert_eq!(err, StorageError::ErasureWriteQuorum);
-        assert!(err.is_quorum_error());
+        assert!(err.to_string().contains("Failed to write data"));
     }
 
     #[tokio::test]

crates/ecstore/src/error/mod.rs

@@ -23,59 +23,17 @@ use s3s::S3ErrorCode;
 pub type Error = StorageError;
 pub type Result<T> = core::result::Result<T, Error>;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PoolMetadataFailure {
-    ReadUnavailable,
-    RecoveryRequired,
-    TransactionUnknown,
-    FenceLost,
-}
-
-impl PoolMetadataFailure {
-    fn recovery_hint(self) -> &'static str {
-        match self {
-            Self::ReadUnavailable => "read unavailable; retry after the replicas are readable",
-            Self::TransactionUnknown => "writes remain blocked pending fenced transaction recovery",
-            Self::RecoveryRequired | Self::FenceLost => {
-                "writes remain blocked after a recovery-required replica state; restart after all replicas are readable and consistent, with compatible formats"
-            }
-        }
-    }
-
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::ReadUnavailable => "read_unavailable",
-            Self::RecoveryRequired => "recovery_required",
-            Self::TransactionUnknown => "transaction_unknown",
-            Self::FenceLost => "fence_lost",
-        }
-    }
-}
-
-/// Local control-plane context. Keep the existing storage error wire codes;
-/// the HTTP boundary recognizes this typed source, not an error-message prefix.
-#[derive(Debug, Clone, thiserror::Error)]
-#[error("{operation}: pool metadata {hint} ({reason}, {phase}): {detail}", hint = kind.recovery_hint(), reason = kind.as_str(), detail = source.as_ref().map(ToString::to_string).unwrap_or_default())]
-pub struct PoolMetadataError {
-    pub kind: PoolMetadataFailure,
-    pub operation: String,
-    pub phase: &'static str,
-    pub since: time::OffsetDateTime,
-    #[source]
-    pub source: Option<std::sync::Arc<StorageError>>,
-}
-
 /// Keeps high-cardinality diagnostic detail in the error source while making
 /// the rendered `io::Error` stable for quorum aggregation.
 #[derive(Debug)]
 struct StableIoContextError {
-    message: std::borrow::Cow<'static, str>,
+    message: &'static str,
     source: Box<dyn std::error::Error + Send + Sync>,
 }
 
 impl std::fmt::Display for StableIoContextError {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        formatter.write_str(&self.message)
+        formatter.write_str(self.message)
     }
 }
 
@@ -90,7 +48,7 @@ where
     E: Into<Box<dyn std::error::Error + Send + Sync>>,
 {
     std::io::Error::other(StableIoContextError {
-        message: message.into(),
+        message,
         source: source.into(),
     })
 }
@@ -245,19 +203,6 @@ pub enum StorageError {
     NotFirstDisk,
     #[error("first disk wait")]
     FirstDiskWait,
-    #[error(
-        "unsupported pool expansion: an existing single-node single-drive (SNSD) deployment cannot be expanded in place (configured {configured_drives} drive endpoints); restart with the original single local path, or create a new multi-drive deployment and migrate data through S3"
-    )]
-    UnsupportedSnsdExpansion { configured_drives: usize },
-    #[error(
-        "pool topology mismatch: stored {stored_drives} drives with {stored_set_drive_count} drives per erasure set, configured {configured_drives} drives with {configured_set_drive_count} drives per erasure set; an existing pool's drive count and erasure set width cannot be changed in place; restore its original endpoints and RUSTFS_ERASURE_SET_DRIVE_COUNT setting; to expand a multi-drive deployment, append a new pool with at least 2 drive endpoints"
-    )]
-    PoolTopologyMismatch {
-        stored_drives: usize,
-        stored_set_drive_count: usize,
-        configured_drives: usize,
-        configured_set_drive_count: usize,
-    },
 
     // ── Operational ──────────────────────────────────────────────────
     #[error("Storage reached its minimum free drive threshold.")]
@@ -342,22 +287,6 @@ impl From<crate::erasure::coding::ErasureConstructionError> for StorageError {
 }
 
 impl StorageError {
-    pub fn pool_metadata_failure(&self) -> Option<&PoolMetadataError> {
-        let mut current: Option<&(dyn std::error::Error + 'static)> = Some(self);
-        while let Some(error) = current {
-            if let Some(context) = error.downcast_ref::<PoolMetadataError>() {
-                return Some(context);
-            }
-            // io::Error::source skips its boxed context itself.
-            current = if let Some(io) = error.downcast_ref::<std::io::Error>() {
-                io.get_ref().map(|inner| inner as &(dyn std::error::Error + 'static))
-            } else {
-                error.source()
-            };
-        }
-        None
-    }
-
     pub fn other<E>(error: E) -> Self
     where
         E: Into<Box<dyn std::error::Error + Send + Sync>>,
@@ -588,7 +517,6 @@ impl From<rustfs_filemeta::Error> for StorageError {
             rustfs_filemeta::Error::FileVersionNotFound => StorageError::FileVersionNotFound,
             rustfs_filemeta::Error::FileCorrupt => StorageError::FileCorrupt,
             rustfs_filemeta::Error::Unexpected => StorageError::Unexpected,
-            rustfs_filemeta::Error::MaxVersionsExceeded => StorageError::MaxVersionsExceeded,
             rustfs_filemeta::Error::Io(io_error) => io_error.into(),
             _ => StorageError::Io(std::io::Error::other(e)),
         }
@@ -607,19 +535,7 @@ impl PartialEq for StorageError {
 impl Clone for StorageError {
     fn clone(&self) -> Self {
         match self {
-            StorageError::Io(e) => {
-                if let Some(context) = self.pool_metadata_failure() {
-                    Self::Io(std::io::Error::new(
-                        e.kind(),
-                        StableIoContextError {
-                            message: e.to_string().into(),
-                            source: Box::new(context.clone()),
-                        },
-                    ))
-                } else {
-                    StorageError::Io(std::io::Error::new(e.kind(), e.to_string()))
-                }
-            }
+            StorageError::Io(e) => StorageError::Io(std::io::Error::new(e.kind(), e.to_string())),
             StorageError::FaultyDisk => StorageError::FaultyDisk,
             StorageError::DiskFull => StorageError::DiskFull,
             StorageError::VolumeNotFound => StorageError::VolumeNotFound,
@@ -713,20 +629,6 @@ impl Clone for StorageError {
             StorageError::ErasureWriteQuorum => StorageError::ErasureWriteQuorum,
             StorageError::NotFirstDisk => StorageError::NotFirstDisk,
             StorageError::FirstDiskWait => StorageError::FirstDiskWait,
-            StorageError::UnsupportedSnsdExpansion { configured_drives } => StorageError::UnsupportedSnsdExpansion {
-                configured_drives: *configured_drives,
-            },
-            StorageError::PoolTopologyMismatch {
-                stored_drives,
-                stored_set_drive_count,
-                configured_drives,
-                configured_set_drive_count,
-            } => StorageError::PoolTopologyMismatch {
-                stored_drives: *stored_drives,
-                stored_set_drive_count: *stored_set_drive_count,
-                configured_drives: *configured_drives,
-                configured_set_drive_count: *configured_set_drive_count,
-            },
             StorageError::TooManyOpenFiles => StorageError::TooManyOpenFiles,
             StorageError::NoHealRequired => StorageError::NoHealRequired,
             StorageError::Lock(e) => StorageError::Lock(e.clone()),
@@ -760,8 +662,7 @@ impl Clone for StorageError {
 }
 
 impl StorageError {
-    /// Stable classification without error payloads or storage paths.
-    pub fn code(&self) -> StorageErrorCode {
+    fn code(&self) -> StorageErrorCode {
         match self {
             StorageError::Io(_) => StorageErrorCode::Io,
             StorageError::FaultyDisk => StorageErrorCode::FaultyDisk,
@@ -834,11 +735,6 @@ impl StorageError {
             StorageError::ErasureWriteQuorum => StorageErrorCode::ErasureWriteQuorum,
             StorageError::NotFirstDisk => StorageErrorCode::NotFirstDisk,
             StorageError::FirstDiskWait => StorageErrorCode::FirstDiskWait,
-            // Topology diagnostics reuse the existing wire code; they are
-            // not disk errors and must retain their local identity for retry classification.
-            StorageError::UnsupportedSnsdExpansion { .. } | StorageError::PoolTopologyMismatch { .. } => {
-                StorageErrorCode::InvalidArgument
-            }
             StorageError::ConfigNotFound => StorageErrorCode::ConfigNotFound,
             StorageError::TooManyOpenFiles => StorageErrorCode::TooManyOpenFiles,
             StorageError::NoHealRequired => StorageErrorCode::NoHealRequired,
@@ -1319,29 +1215,6 @@ mod tests {
     use super::*;
     use std::io::{Error as IoError, ErrorKind};
 
-    #[test]
-    fn startup_topology_errors_preserve_identity_and_guidance() {
-        for error in [
-            StorageError::UnsupportedSnsdExpansion { configured_drives: 4 },
-            StorageError::PoolTopologyMismatch {
-                stored_drives: 4,
-                stored_set_drive_count: 4,
-                configured_drives: 8,
-                configured_set_drive_count: 8,
-            },
-        ] {
-            let io_error: IoError = error.clone().into();
-            let restored = StorageError::from(io_error);
-            assert_eq!(std::mem::discriminant(&restored), std::mem::discriminant(&error));
-            assert_eq!(restored.to_string(), error.to_string());
-            assert_eq!(restored.code(), StorageErrorCode::InvalidArgument);
-            assert!(
-                restored.narrow_to_disk().is_err(),
-                "startup diagnostics must not become disk/quorum errors"
-            );
-        }
-    }
-
     #[test]
     fn other_preserves_erasure_construction_source_chain() {
         use crate::erasure::coding::ErasureConstructionError;

crates/ecstore/src/layout/disks_layout.rs

@@ -25,20 +25,6 @@ pub(crate) const MAX_ERASURE_SET_DRIVE_COUNT: usize = 16;
 const SET_SIZES: [usize; 15] = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, MAX_ERASURE_SET_DRIVE_COUNT];
 const ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT: &str = "RUSTFS_ERASURE_SET_DRIVE_COUNT";
 
-#[derive(Debug, thiserror::Error)]
-enum PoolDriveCountError {
-    #[error(
-        "Incorrect number of endpoints provided, size {size}; an erasure pool requires at least {} drive endpoints on one or more nodes; for a standalone single-drive deployment, use a single local path without ellipses",
-        SET_SIZES[0]
-    )]
-    BelowMinimum { size: usize },
-    #[error(
-        "Incorrect number of endpoints provided, size {size}; {}={set_drive_count} requires at least {set_drive_count} drive endpoints per pool",
-        ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT
-    )]
-    BelowSetWidth { size: usize, set_drive_count: usize },
-}
-
 #[derive(Deserialize, Debug, Default)]
 pub struct PoolDisksLayout {
     cmd_line: String,
@@ -146,7 +132,7 @@ impl DisksLayout {
         for arg in args.iter() {
             if !has_ellipses(&[arg]) && args.len() > 1 {
                 return Err(Error::other(
-                    "all args must have ellipses for pool expansion (Invalid arguments specified); each pool must expand to at least 2 drive endpoints on one or more nodes; a single-drive pool cannot be added to a multi-pool deployment",
+                    "all args must have ellipses for pool expansion (Invalid arguments specified)",
                 ));
             }
 
@@ -410,11 +396,9 @@ fn get_set_indexes<T: AsRef<str>>(
     }
 
     for &size in total_sizes {
-        if size < SET_SIZES[0] {
-            return Err(Error::other(PoolDriveCountError::BelowMinimum { size }));
-        }
-        if size < set_drive_count {
-            return Err(Error::other(PoolDriveCountError::BelowSetWidth { size, set_drive_count }));
+        // Check if total_sizes has minimum range upto set_size
+        if size < SET_SIZES[0] || size < set_drive_count {
+            return Err(Error::other(format!("Incorrect number of endpoints provided, size {size}")));
         }
     }
 
@@ -723,7 +707,7 @@ mod test {
                 arg: "http://rustfs{2...3}/export/set{1...0}",
                 ..Default::default()
             },
-            // Ranges must use three dots.
+            // Range cannot be smaller than 4 minimum.
             TestCase {
                 num: 4,
                 arg: "/export{1..2}",
@@ -942,146 +926,11 @@ mod test {
         }
     }
 
-    #[test]
-    fn pool_expansion_accepts_single_node_multi_drive_pools() {
-        temp_env::with_var(ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT, Some("0"), || {
-            for (volumes, drives) in [
-                (["http://node1:9000/data{1...2}", "http://node2:9000/data{1...2}"], 2),
-                (["http://node1:9000/data{1...4}", "http://node2:9000/data{1...4}"], 4),
-                (["http://node{1...4}:9000/data", "http://node5:9000/data{1...4}"], 4),
-                (["http://node5:9000/data{1...4}", "http://node{1...4}:9000/data"], 4),
-            ] {
-                let layout = DisksLayout::from_volumes(&volumes).expect("single-node multi-drive pools are valid");
-
-                assert!(!layout.legacy);
-                assert_eq!(layout.pools.len(), 2);
-                for (index, volume) in volumes.iter().enumerate() {
-                    assert_eq!(layout.get_set_count(index), 1);
-                    assert_eq!(layout.get_drives_per_set(index), drives);
-                    assert_eq!(layout.get_cmd_line(index), *volume);
-                }
-            }
-        });
-    }
-
-    #[test]
-    fn pool_expansion_accepts_multi_node_single_drive_pools() {
-        temp_env::with_var(ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT, Some("0"), || {
-            for nodes in [2, 3, 4] {
-                let volumes = [
-                    format!("http://pool1-node{{1...{nodes}}}:9000/data"),
-                    format!("http://pool2-node{{1...{nodes}}}:9000/data"),
-                ];
-                let layout = DisksLayout::from_volumes(&volumes).expect("each node may contribute one drive to a pool");
-
-                assert_eq!(layout.pools.len(), 2);
-                for pool in 0..2 {
-                    assert_eq!(layout.get_set_count(pool), 1);
-                    assert_eq!(layout.get_drives_per_set(pool), nodes);
-                    let expected = (1..=nodes)
-                        .map(|node| format!("http://pool{}-node{node}:9000/data", pool + 1))
-                        .collect::<Vec<_>>();
-                    assert_eq!(layout.pools[pool].layout, vec![expected]);
-                }
-            }
-        });
-    }
-
-    #[test]
-    fn explicit_endpoints_without_ellipses_form_one_pool() {
-        temp_env::with_var(ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT, Some("0"), || {
-            let volumes = ["http://node1:9000/data", "http://node2:9000/data"];
-            let layout = DisksLayout::from_volumes(&volumes).expect("explicit endpoints form one legacy pool");
-
-            assert!(layout.legacy);
-            assert_eq!(layout.pools.len(), 1);
-            assert_eq!(layout.pools[0].layout, vec![volumes.to_vec()]);
-        });
-    }
-
-    #[test]
-    fn standalone_single_drive_path_remains_supported() {
-        temp_env::with_var(ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT, Some("0"), || {
-            let layout = DisksLayout::from_volumes(&["/data"]).expect("standalone single-drive deployment is valid");
-
-            assert!(layout.is_single_drive_layout());
-            assert_eq!(layout.get_single_drive_layout(), "/data");
-        });
-    }
-
-    #[test]
-    fn pool_expansion_rejects_plain_single_drive_pool_with_notice() {
-        temp_env::with_var(ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT, Some("0"), || {
-            for volumes in [
-                ["http://node{1...2}:9000/data", "http://node3:9000/data"],
-                ["http://node3:9000/data", "http://node{1...2}:9000/data"],
-            ] {
-                let err = DisksLayout::from_volumes(&volumes).expect_err("a plain endpoint cannot be an expansion pool");
-                let message = err.to_string();
-
-                assert!(message.contains("all args must have ellipses for pool expansion"), "{message}");
-                assert!(message.contains("at least 2 drive endpoints"), "{message}");
-            }
-        });
-    }
-
-    #[test]
-    fn pool_expansion_rejects_singleton_ellipsis_pool_with_notice() {
-        temp_env::with_var(ENV_RUSTFS_ERASURE_SET_DRIVE_COUNT, Some("0"), || {
-            for singleton in ["http://node{3...3}:9000/data", "http://node3:9000/data{1...1}"] {
-                for volumes in [
-                    vec!["http://node{1...2}:9000/data", singleton],
-                    vec![singleton, "http://node{1...2}:9000/data"],
-                    vec![singleton],
-                ] {
-                    let err = DisksLayout::from_volumes(&volumes).expect_err("a singleton range still contains one drive");
-                    let message = err.to_string();
-
-                    assert_eq!(err.kind(), std::io::ErrorKind::Other);
-                    assert!(matches!(
-                        err.get_ref().and_then(|source| source.downcast_ref::<PoolDriveCountError>()),
-                        Some(PoolDriveCountError::BelowMinimum { size: 1 })
-                    ));
-                    assert!(message.contains("at least 2 drive endpoints"), "{message}");
-                    assert!(message.contains("single local path without ellipses"), "{message}");
-                }
-            }
-        });
-    }
-
-    #[test]
-    fn explicit_set_size_counts_drives_not_nodes() {
-        for volume in ["http://node1:9000/data{1...4}", "http://node{1...4}:9000/data"] {
-            let sets = get_all_sets(2, true, &[volume]).expect("four endpoints can form two two-drive sets");
-            assert_eq!(sets.iter().map(Vec::len).collect::<Vec<_>>(), vec![2, 2]);
-        }
-    }
-
-    #[test]
-    fn undersized_pool_error_identifies_requested_set_size() {
-        let err =
-            get_all_sets(4, true, &["http://node{1...2}:9000/data"]).expect_err("two endpoints cannot fill a four-drive set");
-        let message = err.to_string();
-
-        assert_eq!(err.kind(), std::io::ErrorKind::Other);
-        assert!(matches!(
-            err.get_ref().and_then(|source| source.downcast_ref::<PoolDriveCountError>()),
-            Some(PoolDriveCountError::BelowSetWidth {
-                size: 2,
-                set_drive_count: 4
-            })
-        ));
-        assert!(message.contains("size 2"), "{message}");
-        assert!(message.contains("RUSTFS_ERASURE_SET_DRIVE_COUNT=4"), "{message}");
-    }
-
     #[test]
     fn layout_errors_do_not_echo_url_credentials() {
         for volumes in [
             vec!["http://:duplicate-secret@server/path", "http://:duplicate-secret@server/path"],
             vec!["http://:ellipsis...secret@server/path"],
-            vec!["http://server{1...2}/data", "http://:plain-secret@server3/data"],
-            vec!["http://server{1...2}/data", "http://:singleton-secret@server{3...3}/data"],
         ] {
             let err = DisksLayout::from_volumes(&volumes).unwrap_err();
             assert!(!err.to_string().contains("secret"), "layout error leaked endpoint credentials: {err}");

crates/ecstore/src/layout/endpoints.rs

@@ -2432,41 +2432,6 @@ mod test {
         assert_eq!(local_endpoints[0].pool_idx, 1);
     }
 
-    #[tokio::test]
-    async fn pool_expansion_resolves_single_node_multi_drive_and_multi_node_single_drive_pools() {
-        for (additional_pool, expected_nodes) in [
-            ("http://rustfs-5.example.invalid:9000/data{1...4}", 5),
-            ("http://rustfs-{5...8}.example.invalid:9000/data", 8),
-        ] {
-            let layout = temp_env::with_var("RUSTFS_ERASURE_SET_DRIVE_COUNT", Some("0"), || {
-                DisksLayout::from_volumes(&["http://rustfs-{1...4}.example.invalid:9000/data", additional_pool])
-            })
-            .expect("both single-node multi-drive and multi-node single-drive pools should parse");
-
-            let (pools, setup_type) = EndpointServerPools::create_server_endpoints_with(
-                "0.0.0.0:9000",
-                &layout,
-                Some(orchestrated_test_policy()),
-                Some("rustfs-1.example.invalid"),
-            )
-            .await
-            .expect("pool admission must not impose a minimum node count or drives per node");
-
-            assert_eq!(setup_type, SetupType::DistErasure);
-            assert_eq!(pools.0.len(), 2);
-            assert_eq!(pools.get_nodes().len(), expected_nodes);
-            for (pool_index, pool) in (0_i32..).zip(&pools.0) {
-                assert_eq!((pool.set_count, pool.drives_per_set), (1, 4));
-                assert_eq!(pool.endpoints.as_ref().len(), 4);
-                for (disk_index, endpoint) in (0_i32..).zip(pool.endpoints.as_ref()) {
-                    assert_eq!(endpoint.pool_idx, pool_index);
-                    assert_eq!(endpoint.set_idx, 0);
-                    assert_eq!(endpoint.disk_idx, disk_index);
-                }
-            }
-        }
-    }
-
     #[tokio::test]
     async fn explicit_local_endpoint_host_fails_closed_for_invalid_context_or_zero_match() {
         let args = vec![

crates/ecstore/src/lib.rs

@@ -55,8 +55,6 @@ mod set_disk;
 mod storage_api_contracts;
 mod store;
 
-pub use store::PoolMetaWriteGateStatus;
-
 // pub mod checksum;
 mod event;
 

crates/ecstore/src/runtime/instance.rs

@@ -75,7 +75,6 @@ pub(crate) const SCANNER_PUBLICATION_LEASE_TTL: std::time::Duration = std::time:
 pub(crate) struct ScannerPublicationLeaseEntry {
     pub(crate) expires_at: Instant,
     pub(crate) movement_generation: u64,
-    pub(crate) namespace_generation: u64,
     pub(crate) _operation_guard: OwnedRwLockReadGuard<()>,
 }
 
@@ -306,7 +305,6 @@ impl InstanceContext {
         token: Uuid,
         expires_at: Instant,
         movement_generation: u64,
-        namespace_generation: u64,
         operation_guard: OwnedRwLockReadGuard<()>,
     ) -> bool {
         let mut leases = self.scanner_publication_leases.lock().await;
@@ -318,7 +316,6 @@ impl InstanceContext {
             ScannerPublicationLeaseEntry {
                 expires_at,
                 movement_generation,
-                namespace_generation,
                 _operation_guard: operation_guard,
             },
         );
@@ -329,21 +326,39 @@ impl InstanceContext {
         self.scanner_publication_leases.lock().await.remove(&token).is_some()
     }
 
-    /// Return both generations from the same live lease while the caller holds
-    /// the movement read guard. Namespace commits do not take that guard, so
-    /// the caller must compare the saved namespace generation after this await.
-    /// The process-owned table rejects tokens from a prior instance or expiry.
-    pub(crate) async fn scanner_publication_lease_generations(&self, token: Uuid) -> Option<(u64, u64)> {
+    /// Check a lease token while the caller holds the movement read guard.
+    ///
+    /// The token table is deliberately process-owned and non-persistent: a
+    /// restarted instance has no entries from the previous process, so an old
+    /// coordinator proof cannot become valid again merely because the
+    /// movement generation counter restarted at zero.
+    pub(crate) async fn scanner_publication_lease_is_active(&self, token: Uuid) -> bool {
         let mut leases = self.scanner_publication_leases.lock().await;
         let now = Instant::now();
-        let (expires_at, movement_generation, namespace_generation) = leases
+        let Some(expires_at) = leases.get(&token).map(|entry| entry.expires_at) else {
+            return false;
+        };
+        if expires_at <= now {
+            leases.remove(&token);
+            return false;
+        }
+        true
+    }
+
+    /// Return the generation bound to a live lease.  The lease entry owns the
+    /// movement read guard, so a successful lookup remains valid for the
+    /// caller's guard-protected operation; expiry is still fail-closed.
+    pub(crate) async fn scanner_publication_lease_generation(&self, token: Uuid) -> Option<u64> {
+        let mut leases = self.scanner_publication_leases.lock().await;
+        let now = Instant::now();
+        let (expires_at, movement_generation) = leases
             .get(&token)
-            .map(|entry| (entry.expires_at, entry.movement_generation, entry.namespace_generation))?;
+            .map(|entry| (entry.expires_at, entry.movement_generation))?;
         if expires_at <= now {
             leases.remove(&token);
             return None;
         }
-        Some((movement_generation, namespace_generation))
+        Some(movement_generation)
     }
 
     pub(crate) async fn expire_scanner_publication_lease(&self, token: Uuid, expires_at: Instant) {
@@ -501,11 +516,6 @@ impl InstanceContext {
             .store(SCANNER_PUBLICATION_STATE_UNKNOWN, Ordering::Release);
     }
 
-    #[cfg(test)]
-    pub(crate) fn set_namespace_commit_generation_for_test(&self, generation: u64) {
-        self.namespace_commit_generation.store(generation, Ordering::Release);
-    }
-
     #[cfg(test)]
     pub(crate) fn set_data_movement_generation_for_test(&self, generation: u64) {
         self.data_movement_generation.store(generation, Ordering::Release);
@@ -852,26 +862,6 @@ mod tests {
         }
     }
 
-    #[tokio::test(start_paused = true)]
-    async fn scanner_lease_generations_remain_bound_until_expiry() {
-        let ctx = Arc::new(InstanceContext::new());
-        let token = Uuid::new_v4();
-        let gate = ctx.data_movement_operation_gate();
-        let permit = gate.clone().read_owned().await;
-        assert!(
-            ctx.install_scanner_publication_lease(token, Instant::now() + SCANNER_PUBLICATION_LEASE_TTL, 7, 11, permit)
-                .await
-        );
-        drop(ctx.begin_namespace_commit());
-        assert_eq!(ctx.namespace_commit_generation(), 2);
-        assert_eq!(ctx.scanner_publication_lease_generations(token).await, Some((7, 11)));
-        assert!(gate.clone().try_write_owned().is_err(), "lookup must retain the stored permit");
-        tokio::time::advance(SCANNER_PUBLICATION_LEASE_TTL).await;
-        assert_eq!(ctx.scanner_publication_lease_generations(token).await, None);
-        assert!(!ctx.remove_scanner_publication_lease(token).await);
-        assert!(gate.try_write_owned().is_ok(), "expiry releases the stored permit");
-    }
-
     // The SetupType inputs must derive the exact (is_erasure,
     // is_dist_erasure, is_erasure_sd) triples that the original three
     // process-global erasure bools produced via update_erasure_type().

crates/ecstore/src/services/metrics_realtime.rs

@@ -20,10 +20,9 @@ use chrono::Utc;
 use jiff::Timestamp;
 use rustfs_heal_contracts::heal_channel::DriveState;
 use rustfs_io_metrics::internode_metrics::global_internode_metrics;
-use rustfs_io_metrics::s3_http_metrics::s3_http_metrics_snapshot;
 use rustfs_madmin::metrics::{
-    DiskIOStats, DiskMetric, HttpMetrics, HttpRequestMetric, LastMinute as MadminLastMinute, NetDevLine, NetMetrics, RPCMetrics,
-    RealtimeMetrics, ScannerCheckpointReport as MadminScannerCheckpointReport,
+    DiskIOStats, DiskMetric, LastMinute as MadminLastMinute, NetDevLine, NetMetrics, RPCMetrics, RealtimeMetrics,
+    ScannerCheckpointReport as MadminScannerCheckpointReport,
     ScannerLifecycleExpirySnapshot as MadminScannerLifecycleExpirySnapshot,
     ScannerLifecycleTransitionSnapshot as MadminScannerLifecycleTransitionSnapshot,
     ScannerMaintenanceControlSnapshot as MadminScannerMaintenanceControlSnapshot,
@@ -62,10 +61,9 @@ impl MetricType {
     pub const MEM: MetricType = MetricType(1 << 6);
     pub const CPU: MetricType = MetricType(1 << 7);
     pub const RPC: MetricType = MetricType(1 << 8);
-    pub const HTTP: MetricType = MetricType(1 << 9);
 
     // MetricsAll must be last.
-    pub const ALL: MetricType = MetricType((1 << 10) - 1);
+    pub const ALL: MetricType = MetricType((1 << 9) - 1);
 
     pub fn new(t: u32) -> Self {
         Self(t)
@@ -412,21 +410,6 @@ pub async fn collect_local_metrics(types: MetricType, opts: &CollectMetricsOpts)
         by_host_name = local_node_name;
     }
 
-    if types.contains(&MetricType::HTTP) {
-        real_time_metrics.aggregated.http = Some(HttpMetrics {
-            collected_at: Timestamp::now(),
-            requests: s3_http_metrics_snapshot()
-                .into_iter()
-                .map(|series| HttpRequestMetric {
-                    method: series.method.to_string(),
-                    operation: series.operation.to_string(),
-                    outcome: series.outcome.to_string(),
-                    total: series.total,
-                })
-                .collect(),
-        });
-    }
-
     if types.contains(&MetricType::DISK) {
         debug!("start get disk metrics");
         let mut aggr = DiskMetric {
@@ -602,47 +585,11 @@ mod test {
         assert!(t.contains(&MetricType::MEM));
         assert!(t.contains(&MetricType::CPU));
         assert!(t.contains(&MetricType::RPC));
-        assert!(t.contains(&MetricType::HTTP));
 
         let disk = MetricType::new(1 << 1);
         assert!(disk.contains(&MetricType::DISK));
     }
 
-    #[tokio::test]
-    async fn collect_local_metrics_reports_the_same_http_outcome_counters() {
-        let mut request = rustfs_io_metrics::s3_http_metrics::S3HttpRequestGuard::new("PUT");
-        request.response(503);
-        drop(request);
-        let snapshot = s3_http_metrics_snapshot();
-        let realtime = collect_local_metrics(MetricType::HTTP, &CollectMetricsOpts::default()).await;
-        let http = realtime.aggregated.http.as_ref().expect("HTTP selection must report support");
-        assert_eq!(http.requests.len(), snapshot.len());
-        for (actual, expected) in http.requests.iter().zip(&snapshot) {
-            assert_eq!(actual.method, expected.method);
-            assert_eq!(actual.operation, expected.operation);
-            assert_eq!(actual.outcome, expected.outcome);
-            assert_eq!(actual.total, expected.total);
-        }
-        assert_eq!(realtime.by_host.len(), 1);
-        assert_eq!(
-            realtime
-                .by_host
-                .values()
-                .next()
-                .expect("local host")
-                .http
-                .as_ref()
-                .expect("host HTTP")
-                .requests,
-            http.requests
-        );
-        let encoded = rmp_serde::to_vec_named(&realtime).expect("RPC metric map");
-        let decoded: RealtimeMetrics = rmp_serde::from_slice(&encoded).expect("RPC metric roundtrip");
-        assert_eq!(decoded.aggregated.http.expect("HTTP field survives RPC").requests, http.requests);
-        let excluded = collect_local_metrics(MetricType::NET, &CollectMetricsOpts::default()).await;
-        assert!(excluded.aggregated.http.is_none());
-    }
-
     #[tokio::test]
     async fn collect_local_metrics_reports_internode_net_and_rpc() {
         let metrics = global_internode_metrics();

crates/ecstore/src/services/notification_sys.rs

@@ -31,7 +31,7 @@ use lazy_static::lazy_static;
 use rustfs_madmin::health::{Cpus, MemInfo, OsInfo, Partitions, ProcInfo, SysConfig, SysErrors, SysServices};
 use rustfs_madmin::metrics::RealtimeMetrics;
 use rustfs_madmin::net::NetInfo;
-use rustfs_madmin::{ItemState, ServerProperties, StorageInfo, StorageInfoObservation, StorageInfoProbeStatus};
+use rustfs_madmin::{ItemState, ServerProperties, StorageInfo};
 use rustfs_utils::XHost;
 use sha2::{Digest, Sha256};
 use std::collections::{BTreeMap, BTreeSet, HashMap, hash_map::DefaultHasher};
@@ -53,7 +53,6 @@ const LOG_COMPONENT_ECSTORE: &str = "ecstore";
 const LOG_SUBSYSTEM_NOTIFICATION: &str = "notification";
 const EVENT_NOTIFICATION_PEER_PROPAGATION: &str = "notification_peer_propagation";
 const EVENT_NOTIFICATION_CAPABILITY_PROBE: &str = "notification_capability_probe";
-const EVENT_STORAGE_INFO_PROBE: &str = "storage_info_probe";
 const SCANNER_ACTIVITY_PROBE_TIMEOUT: Duration = Duration::from_secs(5);
 const TIER_DAILY_STATS_PROBE_TIMEOUT: Duration = Duration::from_secs(5);
 const TIER_CONFIG_RELOAD_RETRY_BASE: Duration = Duration::from_millis(100);
@@ -141,8 +140,6 @@ pub struct ScannerPublicationLeaseGrant {
 /// Cached result from the last successful admin call to a peer.
 struct PeerAdminCache {
     last_storage_info: Option<StorageInfo>,
-    /// Wall time is for operators; the monotonic clock bounds cache reuse.
-    last_storage_success: Option<(SystemTime, Instant)>,
     last_server_info: Option<ServerProperties>,
     storage_failures: u32,
     server_failures: u32,
@@ -166,7 +163,6 @@ impl PeerAdminCache {
     fn new() -> Self {
         Self {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: None,
             storage_failures: 0,
             server_failures: 0,
@@ -179,9 +175,6 @@ impl PeerAdminCache {
 /// failure: rather than reporting a stale `online`, the member falls through to
 /// the live unknown/degraded/offline classification (rustfs/backlog#1049 P2).
 const SERVER_INFO_CACHE_MAX_AGE: Duration = Duration::from_secs(60);
-// Diagnostic inventory may bridge a short probe interruption, but never more
-// than one minute. Failed probes are marked unknown even within this budget.
-const STORAGE_INFO_CACHE_MAX_AGE: Duration = Duration::from_secs(60);
 
 lazy_static! {
     pub static ref GLOBAL_NOTIFICATION_SYS: OnceLock<Arc<NotificationSys>> = OnceLock::new();
@@ -1913,7 +1906,6 @@ impl NotificationSys {
         for (idx, client) in self.peer_clients.iter().enumerate() {
             let endpoints = endpoints.clone();
             let cache = self.peer_admin_caches.get(idx);
-            let topology_host = self.peer_topology_hosts.get(idx);
             futures.push(async move {
                 if let Some(client) = client {
                     let host = client.host.to_string();
@@ -1924,46 +1916,32 @@ impl NotificationSys {
                             normalize_and_cache_peer_storage_info(cache, &host, &mut info);
                             Some(info)
                         }
-                        Ok(Err(err)) => handle_peer_failure(cache, &host, &endpoints, &err),
-                        Err(_) => handle_peer_failure(cache, &host, &endpoints, &Error::Timeout),
+                        Ok(Err(err)) => {
+                            warn!("peer {} storage_info failed: {}", host, err);
+                            handle_peer_failure(cache, &host, &endpoints)
+                        }
+                        Err(_) => {
+                            warn!("peer {} storage_info timed out after {:?}", host, peer_timeout);
+                            handle_peer_failure(cache, &host, &endpoints)
+                        }
                     }
                 } else {
-                    topology_host.and_then(|host| {
-                        handle_peer_failure(
-                            cache,
-                            host,
-                            &endpoints,
-                            &Error::RemoteClientUnavailable("storage inventory client is unavailable".to_string()),
-                        )
-                    })
+                    None
                 }
             });
         }
 
         let mut replies = join_all(futures).await;
 
-        let mut local = StorageAdminApi::local_storage_info(api).await;
-        local.observations = vec![storage_info_observation(
-            &runtime_sources::local_node_name().await,
-            StorageInfoProbeStatus::Succeeded,
-            false,
-            Some((SystemTime::now(), Instant::now())),
-        )];
-        replies.push(Some(local));
+        replies.push(Some(StorageAdminApi::local_storage_info(api).await));
 
         let mut disks = Vec::new();
-        let mut observations = Vec::new();
         for info in replies.into_iter().flatten() {
             disks.extend(info.disks);
-            observations.extend(info.observations);
         }
 
         let backend = StorageAdminApi::backend_info(api).await;
-        rustfs_madmin::StorageInfo {
-            disks,
-            backend,
-            observations,
-        }
+        rustfs_madmin::StorageInfo { disks, backend }
     }
 
     pub async fn server_info(&self) -> Vec<ServerProperties> {
@@ -3361,80 +3339,56 @@ where
     }
 }
 
-fn storage_info_observation(
-    host: &str,
-    status: StorageInfoProbeStatus,
-    cached: bool,
-    last_success: Option<(SystemTime, Instant)>,
-) -> StorageInfoObservation {
-    StorageInfoObservation {
-        endpoint: host.to_string(),
-        status,
-        cached,
-        last_success_unix_millis: last_success
-            .and_then(|(wall, _)| wall.duration_since(SystemTime::UNIX_EPOCH).ok())
-            .and_then(|age| u64::try_from(age.as_millis()).ok()),
-        snapshot_age_seconds: last_success.map(|(_, monotonic)| monotonic.elapsed().as_secs()),
-        error_code: None,
-    }
-}
-
-/// An admin RPC failure is missing evidence, not evidence of failed drives.
-/// Preserve bounded historical inventory without presenting its states as live.
+/// Handle a peer failure for storage_info: return cached data if available,
+/// or mark offline only after consecutive failures exceed the threshold.
 fn handle_peer_failure(
     cache: Option<&Mutex<PeerAdminCache>>,
     host: &str,
     endpoints: &EndpointServerPools,
-    error: &Error,
 ) -> Option<StorageInfo> {
-    let mut cache = cache.map(|cache| cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()));
-    let last_success = cache.as_ref().and_then(|cache| cache.last_storage_success);
-    let historical = cache
-        .as_ref()
-        .filter(|_| last_success.is_some_and(|(_, when)| when.elapsed() < STORAGE_INFO_CACHE_MAX_AGE))
-        .and_then(|cache| cache.last_storage_info.clone());
-    let cached = historical.is_some();
-    let mut info = historical.unwrap_or_else(|| StorageInfo {
-        disks: synthesized_disks(host, endpoints, ItemState::Unknown),
-        ..Default::default()
-    });
-    if let Some(cache) = &mut cache {
-        cache.storage_failures = cache.storage_failures.saturating_add(1);
-        if cache.storage_failures == 1 {
+    let cache = cache?;
+
+    let mut c = match cache.lock() {
+        Ok(cache) => cache,
+        Err(poisoned) => {
+            warn!("peer {host} storage_info cache mutex poisoned");
+            poisoned.into_inner()
+        }
+    };
+    c.storage_failures += 1;
+
+    if let Some(ref cached) = c.last_storage_info
+        && c.storage_failures < CONSECUTIVE_FAILURE_THRESHOLD
+    {
+        debug!(
+            event = "peer_probe_failure",
+            peer = host,
+            probe = "storage_info",
+            consecutive_failures = c.storage_failures,
+            threshold = CONSECUTIVE_FAILURE_THRESHOLD,
+            "peer storage_info probe failed; returning cached state until the offline threshold is reached"
+        );
+        return Some(cached.clone());
+    }
+
+    if c.storage_failures >= CONSECUTIVE_FAILURE_THRESHOLD {
+        if c.storage_failures == CONSECUTIVE_FAILURE_THRESHOLD {
             warn!(
-                event = EVENT_STORAGE_INFO_PROBE,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_NOTIFICATION,
-                state = "failed",
+                event = "peer_marked_offline",
                 peer = host,
-                error_code = ?error.code(),
-                cached,
-                "Storage inventory probe failed; current drive health is unknown"
+                probe = "storage_info",
+                consecutive_failures = c.storage_failures,
+                threshold = CONSECUTIVE_FAILURE_THRESHOLD,
+                "reporting peer disks offline after consecutive storage_info failures"
             );
         }
+        return Some(StorageInfo {
+            disks: synthesized_disks(host, endpoints, ItemState::Offline),
+            ..Default::default()
+        });
     }
-    for disk in &mut info.disks {
-        disk.state = rustfs_madmin::ITEM_UNKNOWN.to_string();
-        disk.runtime_state = Some(rustfs_madmin::ITEM_UNKNOWN.to_string());
-        disk.offline_duration_seconds = None;
-        disk.capacity_observation_source = Some(if cached { "snapshot" } else { "missing" }.to_string());
-        disk.capacity_observation_age_seconds = if cached {
-            disk.capacity_observation_age_seconds
-                .zip(last_success)
-                .map(|(age, (_, when))| age.saturating_add(when.elapsed().as_secs()))
-        } else {
-            None
-        };
-        disk.local = false;
-    }
-    info.observations = vec![storage_info_observation(
-        host,
-        StorageInfoProbeStatus::Failed,
-        cached,
-        last_success,
-    )];
-    info.observations[0].error_code = Some(format!("{:?}", error.code()));
-    Some(info)
+
+    None
 }
 
 fn normalize_and_cache_peer_storage_info(cache: Option<&Mutex<PeerAdminCache>>, host: &str, info: &mut StorageInfo) {
@@ -3443,15 +3397,6 @@ fn normalize_and_cache_peer_storage_info(cache: Option<&Mutex<PeerAdminCache>>,
     for disk in &mut info.disks {
         disk.local = false;
     }
-    let last_success = (SystemTime::now(), Instant::now());
-    // The aggregator owns probe provenance, including when an older peer
-    // returns no observation or a peer sends its own observation fields.
-    info.observations = vec![storage_info_observation(
-        host,
-        StorageInfoProbeStatus::Succeeded,
-        false,
-        Some(last_success),
-    )];
 
     let Some(cache) = cache else {
         return;
@@ -3464,20 +3409,16 @@ fn normalize_and_cache_peer_storage_info(cache: Option<&Mutex<PeerAdminCache>>,
             poisoned.into_inner()
         }
     };
-    if c.storage_failures > 0 {
+    if c.storage_failures >= CONSECUTIVE_FAILURE_THRESHOLD {
         info!(
-            event = EVENT_STORAGE_INFO_PROBE,
-            component = LOG_COMPONENT_ECSTORE,
-            subsystem = LOG_SUBSYSTEM_NOTIFICATION,
-            state = "succeeded",
+            event = "peer_recovered_online",
             peer = host,
             probe = "storage_info",
             consecutive_failures = c.storage_failures,
-            "Storage inventory probe recovered"
+            "peer storage_info probe succeeded again; peer disks reported online"
         );
     }
     c.last_storage_info = Some(info.clone());
-    c.last_storage_success = Some(last_success);
     c.storage_failures = 0;
 }
 
@@ -4951,7 +4892,6 @@ mod tests {
             server_failures: 1,
             storage_failures: 0,
             last_storage_info: None,
-            last_storage_success: None,
         });
         let cache_b = Mutex::new(PeerAdminCache {
             last_server_info: Some(build_props("cached-b")),
@@ -4959,7 +4899,6 @@ mod tests {
             server_failures: 1,
             storage_failures: 0,
             last_storage_info: None,
-            last_storage_success: None,
         });
         let caches = [cache_a, cache_b];
         let endpoints = EndpointServerPools::from(Vec::new());
@@ -5358,78 +5297,13 @@ mod tests {
 
     // --- Tests for handle_peer_failure / handle_server_info_failure caching ---
 
-    #[tokio::test]
-    async fn storage_info_preserves_failed_members_when_no_rpc_client_exists() {
-        #[derive(Debug)]
-        struct LocalInventory;
-
-        #[async_trait::async_trait]
-        impl StorageAdminApi for LocalInventory {
-            type BackendInfo = rustfs_madmin::BackendInfo;
-            type StorageInfo = StorageInfo;
-            type Disk = ();
-            type Error = Error;
-
-            async fn backend_info(&self) -> Self::BackendInfo {
-                Self::BackendInfo::default()
-            }
-
-            async fn storage_info(&self) -> StorageInfo {
-                panic!("aggregation must query local inventory only")
-            }
-
-            async fn local_storage_info(&self) -> StorageInfo {
-                StorageInfo::default()
-            }
-
-            async fn disk_set_inventory(
-                &self,
-                _: crate::storage_api_contracts::admin::DiskSetSelector,
-            ) -> Result<Vec<Option<Self::Disk>>> {
-                panic!("admin probe must not access the data plane")
-            }
-
-            fn set_drive_counts(&self) -> Vec<usize> {
-                Vec::new()
-            }
-        }
-
-        let sys = NotificationSys {
-            peer_clients: vec![None],
-            all_peer_clients: vec![None, None],
-            peer_topology_hosts: vec!["peer-unavailable".to_string()],
-            peer_admin_caches: vec![Mutex::new(PeerAdminCache::new())],
-            tier_config_reload_workers: Default::default(),
-        };
-        let info = sys.storage_info(&LocalInventory).await;
-        let peer = info
-            .observations
-            .iter()
-            .find(|observation| observation.endpoint == "peer-unavailable")
-            .expect("failed topology member remains visible");
-        assert_eq!(peer.status, StorageInfoProbeStatus::Failed);
-        assert!(!peer.cached);
-        assert_eq!(peer.error_code.as_deref(), Some("RemoteClientUnavailable"));
-        assert!(
-            info.observations
-                .iter()
-                .any(|observation| observation.status == StorageInfoProbeStatus::Succeeded)
-        );
-    }
-
     #[test]
-    fn handle_peer_failure_first_failure_reports_unknown_inventory_without_cache() {
+    fn handle_peer_failure_first_failure_returns_none_when_no_cache() {
         let cache = Mutex::new(PeerAdminCache::new());
         let endpoints = EndpointServerPools::default();
 
-        let result = handle_peer_failure(Some(&cache), "peer-1", &endpoints, &Error::Timeout);
-        let info = result.expect("failed peer must remain visible without cached disks");
-        assert!(info.disks.is_empty());
-        assert_eq!(info.observations[0].status, StorageInfoProbeStatus::Failed);
-        assert!(!info.observations[0].cached);
-        assert_eq!(info.observations[0].last_success_unix_millis, None);
-        assert_eq!(info.observations[0].snapshot_age_seconds, None);
-        assert_eq!(info.observations[0].error_code.as_deref(), Some("Timeout"));
+        let result = handle_peer_failure(Some(&cache), "peer-1", &endpoints);
+        assert!(result.is_none());
         assert_eq!(cache.lock().unwrap().storage_failures, 1);
     }
 
@@ -5446,7 +5320,6 @@ mod tests {
 
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: Some(cached_info),
-            last_storage_success: Some((SystemTime::now(), Instant::now())),
             last_server_info: None,
             storage_failures: 0,
             server_failures: 0,
@@ -5454,17 +5327,11 @@ mod tests {
         });
         let endpoints = EndpointServerPools::default();
 
-        // Historical inventory is available, but its health is not live.
-        let result = handle_peer_failure(Some(&cache), "peer-1", &endpoints, &Error::Timeout);
+        // First failure: should return cached data
+        let result = handle_peer_failure(Some(&cache), "peer-1", &endpoints);
         let info = result.unwrap();
         assert_eq!(info.disks.len(), 1);
-        assert_eq!(info.disks[0].state, "unknown");
-        assert_eq!(info.disks[0].runtime_state.as_deref(), Some("unknown"));
-        assert_eq!(info.disks[0].capacity_observation_source.as_deref(), Some("snapshot"));
-        assert_eq!(info.disks[0].capacity_observation_age_seconds, None);
-        assert!(info.observations[0].cached);
-        assert_eq!(info.observations[0].status, StorageInfoProbeStatus::Failed);
-        assert!(info.observations[0].last_success_unix_millis.is_some());
+        assert_eq!(info.disks[0].state, "ok");
         assert_eq!(cache.lock().unwrap().storage_failures, 1);
     }
 
@@ -5510,13 +5377,13 @@ mod tests {
         );
         drop(cached);
 
-        let degraded = handle_peer_failure(Some(&cache), "peer-1", &EndpointServerPools::default(), &Error::Timeout)
+        let degraded = handle_peer_failure(Some(&cache), "peer-1", &EndpointServerPools::default())
             .expect("first peer failure must return the cached snapshot");
         assert!(degraded.disks.iter().all(|disk| !disk.local));
     }
 
     #[test]
-    fn handle_peer_failure_cache_age_does_not_depend_on_poll_count() {
+    fn handle_peer_failure_returns_offline_after_threshold_exceeded() {
         let cached_info = StorageInfo {
             disks: vec![rustfs_madmin::Disk {
                 endpoint: "disk-0".to_string(),
@@ -5528,7 +5395,6 @@ mod tests {
 
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: Some(cached_info),
-            last_storage_success: Some((SystemTime::now(), Instant::now())),
             last_server_info: None,
             storage_failures: CONSECUTIVE_FAILURE_THRESHOLD - 1,
             server_failures: 0,
@@ -5536,31 +5402,10 @@ mod tests {
         });
         let endpoints = EndpointServerPools::default();
 
-        for _ in 0..10 {
-            let info = handle_peer_failure(Some(&cache), "peer-1", &endpoints, &Error::Timeout).expect("failed probe");
-            assert_eq!(info.disks.len(), 1);
-            assert_eq!(info.disks[0].state, "unknown");
-            assert!(info.observations[0].cached);
-        }
-        cache.lock().expect("age cache").last_storage_success =
-            Some((SystemTime::now() - Duration::from_secs(61), Instant::now() - Duration::from_secs(61)));
-        let info = handle_peer_failure(Some(&cache), "peer-1", &endpoints, &Error::Timeout).expect("expired probe");
-        assert!(!info.observations[0].cached);
-        assert!(info.observations[0].snapshot_age_seconds.expect("known last success") >= 61);
-        assert!(info.disks.is_empty(), "expired inventory must not be reused");
-
-        let mut recovered = StorageInfo {
-            disks: vec![rustfs_madmin::Disk {
-                state: "ok".into(),
-                ..Default::default()
-            }],
-            ..Default::default()
-        };
-        normalize_and_cache_peer_storage_info(Some(&cache), "peer-1", &mut recovered);
-        assert_eq!(recovered.disks[0].state, "ok");
-        assert_eq!(recovered.observations[0].status, StorageInfoProbeStatus::Succeeded);
-        assert!(!recovered.observations[0].cached);
-        assert_eq!(cache.lock().expect("recovered cache").storage_failures, 0);
+        // This failure pushes us to the threshold => offline
+        let result = handle_peer_failure(Some(&cache), "peer-1", &endpoints);
+        assert!(result.is_some());
+        assert_eq!(cache.lock().unwrap().storage_failures, CONSECUTIVE_FAILURE_THRESHOLD);
     }
 
     #[test]
@@ -5573,7 +5418,6 @@ mod tests {
 
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: Some(cached_props),
             storage_failures: 0,
             server_failures: 0,
@@ -5604,7 +5448,6 @@ mod tests {
 
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: Some(cached_props),
             storage_failures: 0,
             server_failures: 0,
@@ -5732,7 +5575,6 @@ mod tests {
 
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: Some(cached_props),
             storage_failures: 0,
             server_failures: CONSECUTIVE_FAILURE_THRESHOLD - 1,
@@ -5752,7 +5594,6 @@ mod tests {
         // the real per-drive health), not offline (rustfs/backlog#1049 P0-B).
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: None,
             storage_failures: 0,
             server_failures: CONSECUTIVE_FAILURE_THRESHOLD - 1,
@@ -5781,7 +5622,6 @@ mod tests {
         // this is a genuine offline, degraded must not mask it.
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: None,
             storage_failures: 0,
             server_failures: CONSECUTIVE_FAILURE_THRESHOLD - 1,
@@ -5805,7 +5645,6 @@ mod tests {
     fn success_resets_failure_counters_independently() {
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: None,
             storage_failures: 2,
             server_failures: 2,
@@ -5827,7 +5666,6 @@ mod tests {
     fn storage_failures_do_not_affect_server_failures() {
         let cache = Mutex::new(PeerAdminCache {
             last_storage_info: Some(StorageInfo::default()),
-            last_storage_success: None,
             last_server_info: Some(ServerProperties {
                 endpoint: "peer-1".to_string(),
                 state: "online".to_string(),
@@ -5839,7 +5677,7 @@ mod tests {
         });
         let endpoints = EndpointServerPools::default();
 
-        let storage_result = handle_peer_failure(Some(&cache), "peer-1", &endpoints, &Error::Timeout);
+        let storage_result = handle_peer_failure(Some(&cache), "peer-1", &endpoints);
         assert!(storage_result.is_some());
 
         let server_result = handle_server_info_failure(Some(&cache), "peer-1", &endpoints, None);
@@ -5862,10 +5700,8 @@ mod tests {
             panic!("poison server cache mutex");
         });
 
-        let storage_result = handle_peer_failure(Some(&storage_cache), "peer-1", &endpoints, &Error::Timeout);
-        let storage = storage_result.expect("poisoned cache must still report the failed peer");
-        assert_eq!(storage.observations[0].status, StorageInfoProbeStatus::Failed);
-        assert!(!storage.observations[0].cached);
+        let storage_result = handle_peer_failure(Some(&storage_cache), "peer-1", &endpoints);
+        assert!(storage_result.is_none());
 
         let server_result = handle_server_info_failure(Some(&server_cache), "peer-1", &endpoints, None);
         assert_eq!(server_result.endpoint, "peer-1");
@@ -5876,7 +5712,6 @@ mod tests {
     fn poisoned_admin_cache_recovers_on_success_and_resets_failures() {
         let storage_cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: None,
             storage_failures: CONSECUTIVE_FAILURE_THRESHOLD - 1,
             server_failures: 0,
@@ -5884,7 +5719,6 @@ mod tests {
         });
         let server_cache = Mutex::new(PeerAdminCache {
             last_storage_info: None,
-            last_storage_success: None,
             last_server_info: None,
             storage_failures: 0,
             server_failures: CONSECUTIVE_FAILURE_THRESHOLD - 1,
@@ -5923,11 +5757,9 @@ mod tests {
             },
         );
 
-        let storage_result = handle_peer_failure(Some(&storage_cache), "peer-1", &endpoints, &Error::Timeout);
+        let storage_result = handle_peer_failure(Some(&storage_cache), "peer-1", &endpoints);
         assert!(storage_result.is_some());
-        let storage = storage_result.expect("failed probe after recovery");
-        assert_eq!(storage.disks[0].state, "unknown");
-        assert!(storage.observations[0].cached);
+        assert_eq!(storage_result.unwrap().disks[0].state, "ok");
 
         let server_result = handle_server_info_failure(Some(&server_cache), "peer-1", &endpoints, None);
         assert_eq!(server_result.state, "online");

crates/ecstore/src/services/rebalance/control.rs

@@ -300,13 +300,11 @@ pub(super) fn ensure_rebalance_worker_active(meta: Option<&RebalanceMeta>, expec
     let Some(meta) = meta else {
         return Err(rebalance_metadata_not_initialized_error(stage));
     };
-    if meta.stopped_at.is_some() || meta.stop_requested {
-        return Err(Error::OperationCanceled);
-    }
-    if meta
-        .cancel
-        .as_ref()
-        .is_some_and(tokio_util::sync::CancellationToken::is_cancelled)
+    if meta.stopped_at.is_some()
+        || meta
+            .cancel
+            .as_ref()
+            .is_some_and(tokio_util::sync::CancellationToken::is_cancelled)
         || !is_rebalance_conflicting_with_decommission(meta)
     {
         return Err(Error::other(format!("inactive rebalance worker rejected during {stage}: {expected_id}")));
@@ -631,7 +629,6 @@ impl ECStore {
             if let Some(meta) = rebalance_meta.as_mut()
                 && is_rebalance_conflicting_with_decommission(meta)
             {
-                meta.stop_requested = true;
                 meta.cancel
                     .get_or_insert_with(tokio_util::sync::CancellationToken::new)
                     .cancel();
@@ -646,13 +643,12 @@ impl ECStore {
         let Some(meta) = rebalance_meta.as_mut() else {
             return Ok(None);
         };
-        if meta.stopped_at.is_some() || (!is_rebalance_conflicting_with_decommission(meta) && !meta.stop_requested) {
+        if !is_rebalance_conflicting_with_decommission(meta) {
             return Ok(None);
         }
         if meta.id.is_empty() {
             return Err(Error::other("active rebalance metadata has no activation id"));
         }
-        meta.stop_requested = true;
         meta.cancel
             .get_or_insert_with(tokio_util::sync::CancellationToken::new)
             .cancel();
@@ -677,13 +673,7 @@ impl ECStore {
             let movement_changed = rebalance_movement_snapshot_changed(self.rebalance_meta.read().await.as_ref(), &meta);
             {
                 let mut rebalance_meta = self.rebalance_meta.write().await;
-                if let Some(current) = rebalance_meta.as_ref()
-                    && current.id == meta.id
-                {
-                    meta.cancel = current.cancel.clone();
-                    meta.activation_gate = Arc::clone(&current.activation_gate);
-                    meta.stop_requested = current.stop_requested;
-                }
+
                 *rebalance_meta = Some(meta);
 
                 drop(rebalance_meta);
@@ -1198,12 +1188,11 @@ impl ECStore {
         let meta = rebalance_meta
             .as_mut()
             .ok_or_else(|| rebalance_metadata_not_initialized_error("cancel rebalance admission"))?;
-        if meta.stopped_at.is_some() || (!is_rebalance_conflicting_with_decommission(meta) && !meta.stop_requested) {
+        if meta.stopped_at.is_some() || !is_rebalance_conflicting_with_decommission(meta) {
             return Err(Error::other(format!(
                 "inactive rebalance rejected while cancelling admission: {expected_id}"
             )));
         }
-        meta.stop_requested = true;
         meta.cancel
             .get_or_insert_with(tokio_util::sync::CancellationToken::new)
             .cancel();
@@ -1224,7 +1213,6 @@ impl ECStore {
                 ensure_rebalance_run_id(rebalance_meta.as_ref(), expected_id, "stop rebalance")?;
             }
             rebalance_meta.as_mut().map(|meta| {
-                meta.stop_requested |= is_rebalance_conflicting_with_decommission(meta);
                 let cancel = meta.cancel.get_or_insert_with(tokio_util::sync::CancellationToken::new);
                 cancel.cancel();
                 Arc::clone(&meta.activation_gate)
@@ -1389,79 +1377,6 @@ mod tests {
         probe.wait_until_attempted().await;
     }
 
-    #[test]
-    fn rebalance_stop_classification_checks_identity_and_explicit_intent() {
-        let mut meta = RebalanceMeta {
-            id: "current".to_string(),
-            cancel: Some(tokio_util::sync::CancellationToken::new()),
-            pool_stats: vec![RebalanceStats {
-                participating: true,
-                info: RebalanceInfo {
-                    status: RebalStatus::Started,
-                    ..Default::default()
-                },
-                ..Default::default()
-            }],
-            ..Default::default()
-        };
-        ensure_rebalance_worker_active(Some(&meta), "current", "test").expect("active worker");
-        meta.cancel.as_ref().unwrap().cancel();
-        assert!(
-            !matches!(
-                ensure_rebalance_worker_active(Some(&meta), "current", "test"),
-                Err(Error::OperationCanceled)
-            ),
-            "a sibling failure is not an operator stop"
-        );
-        meta.stop_requested = true;
-        assert!(matches!(
-            ensure_rebalance_worker_active(Some(&meta), "current", "test"),
-            Err(Error::OperationCanceled)
-        ));
-        assert!(
-            !matches!(ensure_rebalance_worker_active(Some(&meta), "old", "test"), Err(Error::OperationCanceled)),
-            "stale identity remains a failure even during stop"
-        );
-        assert!(!matches!(
-            ensure_rebalance_worker_active(None, "current", "test"),
-            Err(Error::OperationCanceled)
-        ));
-    }
-
-    #[tokio::test]
-    async fn rebalance_stop_intent_does_not_survive_replacement_run_reload() {
-        let (_temp_dirs, store) = crate::services::rebalance::test_store_with_persisted_rebalance_meta(RebalanceMeta {
-            id: "replacement".to_string(),
-            pool_stats: vec![RebalanceStats {
-                participating: true,
-                info: RebalanceInfo {
-                    status: RebalStatus::Completed,
-                    ..Default::default()
-                },
-                ..Default::default()
-            }],
-            ..Default::default()
-        })
-        .await;
-        let previous_gate = {
-            let mut meta = store.rebalance_meta.write().await;
-            let meta = meta.as_mut().unwrap();
-            meta.id = "previous".to_string();
-            meta.stop_requested = true;
-            let cancel = tokio_util::sync::CancellationToken::new();
-            cancel.cancel();
-            meta.cancel = Some(cancel);
-            Arc::clone(&meta.activation_gate)
-        };
-        store.load_rebalance_meta().await.expect("reload replacement run");
-        let meta = store.rebalance_meta.read().await;
-        let meta = meta.as_ref().unwrap();
-        assert_eq!(meta.id, "replacement");
-        assert!(!meta.stop_requested);
-        assert!(meta.cancel.is_none());
-        assert!(!Arc::ptr_eq(&previous_gate, &meta.activation_gate));
-    }
-
     #[tokio::test]
     async fn cancel_rebalance_admission_is_id_checked_and_idempotent() {
         let rebalance_id = "rebalance-admission-current";
@@ -1500,59 +1415,6 @@ mod tests {
             .await
             .expect("retrying admission cancellation should be idempotent");
         assert!(cancel.is_cancelled());
-        let err = store
-            .update_pool_stats_batch_for_rebalance(0, "bucket".to_string(), &[&FileInfo::default()], rebalance_id)
-            .await
-            .expect_err("stop racing with a final stats update must cancel that update");
-        assert!(matches!(err, Error::OperationCanceled), "operator stop lost its cancellation type: {err}");
-    }
-
-    #[tokio::test]
-    async fn prepare_rebalance_stop_preserves_intent_when_worker_stops_before_reload() {
-        let id = "stop-worker-before-reload";
-        let cancel = tokio_util::sync::CancellationToken::new();
-        let (_temp_dirs, store) = crate::services::rebalance::test_store_with_persisted_rebalance_meta(RebalanceMeta {
-            id: id.to_string(),
-            cancel: Some(cancel.clone()),
-            pool_stats: vec![RebalanceStats {
-                participating: true,
-                info: RebalanceInfo {
-                    status: RebalStatus::Stopped,
-                    ..Default::default()
-                },
-                ..Default::default()
-            }],
-            ..Default::default()
-        })
-        .await;
-        let gate = {
-            let mut meta = store.rebalance_meta.write().await;
-            let meta = meta.as_mut().expect("local rebalance metadata");
-            meta.pool_stats[0].info.status = RebalStatus::Started;
-            Arc::clone(&meta.activation_gate)
-        };
-        assert_eq!(
-            store.prepare_rebalance_stop().await.expect("prepare the same run stop"),
-            Some(id.to_string())
-        );
-        {
-            let meta = store.rebalance_meta.read().await;
-            let meta = meta.as_ref().expect("reloaded stop target");
-            assert!(Arc::ptr_eq(&gate, &meta.activation_gate), "reload must retain the drained run's gate");
-            assert!(meta.cancel.as_ref().is_some_and(|token| token.is_cancelled()));
-        }
-        store
-            .stop_rebalance_for_id(Some(id))
-            .await
-            .expect("finish the stop after the worker's terminal event");
-        store
-            .load_rebalance_meta()
-            .await
-            .expect("reload the acknowledged durable stop");
-        let meta = store.rebalance_meta.read().await;
-        let meta = meta.as_ref().expect("durable stopped metadata");
-        assert!(meta.stopped_at.is_some(), "a successful stop must retain its durable timestamp");
-        assert_eq!(meta.pool_stats[0].info.status, RebalStatus::Stopped);
     }
 
     #[tokio::test]
@@ -2169,10 +2031,7 @@ mod tests {
         let err = acquire_persisted_rebalance_run_guard(set_disks, active.id.as_str(), "cross-node stale snapshot")
             .await
             .expect_err("persisted stop must fence a node that missed stop propagation");
-        assert!(
-            matches!(err, Error::OperationCanceled),
-            "a durable remote stop cancels the same run: {err}"
-        );
+        assert!(err.to_string().contains("inactive rebalance worker rejected"));
     }
 
     #[test]

crates/ecstore/src/services/rebalance/entry.rs

@@ -19,11 +19,11 @@ use super::meta::{
 use super::migration::{RebalanceMigrationBackend, migrate_entry_version};
 use super::worker::{
     RebalanceEntryCleanupResult, RebalanceEntryTask, load_rebalance_bucket_configs, rebalance_max_attempts,
-    record_rebalance_error, resolve_rebalance_bucket_error, resolve_rebalance_entry_cleanup_delete_result,
-    resolve_rebalance_file_info_versions_result, resolve_rebalance_migrate_result_error, resolve_rebalance_stats_update_result,
-    resolve_rebalance_worker_result, run_rebalance_listing_with_retry, should_cleanup_rebalance_source_entry,
-    should_count_rebalance_version_complete, should_defer_rebalance_entry_failure, should_skip_rebalance_delete_marker,
-    wait_rebalance_entry_tasks, with_rebalance_entry_context,
+    resolve_rebalance_bucket_error, resolve_rebalance_entry_cleanup_delete_result, resolve_rebalance_file_info_versions_result,
+    resolve_rebalance_migrate_result_error, resolve_rebalance_stats_update_result, resolve_rebalance_worker_result,
+    run_rebalance_listing_with_retry, should_cleanup_rebalance_source_entry, should_count_rebalance_version_complete,
+    should_defer_rebalance_entry_failure, should_skip_rebalance_delete_marker, wait_rebalance_entry_tasks,
+    with_rebalance_entry_context,
 };
 use super::{
     EVENT_REBALANCE_BUCKET, EVENT_REBALANCE_ENTRY, EVENT_REBALANCE_STATE, LOG_COMPONENT_ECSTORE, LOG_SUBSYSTEM_REBALANCE,
@@ -676,8 +676,10 @@ impl ECStore {
                             }
                             error!("rebalance_entry: data movement admission failed: {err}");
                             let mut first_err = entry_error.lock().await;
-                            record_rebalance_error(&mut first_err, err);
-                            callback_rx.cancel();
+                            if first_err.is_none() {
+                                *first_err = Some(err);
+                                callback_rx.cancel();
+                            }
                             return;
                         }
 
@@ -719,8 +721,10 @@ impl ECStore {
                             if let Err(err) = &result {
                                 error!("rebalance_entry: rebalance entry failed: {err}");
                                 let mut first_err = entry_error.lock().await;
-                                record_rebalance_error(&mut first_err, err.clone());
-                                callback_rx.cancel();
+                                if first_err.is_none() {
+                                    *first_err = Some(err.clone());
+                                    callback_rx.cancel();
+                                }
                             }
                             debug!(
                                 event = EVENT_REBALANCE_ENTRY,
@@ -789,7 +793,10 @@ impl ECStore {
                     deferred_error = Some(last_error);
                 }
                 Ok(_) => {}
-                Err(err) => record_rebalance_error(&mut worker_error, err),
+                Err(err) if worker_error.is_none() => {
+                    worker_error = Some(err);
+                }
+                Err(_) => {}
             }
         }
         let entry_error = entry_error.lock().await.clone();

crates/ecstore/src/services/rebalance/meta.rs

@@ -643,12 +643,16 @@ pub(super) fn should_skip_start_rebalance(cancel_attached: bool, in_progress: bo
     cancel_attached && in_progress
 }
 
+pub(super) fn is_rebalance_stopped_terminal_event(terminal_event: &RebalanceTerminalEvent) -> bool {
+    matches!(terminal_event, RebalanceTerminalEvent::Stopped { .. })
+}
+
 pub(super) fn should_preserve_rebalance_stopped_state(
     meta_stopped: bool,
     status: RebalStatus,
     terminal_event: &RebalanceTerminalEvent,
 ) -> bool {
-    (meta_stopped || status == RebalStatus::Stopped) && matches!(terminal_event, RebalanceTerminalEvent::Completed { .. })
+    (meta_stopped || status == RebalStatus::Stopped) && !is_rebalance_stopped_terminal_event(terminal_event)
 }
 
 pub(super) fn resolve_rebalance_participants(pool_stats: &[RebalanceStats], pool_count: usize) -> Vec<bool> {
@@ -916,7 +920,7 @@ pub(super) fn clear_rebalance_cancel_token(meta: Option<&mut RebalanceMeta>) ->
 
 pub(super) fn stop_rebalance_state(meta: &mut RebalanceMeta, now: OffsetDateTime) {
     clear_rebalance_cancel_token(Some(meta));
-    if meta.stopped_at.is_none() && (meta.stop_requested || is_rebalance_in_progress(meta)) {
+    if meta.stopped_at.is_none() && is_rebalance_in_progress(meta) {
         apply_stopped_at(meta, now);
     } else if meta.stopped_at.is_some() {
         mark_started_rebalance_pools_stopping(meta);

crates/ecstore/src/services/rebalance/rebalance_unit_tests.rs

@@ -19,14 +19,14 @@ use super::meta::{
     complete_rebalance_pools_at_goal, complete_rebalance_pools_with_empty_queue, defer_bucket_in_rebalance_queue,
     ensure_rebalance_not_decommissioning, ensure_valid_rebalance_pool_index, first_rebalance_bucket,
     has_deferred_rebalance_error, is_rebalance_actively_running, is_rebalance_conflicting_with_decommission,
-    is_rebalance_in_progress, is_rebalance_meta_replaceable_for_new_id, mark_rebalance_bucket_done, merge_rebalance_bucket_lists,
-    merge_rebalance_meta, next_rebal_bucket_from_stat, percent_free_ratio, rebalance_goal_reached,
-    rebalance_meta_load_no_data_error, rebalance_meta_load_unknown_format_error, rebalance_meta_load_unknown_version_error,
-    rebalance_requires_worker_activation, record_rebalance_cleanup_warning_in_meta, remove_rebalanced_buckets_from_queue,
-    resolve_next_rebalance_bucket, resolve_rebalance_participants, should_accept_rebalance_stats_update,
-    should_ignore_rebalance_data_usage_cache, should_pool_participate, should_preserve_rebalance_stopped_state,
-    should_skip_start_rebalance, stop_rebalance_meta_snapshot, stop_rebalance_state, take_bucket_from_rebalance_queue,
-    validate_init_rebalance_state, validate_start_rebalance_state,
+    is_rebalance_in_progress, is_rebalance_meta_replaceable_for_new_id, is_rebalance_stopped_terminal_event,
+    mark_rebalance_bucket_done, merge_rebalance_bucket_lists, merge_rebalance_meta, next_rebal_bucket_from_stat,
+    percent_free_ratio, rebalance_goal_reached, rebalance_meta_load_no_data_error, rebalance_meta_load_unknown_format_error,
+    rebalance_meta_load_unknown_version_error, rebalance_requires_worker_activation, record_rebalance_cleanup_warning_in_meta,
+    remove_rebalanced_buckets_from_queue, resolve_next_rebalance_bucket, resolve_rebalance_participants,
+    should_accept_rebalance_stats_update, should_ignore_rebalance_data_usage_cache, should_pool_participate,
+    should_preserve_rebalance_stopped_state, should_skip_start_rebalance, stop_rebalance_meta_snapshot, stop_rebalance_state,
+    take_bucket_from_rebalance_queue, validate_init_rebalance_state, validate_start_rebalance_state,
 };
 use super::migration::{
     MigrationBackend, MigrationVersionResult, migrate_entry_version, migrate_entry_version_with_retry_wait,
@@ -1676,30 +1676,6 @@ fn test_resolve_rebalance_stats_update_result_passthrough() {
     assert!(resolve_rebalance_stats_update_result(Ok(()), 0, "bucket", "object").is_ok());
 }
 
-#[test]
-fn test_rebalance_stop_preserves_cancellation_through_entry_context() {
-    let err = resolve_rebalance_stats_update_result(Err(Error::OperationCanceled), 0, "bucket", "object")
-        .expect_err("canceled stats update");
-    let err = with_rebalance_entry_context("stats", "bucket", "object", err);
-    assert!(matches!(err, Error::OperationCanceled));
-    assert!(matches!(
-        classify_rebalance_terminal_event(Some(Err(err)), OffsetDateTime::now_utc()),
-        RebalanceTerminalEvent::Stopped { .. }
-    ));
-}
-
-#[tokio::test]
-async fn test_rebalance_stop_does_not_hide_later_entry_failure() {
-    let tasks = Arc::new(tokio::sync::Mutex::new(vec![
-        tokio::spawn(async { Err(Error::OperationCanceled) }),
-        tokio::spawn(async { Err(Error::ErasureWriteQuorum) }),
-    ]));
-    let err = wait_rebalance_entry_tasks(0, tasks)
-        .await
-        .expect_err("entry I/O failure must survive sibling cancellation");
-    assert!(matches!(err, Error::ErasureWriteQuorum));
-}
-
 #[test]
 fn test_resolve_rebalance_stats_update_result_wraps_error_context() {
     let err = resolve_rebalance_stats_update_result(Err(Error::SlowDown), 2, "bucket-a", "obj.txt")
@@ -2389,9 +2365,9 @@ fn test_resolve_rebalance_terminal_error_wraps_signal_failure_context() {
 }
 
 #[test]
-fn test_resolve_rebalance_bucket_error_prefers_real_failure_over_entry_cancellation() {
+fn test_resolve_rebalance_bucket_error_prefers_entry_error() {
     let err = resolve_rebalance_bucket_error(Some(Error::OperationCanceled), Some(Error::SlowDown)).unwrap_err();
-    assert!(matches!(err, Error::SlowDown));
+    assert!(matches!(err, Error::OperationCanceled));
 }
 
 #[test]
@@ -2536,6 +2512,19 @@ fn test_apply_rebalance_terminal_event_stopped_clears_error() {
     assert_eq!(last_error, None);
 }
 
+#[test]
+fn test_is_rebalance_stopped_terminal_event_only_matches_stopped_variant() {
+    let stopped = RebalanceTerminalEvent::Stopped {
+        msg: "stopped".to_string(),
+    };
+    let completed = RebalanceTerminalEvent::Completed {
+        msg: "completed".to_string(),
+    };
+
+    assert!(is_rebalance_stopped_terminal_event(&stopped));
+    assert!(!is_rebalance_stopped_terminal_event(&completed));
+}
+
 #[test]
 fn test_should_preserve_rebalance_stopped_state_when_meta_marked_stopped() {
     let event = RebalanceTerminalEvent::Completed {
@@ -2546,14 +2535,13 @@ fn test_should_preserve_rebalance_stopped_state_when_meta_marked_stopped() {
 }
 
 #[test]
-fn test_rebalance_stop_does_not_hide_real_terminal_failure() {
+fn test_should_preserve_rebalance_stopped_state_when_pool_already_stopped() {
     let event = RebalanceTerminalEvent::Failed {
         msg: "failed".to_string(),
         last_error: "boom".to_string(),
     };
 
-    assert!(!should_preserve_rebalance_stopped_state(false, RebalStatus::Stopped, &event));
-    assert!(!should_preserve_rebalance_stopped_state(true, RebalStatus::Started, &event));
+    assert!(should_preserve_rebalance_stopped_state(false, RebalStatus::Stopped, &event));
 }
 
 #[test]
@@ -2728,32 +2716,6 @@ async fn test_start_rebalance_for_id_rejects_stopped_metadata() {
     assert!(err.to_string().contains("was stopped before start"));
 }
 
-#[test]
-fn test_rebalance_stop_intent_blocks_activation_before_durable_timestamp() {
-    let mut meta = RebalanceMeta {
-        id: "stopping".to_string(),
-        stop_requested: true,
-        pool_stats: vec![RebalanceStats {
-            participating: true,
-            buckets: vec!["pending".to_string()],
-            info: RebalanceInfo {
-                status: RebalStatus::Started,
-                ..Default::default()
-            },
-            ..Default::default()
-        }],
-        ..Default::default()
-    };
-    let outcome = commit_local_rebalance_worker_activation(&mut meta, "stopping", CancellationToken::new())
-        .expect("stop must prevent activation without a new error");
-    assert_eq!(outcome, RebalanceLocalActivationOutcome::NotStartedTerminal);
-    assert!(meta.cancel.is_none());
-    assert!(meta.stopped_at.is_none());
-    let bytes = rmp_serde::to_vec_named(&meta).expect("encode legacy-compatible metadata");
-    let reloaded: RebalanceMeta = rmp_serde::from_slice(&bytes).expect("decode metadata");
-    assert!(!reloaded.stop_requested, "operator intent is local, not a new persisted field");
-}
-
 #[test]
 fn test_stopped_activation_state_prevents_worker_token_commit() {
     let mut meta = RebalanceMeta {

crates/ecstore/src/services/rebalance/runtime.rs

@@ -57,7 +57,7 @@ pub(super) fn commit_local_rebalance_worker_activation(
             meta.id
         )));
     }
-    if meta.stopped_at.is_some() || meta.stop_requested || !is_rebalance_in_progress(meta) {
+    if meta.stopped_at.is_some() || !is_rebalance_in_progress(meta) {
         return Ok(RebalanceLocalActivationOutcome::NotStartedTerminal);
     }
     meta.cancel = Some(cancel);

crates/ecstore/src/services/rebalance/types.rs

@@ -143,10 +143,6 @@ pub struct DiskStat {
 pub struct RebalanceMeta {
     #[serde(skip)]
     pub cancel: Option<CancellationToken>, // To be invoked on rebalance-stop
-    /// Local operator intent, scoped to this run ID; a worker failure also cancels
-    /// `cancel`, so the token alone cannot identify an administrative stop.
-    #[serde(skip)]
-    pub stop_requested: bool,
     #[serde(skip)]
     pub activation_gate: std::sync::Arc<tokio::sync::RwLock<()>>,
     #[serde(skip)]

crates/ecstore/src/services/rebalance/worker.rs

@@ -38,17 +38,6 @@ pub(super) fn resolve_rebalance_worker_result<T>(
 
 pub(super) type RebalanceEntryTask = tokio::task::JoinHandle<Result<RebalanceEntryOutcome>>;
 
-/// Preserve the first real failure even when another task observes cancellation
-/// first. Cancellation is an outcome only when no entry or worker failed.
-pub(super) fn record_rebalance_error(first_error: &mut Option<Error>, err: Error) {
-    if first_error
-        .as_ref()
-        .is_none_or(|first| is_err_operation_canceled(first) && !is_err_operation_canceled(&err))
-    {
-        *first_error = Some(err);
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(super) enum RebalanceEntryCleanupResult {
     Completed { warning: Option<String> },
@@ -76,12 +65,16 @@ pub(super) async fn wait_rebalance_entry_tasks(
             }
             Ok(Err(err)) => {
                 error!("rebalance entry task failed for set {}: {}", set_idx, err);
-                record_rebalance_error(&mut first_error, err);
+                if first_error.is_none() {
+                    first_error = Some(err);
+                }
             }
             Err(err) => {
                 let err = Error::other(format!("rebalance entry task join error for set {set_idx}: {err}"));
                 error!("{}", err);
-                record_rebalance_error(&mut first_error, err);
+                if first_error.is_none() {
+                    first_error = Some(err);
+                }
             }
         }
     }
@@ -142,9 +135,6 @@ pub(super) fn resolve_rebalance_stats_update_result(
     object_name: &str,
 ) -> Result<()> {
     result.map_err(|err| {
-        if is_err_operation_canceled(&err) {
-            return err;
-        }
         Error::other(format!(
             "rebalance stats update failed for pool {pool_idx} bucket {bucket} object {object_name}: {err}"
         ))
@@ -224,11 +214,16 @@ pub(super) fn resolve_rebalance_terminal_error(primary_err: Error, signal_result
     }
 }
 
-pub(super) fn resolve_rebalance_bucket_error(mut entry_error: Option<Error>, worker_error: Option<Error>) -> Result<()> {
-    if let Some(err) = worker_error {
-        record_rebalance_error(&mut entry_error, err);
+pub(super) fn resolve_rebalance_bucket_error(entry_error: Option<Error>, worker_error: Option<Error>) -> Result<()> {
+    if let Some(err) = entry_error {
+        return Err(err);
     }
-    entry_error.map_or(Ok(()), Err)
+
+    if let Some(err) = worker_error {
+        return Err(err);
+    }
+
+    Ok(())
 }
 
 pub(super) fn resolve_rebalance_bucket_result(
@@ -367,9 +362,6 @@ pub(super) fn ensure_rebalance_listing_disks_available(has_disks: bool, bucket:
 }
 
 pub(super) fn with_rebalance_entry_context(stage: &str, bucket: &str, object_name: &str, err: Error) -> Error {
-    if is_err_operation_canceled(&err) {
-        return err;
-    }
     Error::other(format!("rebalance entry {stage} failed for {bucket}/{object_name}: {err}"))
 }
 

crates/ecstore/src/set_disk/mod.rs

@@ -6650,7 +6650,6 @@ async fn get_storage_info(disks: &[Option<DiskStore>], eps: &[Endpoint]) -> rust
             total_sets,
             ..Default::default()
         },
-        ..Default::default()
     }
 }
 pub async fn stat_all_dirs(disks: &[Option<DiskStore>], bucket: &str, prefix: &str) -> Vec<Option<DiskError>> {

crates/ecstore/src/store/heal.rs

@@ -2353,22 +2353,11 @@ mod tests {
             .await
             .expect("quorum boundary heal should return a mapped result");
         *store.pools[0].disk_set[0].disks.write().await = original_quorum_disks;
-        let quorum_err = quorum_err
-            .as_ref()
-            .expect("heal must fail closed when capacity admission cannot verify pool metadata");
-        let quorum_failure = quorum_err
-            .pool_metadata_failure()
-            .expect("capacity admission failure should preserve typed pool metadata context");
-        assert_eq!(
-            quorum_failure.kind,
-            crate::error::PoolMetadataFailure::ReadUnavailable,
-            "read-only capacity admission failure must remain retryable"
-        );
-        assert_eq!(quorum_failure.operation, "target capacity admission failed");
-        assert_eq!(quorum_failure.phase, "pool_read");
         assert!(
-            store.pool_meta_writes_ready().await,
-            "read-only capacity admission failure must not latch the pool metadata writer"
+            quorum_err.as_ref().is_some_and(|err| err
+                .to_string()
+                .contains("pool metadata writes remain blocked after a recovery-required replica state")),
+            "heal must fail closed when capacity admission cannot verify pool metadata, got {quorum_err:?}"
         );
         shutdown.cancel();
     }

crates/ecstore/src/store/init.rs

@@ -14,8 +14,8 @@
 
 use super::*;
 use crate::core::pools::{
-    PoolMetaBootstrapAuthority, PoolMetaReplicaState, PoolMetaWriteState, local_decommission_queue_prefix,
-    persist_pool_meta_identity_for_startup, pool_meta_has_active_decommission,
+    PoolMetaBootstrapAuthority, PoolMetaReplicaState, PoolMetaWriteState, load_pool_meta_identity_observing,
+    local_decommission_queue_prefix, persist_pool_meta_identity_for_startup, pool_meta_has_active_decommission,
 };
 use crate::runtime::instance::InstanceContext;
 use crate::runtime::sources as runtime_sources;
@@ -103,10 +103,7 @@ const REBALANCE_INITIAL_RESUME_DELAY: Duration = Duration::from_secs(10);
 const REBALANCE_RESUME_RETRY_DELAY: Duration = Duration::from_secs(10);
 
 fn should_retry_format_load(err: &Error) -> bool {
-    !matches!(
-        err,
-        Error::CorruptedFormat | Error::UnsupportedSnsdExpansion { .. } | Error::PoolTopologyMismatch { .. }
-    )
+    !matches!(err, Error::CorruptedFormat)
 }
 
 fn should_auto_start_rebalance_after_init(decommission_running: bool, rebalance_resume_required: bool) -> bool {
@@ -153,14 +150,17 @@ async fn load_pool_meta_for_startup<S>(
 where
     S: EcstoreObjectIO,
 {
+    load_pool_meta_identity_observing(pools.clone(), write_state)
+        .await
+        .map_err(|err| Error::other(format!("store init failed during load_pool_meta_identity: {err}")))?;
     let mut meta = PoolMeta::default();
     let replica_state = meta
-        .load_for_startup_observing(pools, write_state)
+        .load_no_lock_from_replicas_observing(pools, write_state)
         .await
-        .map_err(|err| Error::other_with_context("store init failed during load_pool_meta", err))?;
+        .map_err(|err| Error::other(format!("store init failed during load_pool_meta: {err}")))?;
     write_state.observe_replicas(replica_state);
     write_state
-        .ensure_startup_metadata_can_initialize()
+        .ensure_missing_metadata_can_initialize()
         .map_err(|err| Error::other(format!("store init failed during classify_pool_meta_absence: {err}")))?;
     Ok((meta, replica_state))
 }
@@ -630,27 +630,14 @@ impl ECStore {
             .pools
             .first()
             .is_some_and(|pool| pool_first_endpoint_is_local(&pool.endpoints));
-        #[cfg(feature = "e2e-test-hooks")]
-        let startup_attempt = uuid::Uuid::new_v4();
         let (meta, pool_meta_replica_state) = {
             let mut write_state = self.pool_meta_save_gate.lock().await;
             establish_pool_meta_bootstrap_identity_if_proven(self.pools.clone(), &mut write_state, should_persist_pool_meta)
                 .await
                 .map_err(|err| Error::other(format!("store init failed during establish_pool_meta_bootstrap_identity: {err}")))?;
-            let load = load_pool_meta_for_startup(self.pools.clone(), &mut write_state);
-            #[cfg(feature = "e2e-test-hooks")]
-            let load = crate::core::pools::startup_cas_test_scope(startup_attempt, "load", &self.pools, load);
-            load.await?
+            load_pool_meta_for_startup(self.pools.clone(), &mut write_state).await?
         };
         let update = meta.validate(self.pools.clone())?;
-        #[cfg(feature = "e2e-test-hooks")]
-        crate::core::pools::startup_cas_test_observe(serde_json::json!({
-            "kind": "startup-classifier", "attempt": startup_attempt,
-            "elected_writer": should_persist_pool_meta,
-            "needs_repair": pool_meta_replica_state.needs_repair,
-            "repair_write_safe": pool_meta_replica_state.repair_write_safe,
-            "topology_update": update,
-        }));
         let endpoints = runtime_sources::endpoint_pools_or_default();
 
         let mut installed_pool_meta = if update {
@@ -662,17 +649,15 @@ impl ECStore {
         // distributed startup can race on the same lock and replay the prior init bug.
         {
             let mut write_state = self.pool_meta_save_gate.lock().await;
-            let persist = persist_pool_meta_for_startup_if_safe(
+            installed_pool_meta = persist_pool_meta_for_startup_if_safe(
                 &installed_pool_meta,
                 self.pools.clone(),
                 pool_meta_replica_state,
                 &mut write_state,
                 update,
                 should_persist_pool_meta,
-            );
-            #[cfg(feature = "e2e-test-hooks")]
-            let persist = crate::core::pools::startup_cas_test_scope(startup_attempt, "persist", &self.pools, persist);
-            installed_pool_meta = persist.await?;
+            )
+            .await?;
         }
 
         {
@@ -781,33 +766,6 @@ impl ECStore {
             });
         }
 
-        let recovery_store = self.clone();
-        let recovery_rx = rx.clone();
-        tokio::spawn(async move {
-            let mut delay = std::time::Duration::from_secs(5);
-            loop {
-                tokio::select! {
-                    _ = recovery_rx.cancelled() => return,
-                    _ = tokio::time::sleep(delay) => {}
-                }
-                let result = tokio::select! {
-                    _ = recovery_rx.cancelled() => return,
-                    result = tokio::time::timeout(std::time::Duration::from_secs(30), recovery_store.recover_pool_meta_transaction()) => result,
-                };
-                delay = match result {
-                    Ok(Ok(_)) => std::time::Duration::from_secs(5),
-                    failure => {
-                        let error = match failure {
-                            Ok(Err(error)) => error,
-                            _ => Error::Timeout,
-                        };
-                        recovery_store.record_pool_meta_recovery_failure(error);
-                        (delay * 2).min(std::time::Duration::from_secs(60))
-                    }
-                };
-            }
-        });
-
         runtime_sources::init_bucket_monitor_for_current_endpoints();
         crate::bucket::bucket_target_sys::BucketTargetSys::get().start_heartbeat();
 
@@ -1373,321 +1331,6 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn test_pending_identity_follower_becomes_write_ready_after_elected_commit() {
-        let deployment_id = Uuid::new_v4();
-        let storage = Arc::new(StartupPoolMetaStorage::new(Vec::new()));
-        let mut elected_writer = PoolMetaWriteState::for_startup(deployment_id, true);
-        establish_pool_meta_bootstrap_identity_if_proven(vec![storage.clone()], &mut elected_writer, true)
-            .await
-            .expect("the elected writer should persist its pending bootstrap identity");
-        let pending_objects = storage
-            .objects
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .clone();
-        assert!(
-            !pool_meta_identity_initialized_for_test(&pending_objects[POOL_META_IDENTITY_NAME].0)
-                .expect("decode the pending identity")
-        );
-        assert!(!pending_objects.contains_key(POOL_META_NAME));
-
-        let mut follower = PoolMetaWriteState::for_startup(deployment_id, false);
-        let pending_error = load_pool_meta_for_startup(vec![storage.clone()], &mut follower)
-            .await
-            .expect_err("the follower must not initialize metadata using another node's pending identity");
-        assert!(pending_error.to_string().contains("no verified fresh-bootstrap proof"));
-        let blocked = follower
-            .ensure_write_safe("pending identity follower")
-            .expect_err("the pending identity must not authorize follower writes");
-        assert_eq!(blocked.pool_metadata_failure().expect("typed failure").phase, "metadata_absence");
-        assert_eq!(storage.pool_meta_write_attempts.load(Ordering::SeqCst), 0);
-        assert_eq!(
-            *storage.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner),
-            pending_objects,
-            "the rejected follower must leave both metadata objects and CAS tokens untouched"
-        );
-
-        let (initial, replica_state) = load_pool_meta_for_startup(vec![storage.clone()], &mut elected_writer)
-            .await
-            .expect("the elected writer's bootstrap proof should authorize missing metadata");
-        assert!(initial.pools.is_empty());
-        assert!(!replica_state.needs_repair);
-        assert!(replica_state.repair_write_safe);
-        let committed = persist_pool_meta_for_startup_if_safe(
-            &init_test_pool_meta(None),
-            vec![storage.clone()],
-            replica_state,
-            &mut elected_writer,
-            true,
-            true,
-        )
-        .await
-        .expect("the elected writer should finish the normal startup metadata transaction");
-        elected_writer
-            .ensure_write_safe("elected writer after commit")
-            .expect("both metadata CAS phases and the identity commit must complete");
-        assert_eq!(storage.pool_meta_write_attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(
-            *storage
-                .pool_meta_written_versions
-                .lock()
-                .unwrap_or_else(std::sync::PoisonError::into_inner),
-            vec![3, 3]
-        );
-        let committed_objects = storage
-            .objects
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .clone();
-        assert!(
-            pool_meta_identity_initialized_for_test(&committed_objects[POOL_META_IDENTITY_NAME].0)
-                .expect("decode the committed identity")
-        );
-        assert_eq!(
-            pool_meta_v3_commit_state_for_test(committed_objects[POOL_META_NAME].0.clone())
-                .expect("decode the complete V3 pool metadata"),
-            (1, true)
-        );
-
-        // Retry the same state that observed the pending identity, after normal commit completion.
-        let (reloaded, replica_state) = load_pool_meta_for_startup(vec![storage.clone()], &mut follower)
-            .await
-            .expect("the original follower should validate matching committed identity and metadata");
-        assert!(!replica_state.needs_repair);
-        assert!(replica_state.repair_write_safe);
-        assert_eq!(
-            serde_json::to_value(&reloaded).expect("serialize the reloaded metadata"),
-            serde_json::to_value(&committed).expect("serialize the committed metadata")
-        );
-        persist_pool_meta_for_startup_if_safe(&reloaded, vec![storage.clone()], replica_state, &mut follower, false, false)
-            .await
-            .expect("the non-elected follower must adopt the committed metadata without writing");
-
-        let mut late_follower = PoolMetaWriteState::for_startup(deployment_id, false);
-        load_pool_meta_for_startup(vec![storage.clone()], &mut late_follower)
-            .await
-            .expect("a follower first observing these same committed records must accept them");
-        late_follower
-            .ensure_write_safe("late follower after commit")
-            .expect("the committed records themselves must permit readiness");
-        assert_eq!(storage.pool_meta_write_attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(
-            *storage.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner),
-            committed_objects,
-            "neither follower may rewrite the elected writer's committed bytes or CAS tokens"
-        );
-        follower.ensure_write_safe("original follower after elected commit").expect(
-            "a follower retry must become write-ready after the elected writer commits matching identity and pool metadata",
-        );
-    }
-
-    #[tokio::test]
-    async fn test_pending_identity_follower_accepts_safe_repairable_commit() {
-        let deployment_id = Uuid::new_v4();
-        let canonical = Arc::new(StartupPoolMetaStorage::new(Vec::new()));
-        let backup = Arc::new(StartupPoolMetaStorage::new(Vec::new()));
-        let pools = vec![canonical.clone(), backup.clone()];
-        let mut writer = PoolMetaWriteState::for_startup(deployment_id, true);
-        establish_pool_meta_bootstrap_identity_if_proven(pools.clone(), &mut writer, true)
-            .await
-            .expect("create pending identities through the elected writer");
-        let pending_backup = backup
-            .objects
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .clone();
-        let mut follower = PoolMetaWriteState::for_startup(deployment_id, false);
-        for _ in 0..2 {
-            load_pool_meta_for_startup(pools.clone(), &mut follower)
-                .await
-                .expect_err("repeated pending reads cannot authorize follower writes");
-            follower
-                .ensure_write_safe("pending follower")
-                .expect_err("pending writes stay blocked");
-        }
-        assert_eq!(canonical.pool_meta_write_attempts.load(Ordering::SeqCst), 0);
-        assert_eq!(backup.pool_meta_write_attempts.load(Ordering::SeqCst), 0);
-        let (_, replica_state) = load_pool_meta_for_startup(pools.clone(), &mut writer)
-            .await
-            .expect("load fresh metadata");
-        let mut requested = init_test_pool_meta(None);
-        let mut second = requested.pools[0].clone();
-        second.id = 1;
-        second.cmd_line = "pool-1".to_string();
-        requested.pools.push(second);
-        let committed = persist_pool_meta_for_startup_if_safe(&requested, pools.clone(), replica_state, &mut writer, true, true)
-            .await
-            .expect("commit metadata and identity through the normal startup path");
-        assert_eq!(canonical.pool_meta_write_attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(backup.pool_meta_write_attempts.load(Ordering::SeqCst), 2);
-
-        // Expose the backup's actual pre-commit image: pending identity and missing pool.bin.
-        *backup.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = pending_backup.clone();
-        let canonical_objects = canonical
-            .objects
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .clone();
-        assert!(pool_meta_identity_initialized_for_test(&canonical_objects[POOL_META_IDENTITY_NAME].0).expect("decode identity"));
-        assert_eq!(
-            pool_meta_v3_commit_state_for_test(canonical_objects[POOL_META_NAME].0.clone()).expect("decode committed record"),
-            (1, true)
-        );
-        canonical
-            .objects
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .insert(POOL_META_IDENTITY_NAME.to_string(), pending_backup[POOL_META_IDENTITY_NAME].clone());
-        load_pool_meta_for_startup(pools.clone(), &mut follower)
-            .await
-            .expect("committed metadata is readable before identity promotion");
-        follower
-            .ensure_write_safe("identity still pending")
-            .expect_err("pool metadata alone cannot finish bootstrap");
-        *canonical.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = canonical_objects.clone();
-        let (loaded, replica_state) = load_pool_meta_for_startup(pools.clone(), &mut follower)
-            .await
-            .expect("a validated committed canonical copy permits safe repair of the lagging backup");
-        assert!(replica_state.needs_repair);
-        assert!(replica_state.repair_write_safe);
-        assert!(follower.identity_requires_repair());
-        assert_eq!(
-            serde_json::to_value(&loaded).expect("loaded metadata"),
-            serde_json::to_value(&committed).expect("committed metadata")
-        );
-        follower
-            .ensure_write_safe("safe repairable startup")
-            .expect("repairable copies must not permanently block a follower");
-        persist_pool_meta_for_startup_if_safe(&loaded, pools, replica_state, &mut follower, false, false)
-            .await
-            .expect("a non-elected follower never repairs copies itself");
-        assert_eq!(canonical.pool_meta_write_attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(backup.pool_meta_write_attempts.load(Ordering::SeqCst), 2);
-        assert_eq!(
-            *canonical.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner),
-            canonical_objects
-        );
-        assert_eq!(*backup.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner), pending_backup);
-    }
-
-    #[tokio::test]
-    async fn test_pending_identity_wait_stays_blocked_after_hard_startup_failure() {
-        #[derive(Clone, Copy, Debug)]
-        enum Fault {
-            Unreadable,
-            CorruptIdentity,
-            CorruptMetadata,
-            ConflictingIdentity,
-            ConflictingEpoch,
-            InitializedMetadataMissing,
-        }
-        for fault in [
-            Fault::Unreadable,
-            Fault::CorruptIdentity,
-            Fault::CorruptMetadata,
-            Fault::ConflictingIdentity,
-            Fault::ConflictingEpoch,
-            Fault::InitializedMetadataMissing,
-        ] {
-            let deployment_id = Uuid::new_v4();
-            let storage = Arc::new(StartupPoolMetaStorage::new(Vec::new()));
-            let mut writer = PoolMetaWriteState::for_startup(deployment_id, true);
-            establish_pool_meta_bootstrap_identity_if_proven(vec![storage.clone()], &mut writer, true)
-                .await
-                .expect("create pending identity");
-            let pending_objects = storage
-                .objects
-                .lock()
-                .unwrap_or_else(std::sync::PoisonError::into_inner)
-                .clone();
-            let pending = StartupPoolMetaStorage::new(Vec::new());
-            *pending.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = pending_objects;
-            let pending = Arc::new(pending);
-            let mut follower = PoolMetaWriteState::for_startup(deployment_id, false);
-            load_pool_meta_for_startup(vec![storage.clone()], &mut follower)
-                .await
-                .expect_err("pending identity must reject writes");
-            let (_, replica_state) = load_pool_meta_for_startup(vec![storage.clone()], &mut writer)
-                .await
-                .expect("load fresh metadata");
-            let committed = persist_pool_meta_for_startup_if_safe(
-                &init_test_pool_meta(None),
-                vec![storage.clone()],
-                replica_state,
-                &mut writer,
-                true,
-                true,
-            )
-            .await
-            .expect("commit matching identity and metadata");
-            let committed_objects = storage
-                .objects
-                .lock()
-                .unwrap_or_else(std::sync::PoisonError::into_inner)
-                .clone();
-            let mut faulty = StartupPoolMetaStorage::new(Vec::new());
-            let mut faulty_objects = committed_objects.clone();
-            match fault {
-                Fault::Unreadable => faulty.read_error = true,
-                Fault::CorruptIdentity => faulty_objects.get_mut(POOL_META_IDENTITY_NAME).expect("identity exists").0 = vec![0],
-                Fault::CorruptMetadata => faulty_objects.get_mut(POOL_META_NAME).expect("metadata exists").0 = vec![0],
-                Fault::ConflictingIdentity | Fault::ConflictingEpoch => {
-                    let (cluster_id, epoch) = match fault {
-                        Fault::ConflictingIdentity => (Uuid::new_v4(), 1),
-                        _ => (deployment_id, 2),
-                    };
-                    faulty_objects.get_mut(POOL_META_IDENTITY_NAME).expect("identity exists").0 =
-                        crate::core::pools::initialized_pool_meta_identity_for_test(cluster_id, epoch)
-                            .expect("encode valid conflicting identity");
-                }
-                Fault::InitializedMetadataMissing => {
-                    faulty_objects.remove(POOL_META_NAME);
-                }
-            }
-            *faulty.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = faulty_objects.clone();
-            let faulty = Arc::new(faulty);
-            load_pool_meta_for_startup(vec![faulty.clone()], &mut follower)
-                .await
-                .expect_err("hard startup failure must reject this read");
-            let blocked = follower
-                .ensure_write_safe("after hard startup failure")
-                .expect_err("hard failure must block writes");
-            let failure = blocked.pool_metadata_failure().expect("typed hard failure");
-            assert_eq!(faulty.pool_meta_write_attempts.load(Ordering::SeqCst), 0, "{fault:?}");
-            assert_eq!(
-                *faulty.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner),
-                faulty_objects,
-                "{fault:?}"
-            );
-
-            load_pool_meta_for_startup(vec![pending], &mut follower)
-                .await
-                .expect_err("a later pending identity cannot downgrade the hard block");
-            let (loaded, replicas) = load_pool_meta_for_startup(vec![storage.clone()], &mut follower)
-                .await
-                .expect("later healthy committed records remain readable");
-            assert!(replicas.repair_write_safe);
-            assert!(!replicas.needs_repair);
-            assert_eq!(
-                serde_json::to_value(&loaded).expect("loaded metadata"),
-                serde_json::to_value(&committed).expect("committed metadata")
-            );
-            let still_blocked = follower
-                .ensure_write_safe("after healthy reread")
-                .expect_err("a hard failure must never downgrade to a temporary bootstrap wait");
-            let retained = still_blocked.pool_metadata_failure().expect("retained typed failure");
-            assert_eq!(retained.phase, failure.phase, "{fault:?}");
-            assert_eq!(retained.since, failure.since, "{fault:?}");
-            assert_eq!(storage.pool_meta_write_attempts.load(Ordering::SeqCst), 2, "{fault:?}");
-            assert_eq!(
-                *storage.objects.lock().unwrap_or_else(std::sync::PoisonError::into_inner),
-                committed_objects,
-                "{fault:?}"
-            );
-        }
-    }
-
     #[tokio::test]
     async fn test_nonfresh_identity_repair_crash_never_persists_pending_bootstrap_authority() {
         let deployment_id = Uuid::new_v4();
@@ -2141,33 +1784,6 @@ mod tests {
         assert!(should_retry_format_load(&StorageError::FirstDiskWait));
     }
 
-    #[test]
-    fn test_should_retry_format_load_rejects_permanent_topology_errors() {
-        for error in [
-            StorageError::UnsupportedSnsdExpansion { configured_drives: 4 },
-            StorageError::PoolTopologyMismatch {
-                stored_drives: 4,
-                stored_set_drive_count: 4,
-                configured_drives: 8,
-                configured_set_drive_count: 8,
-            },
-        ] {
-            assert!(!should_retry_format_load(&error), "topology errors require operator action: {error}");
-        }
-        for error in [
-            StorageError::DiskNotFound,
-            StorageError::Timeout,
-            StorageError::RemoteNotInitialized,
-            StorageError::NotFirstDisk,
-            StorageError::other(std::io::Error::from(std::io::ErrorKind::ConnectionRefused)),
-        ] {
-            assert!(
-                should_retry_format_load(&error),
-                "transient failures retain their existing retry path: {error}"
-            );
-        }
-    }
-
     #[test]
     fn test_should_auto_start_rebalance_after_init_allows_active_rebalance_without_decommission() {
         assert!(should_auto_start_rebalance_after_init(false, true));
@@ -2847,106 +2463,6 @@ mod tests {
         shutdown.cancel();
     }
 
-    #[tokio::test]
-    #[serial_test::serial(storage_class_env)]
-    async fn pool_metadata_preflight_recovery_preserves_single_and_multi_pool_public_mutations() {
-        for layout in [vec![4], vec![4, 4]] {
-            let temp_dir = tempfile::tempdir().unwrap();
-            let (_ctx, store, shutdown) =
-                without_storage_class_env(build_isolated_test_store(temp_dir.path(), "pool-meta-retry", &layout)).await;
-            crate::bucket::metadata_sys::init_bucket_metadata_sys(Arc::clone(&store), Vec::new()).await;
-            let bucket = format!("pool-meta-retry-{}", Uuid::new_v4());
-            store.make_bucket(&bucket, &MakeBucketOptions::default()).await.unwrap();
-            let mut saved_disks = Vec::new();
-            for set in &store.pools[0].disk_set {
-                let mut disks = set.disks.write().await;
-                let count = disks.len();
-                saved_disks.push((set.clone(), std::mem::replace(&mut *disks, vec![None; count])));
-            }
-            let indices = (0..layout.len()).collect::<Vec<_>>();
-            let err = store.save_current_pool_meta_for_test(&indices).await.unwrap_err();
-            assert_eq!(
-                err.pool_metadata_failure().unwrap().kind,
-                crate::error::PoolMetadataFailure::ReadUnavailable
-            );
-            for (set, disks) in saved_disks {
-                *set.disks.write().await = disks;
-            }
-            store.save_current_pool_meta_for_test(&indices).await.unwrap();
-            assert!(store.pool_meta_writes_ready().await);
-
-            let payload = b"pool metadata recovery payload".to_vec();
-            store
-                .put_object(&bucket, "put", &mut PutObjReader::from_vec(payload.clone()), &ObjectOptions::default())
-                .await
-                .unwrap();
-            let mut reader = store
-                .get_object_reader(&bucket, "put", None, HeaderMap::new(), &ObjectOptions::default())
-                .await
-                .unwrap();
-            let mut actual = Vec::new();
-            reader.stream.read_to_end(&mut actual).await.unwrap();
-            assert_eq!(actual, payload);
-            drop(reader);
-            store.delete_object(&bucket, "put", ObjectOptions::default()).await.unwrap();
-            assert!(crate::error::is_err_object_not_found(
-                &store
-                    .get_object_info(&bucket, "put", &ObjectOptions::default())
-                    .await
-                    .unwrap_err()
-            ));
-
-            let upload = store
-                .new_multipart_upload(&bucket, "multipart", &ObjectOptions::default())
-                .await
-                .unwrap();
-            let part = store
-                .put_object_part(
-                    &bucket,
-                    "multipart",
-                    &upload.upload_id,
-                    1,
-                    &mut PutObjReader::from_vec(payload.clone()),
-                    &ObjectOptions::default(),
-                )
-                .await
-                .unwrap();
-            store
-                .clone()
-                .complete_multipart_upload(
-                    &bucket,
-                    "multipart",
-                    &upload.upload_id,
-                    vec![crate::storage_api_contracts::multipart::CompletePart {
-                        part_num: part.part_num,
-                        etag: part.etag,
-                        ..Default::default()
-                    }],
-                    &ObjectOptions::default(),
-                )
-                .await
-                .unwrap();
-            let mut reader = store
-                .get_object_reader(&bucket, "multipart", None, HeaderMap::new(), &ObjectOptions::default())
-                .await
-                .unwrap();
-            actual.clear();
-            reader.stream.read_to_end(&mut actual).await.unwrap();
-            assert_eq!(actual, payload);
-            drop(reader);
-            let upload = store
-                .new_multipart_upload(&bucket, "abort", &ObjectOptions::default())
-                .await
-                .unwrap();
-            store
-                .abort_multipart_upload(&bucket, "abort", &upload.upload_id, &ObjectOptions::default())
-                .await
-                .unwrap();
-            assert!(store.pool_meta_writes_ready().await);
-            shutdown.cancel();
-        }
-    }
-
     #[cfg(feature = "test-util")]
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     #[serial_test::serial(storage_class_env)]

crates/ecstore/src/store/init_format.rs

@@ -109,21 +109,6 @@ pub(crate) async fn connect_load_init_formats_with_instance_ctx(
     let fresh_bootstrap_proven = should_init_erasure_disks(&errs);
     let formats_present = formats.iter().flatten().count();
     let mut format_quorum = (formats_present > 0).then(|| select_format_erasure_in_quorum(&formats, 0));
-    // A resized pool may never reach quorum under its new endpoint count.
-    // Diagnose a valid, unambiguous stored layout before migration or waiting.
-    // A healthy quorum still takes precedence over foreign minority formats;
-    // conflicting or malformed observations retain their existing error path.
-    if format_quorum.as_ref().is_some_and(Result::is_err)
-        && let Some(reference) = formats.iter().flatten().next()
-        && formats.iter().flatten().all(|format| {
-            format.shared_identity() == reference.shared_identity()
-                && reference.erasure.sets.iter().flatten().any(|id| *id == format.erasure.this)
-        })
-        && let Err(err @ (Error::UnsupportedSnsdExpansion { .. } | Error::PoolTopologyMismatch { .. })) =
-            check_format_erasure_value_for_topology(reference, formats.len(), set_drive_count)
-    {
-        return Err(err);
-    }
     if format_quorum.as_ref().is_none_or(Result::is_err)
         && errs.iter().any(|error| {
             matches!(
@@ -676,18 +661,15 @@ fn check_format_erasure_value_for_topology(format: &FormatV3, format_count: usiz
         .len()
         .checked_mul(set_drive_count_in_format)
         .ok_or_else(|| Error::other("erasure set drive count overflow"))?;
-    if format_drive_count == 1 && format_count > 1 {
-        return Err(Error::UnsupportedSnsdExpansion {
-            configured_drives: format_count,
-        });
+    if format_count != format_drive_count {
+        return Err(Error::other(format!(
+            "formats length for erasure.sets does not match: got {format_count}, expected {format_drive_count}"
+        )));
     }
-    if format_count != format_drive_count || set_drive_count_in_format != set_drive_count {
-        return Err(Error::PoolTopologyMismatch {
-            stored_drives: format_drive_count,
-            stored_set_drive_count: set_drive_count_in_format,
-            configured_drives: format_count,
-            configured_set_drive_count: set_drive_count,
-        });
+    if set_drive_count_in_format != set_drive_count {
+        return Err(Error::other(format!(
+            "erasure set length for set_drive_count does not match: got {set_drive_count_in_format}, expected {set_drive_count}"
+        )));
     }
     Ok(())
 }
@@ -895,10 +877,6 @@ mod tests {
     use serial_test::serial;
 
     async fn local_disks(count: usize) -> (tempfile::TempDir, Vec<Option<DiskStore>>) {
-        local_disks_with_set_width(count, count).await
-    }
-
-    async fn local_disks_with_set_width(count: usize, set_width: usize) -> (tempfile::TempDir, Vec<Option<DiskStore>>) {
         let temp_dir = tempfile::tempdir().expect("temporary disk root should be created");
         let mut endpoints = Vec::with_capacity(count);
         for disk_index in 0..count {
@@ -909,8 +887,8 @@ mod tests {
             let mut endpoint =
                 Endpoint::try_from(path.to_str().expect("temporary disk path should be UTF-8")).expect("endpoint should parse");
             endpoint.set_pool_index(0);
-            endpoint.set_set_index(disk_index / set_width);
-            endpoint.set_disk_index(disk_index % set_width);
+            endpoint.set_set_index(0);
+            endpoint.set_disk_index(disk_index);
             endpoints.push(endpoint);
         }
 
@@ -934,21 +912,6 @@ mod tests {
         (temp_dir, disks)
     }
 
-    async fn format_bytes(disks: &[Option<DiskStore>]) -> Vec<Option<Vec<u8>>> {
-        let mut snapshots = Vec::with_capacity(disks.len());
-        for disk in disks {
-            let disk = disk.as_ref().expect("snapshot disk should exist");
-            // Inspect bytes even when the disk wrapper rejects a format whose
-            // stored slot differs from the attempted new endpoint geometry.
-            match tokio::fs::read(disk.path().join(RUSTFS_META_BUCKET).join(FORMAT_CONFIG_FILE)).await {
-                Ok(data) => snapshots.push(Some(data)),
-                Err(err) if err.kind() == std::io::ErrorKind::NotFound => snapshots.push(None),
-                Err(err) => panic!("format snapshot failed: {err}"),
-            }
-        }
-        snapshots
-    }
-
     async fn write_legacy_format(disk: &Option<DiskStore>, format: &FormatV3) {
         write_legacy_bytes(disk, bytes::Bytes::from(format.to_json().expect("legacy format should serialize"))).await;
     }
@@ -1153,212 +1116,6 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn single_drive_format_rejects_in_place_expansion_without_writes() {
-        for configured_drives in [2, 4] {
-            for first_disk in [false, true] {
-                let (_temp_dir, mut disks) = local_disks(configured_drives).await;
-                let mut original = FormatV3::new(1, 1);
-                original.erasure.this = original.erasure.sets[0][0];
-                save_format_file(&disks[0], &Some(original))
-                    .await
-                    .expect("SNSD format should be written");
-                let before = format_bytes(&disks).await;
-
-                let err = connect_load_init_formats(first_disk, &mut disks, 1, configured_drives, None)
-                    .await
-                    .expect_err("an existing SNSD deployment cannot expand in place");
-                let message = err.to_string();
-                assert!(message.contains("SNSD"), "expected a single-drive expansion error: {message}");
-                assert!(message.contains("migrate data through S3"), "expected actionable guidance: {message}");
-                assert_eq!(format_bytes(&disks).await, before, "neither old nor new formats may be written");
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn existing_pool_rejects_drive_count_or_set_width_changes_without_writes() {
-        for (stored_sets, stored_width, configured_sets, configured_width) in
-            [(1, 4, 1, 6), (1, 4, 1, 8), (1, 4, 1, 2), (1, 4, 2, 2), (2, 2, 1, 4)]
-        {
-            for first_disk in [false, true] {
-                let (_temp_dir, mut disks) =
-                    local_disks_with_set_width(configured_sets * configured_width, configured_width).await;
-                let original = FormatV3::new(stored_sets, stored_width);
-                for (disk, disk_id) in disks.iter().zip(original.erasure.sets.iter().flatten()) {
-                    let mut format = original.clone();
-                    format.erasure.this = *disk_id;
-                    save_format_file(disk, &Some(format))
-                        .await
-                        .expect("existing format should be written");
-                }
-                let before = format_bytes(&disks).await;
-
-                let err = connect_load_init_formats(first_disk, &mut disks, configured_sets, configured_width, None)
-                    .await
-                    .expect_err("an existing pool's geometry is immutable");
-                let message = err.to_string();
-                assert!(message.contains("pool topology mismatch"), "expected a topology error: {message}");
-                assert!(
-                    message.contains(&format!("stored 4 drives with {stored_width} drives per erasure set")),
-                    "expected stored geometry: {message}"
-                );
-                assert!(message.contains("append a new pool"), "expected expansion guidance: {message}");
-                assert_eq!(format_bytes(&disks).await, before, "rejection must not rewrite any format");
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn subquorum_existing_layout_with_missing_drives_is_not_expansion() {
-        let (_temp_dir, mut disks) = local_disks(1).await;
-        let mut original = FormatV3::new(1, 4);
-        original.erasure.this = original.erasure.sets[0][0];
-        save_format_file(&disks[0], &Some(original))
-            .await
-            .expect("existing format should be written");
-        disks.extend([None, None, None]);
-
-        for first_disk in [false, true] {
-            assert!(matches!(
-                connect_load_init_formats(first_disk, &mut disks, 1, 4, None).await,
-                Err(Error::ErasureReadQuorum)
-            ));
-        }
-    }
-
-    #[tokio::test]
-    async fn conflicting_layouts_without_quorum_are_not_expansion_proof() {
-        let (_temp_dir, mut disks) = local_disks(2).await;
-        for (index, (disk, width)) in disks.iter().zip([4, 2]).enumerate() {
-            let mut format = FormatV3::new(1, width);
-            format.erasure.this = format.erasure.sets[0][index];
-            save_format_file(disk, &Some(format))
-                .await
-                .expect("existing format should be written");
-        }
-        disks.extend([None, None]);
-
-        let result = connect_load_init_formats(true, &mut disks, 1, 4, None).await;
-        assert!(matches!(result, Err(Error::ErasureReadQuorum)), "conflicting layout result: {result:?}");
-    }
-
-    #[tokio::test]
-    async fn existing_format_quorum_ignores_single_drive_outlier() {
-        let (_temp_dir, mut disks) = local_disks(3).await;
-        let majority = FormatV3::new(1, 3);
-        for (index, disk) in disks.iter().enumerate() {
-            // Slot zero lets the SNSD outlier pass the disk wrapper's own
-            // slot check, so quorum selection must exclude the parsed format.
-            let mut format = if index == 0 { FormatV3::new(1, 1) } else { majority.clone() };
-            format.erasure.this = format.erasure.sets[0][index];
-            save_format_file(disk, &Some(format))
-                .await
-                .expect("existing format should be written");
-        }
-
-        let loaded = connect_load_init_formats(true, &mut disks, 1, 3, None)
-            .await
-            .expect("a foreign SNSD outlier must not block a healthy majority");
-        assert_eq!(loaded.shared_identity(), majority.shared_identity());
-        assert!(disks[0].is_none(), "the foreign single-drive format must be quarantined");
-    }
-
-    #[tokio::test]
-    async fn multi_drive_pool_expansion_preserves_existing_format() {
-        let (_original_dir, mut disks) = local_disks(4).await;
-        let (_new_dir, mut new_disks) = local_disks(4).await;
-        let original = connect_load_init_formats(true, &mut disks, 1, 4, None)
-            .await
-            .expect("original multi-drive pool should initialize");
-        let before = format_bytes(&disks).await;
-
-        let added = connect_load_init_formats(true, &mut new_disks, 1, 4, Some(original.id))
-            .await
-            .expect("a new multi-drive pool should initialize with the existing deployment ID");
-        assert_eq!(added.id, original.id);
-        assert_ne!(added.erasure.sets, original.erasure.sets);
-        assert_eq!(format_bytes(&disks).await, before);
-        assert_eq!(
-            connect_load_init_formats(true, &mut disks, 1, 4, Some(original.id))
-                .await
-                .expect("the original pool should restart with unchanged geometry"),
-            original
-        );
-        assert_eq!(
-            connect_load_init_formats(true, &mut new_disks, 1, 4, Some(original.id))
-                .await
-                .expect("the new pool should restart with its own format"),
-            added
-        );
-    }
-
-    #[tokio::test]
-    async fn store_startup_rejects_pool_resize_before_retry_loop() {
-        use crate::layout::endpoints::{EndpointServerPools, PoolEndpoints};
-        use tokio_util::sync::CancellationToken;
-
-        for (stored_width, configured_width) in [(1, 4), (4, 8)] {
-            let (_temp_dir, disks) = local_disks(configured_width).await;
-            let original = FormatV3::new(1, stored_width);
-            for (disk, disk_id) in disks.iter().zip(&original.erasure.sets[0]) {
-                let mut format = original.clone();
-                format.erasure.this = *disk_id;
-                save_format_file(disk, &Some(format))
-                    .await
-                    .expect("old format should be written");
-            }
-            let before = format_bytes(&disks).await;
-            let endpoints = disks.iter().flatten().map(|disk| disk.endpoint()).collect::<Vec<_>>();
-            let pools = EndpointServerPools::from(vec![PoolEndpoints {
-                legacy: true,
-                set_count: 1,
-                drives_per_set: configured_width,
-                endpoints: Endpoints::from(endpoints),
-                cmd_line: "test-pool".to_string(),
-                platform: String::new(),
-            }]);
-            let shutdown = CancellationToken::new();
-            let result = temp_env::async_with_vars(
-                [
-                    (storageclass::STANDARD_ENV, None::<&str>),
-                    (storageclass::RRS_ENV, None::<&str>),
-                    (storageclass::OPTIMIZE_ENV, None::<&str>),
-                    (storageclass::INLINE_BLOCK_ENV, None::<&str>),
-                ],
-                tokio::time::timeout(
-                    std::time::Duration::from_secs(5),
-                    crate::store::ECStore::new_with_instance_ctx(
-                        "127.0.0.1:0".parse().expect("test address"),
-                        pools,
-                        shutdown.clone(),
-                        Arc::new(InstanceContext::new()),
-                    ),
-                ),
-            )
-            .await;
-            shutdown.cancel();
-            let err = result
-                .expect("invalid topology must abort without the format retry backoff")
-                .expect_err("resize must fail");
-            match stored_width {
-                1 => assert!(matches!(err, Error::UnsupportedSnsdExpansion { configured_drives: 4 }), "{err}"),
-                _ => assert!(
-                    matches!(
-                        err,
-                        Error::PoolTopologyMismatch {
-                            stored_drives: 4,
-                            configured_drives: 8,
-                            ..
-                        }
-                    ),
-                    "{err}"
-                ),
-            }
-            assert_eq!(format_bytes(&disks).await, before, "failed store startup must not write formats");
-        }
-    }
-
     #[tokio::test]
     async fn existing_format_load_rejects_conflicting_formats_without_a_majority() {
         let (_temp_dir, mut disks) = two_local_disks_with_missing_third().await;

crates/ecstore/src/store/mod.rs

@@ -442,7 +442,7 @@ pub(crate) mod utils;
 
 use peer::init_local_peer;
 pub use peer::{
-    BootstrapLocalTarget, all_local_disk, all_local_disk_path, find_local_disk_by_ref, get_disk_infos, init_local_disks,
+    all_local_disk, all_local_disk_path, find_local_disk_by_ref, get_disk_infos, init_local_disks,
     init_local_disks_with_instance_ctx, init_lock_clients, prewarm_local_disk_id_map,
     prewarm_local_disk_id_map_with_instance_ctx,
 };
@@ -527,39 +527,6 @@ impl Default for ScannerDataMovementPauseStatus {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
-pub struct PoolMetaWriteGateStatus {
-    pub writes_ready: bool,
-    pub check_timed_out: bool,
-    pub write_blocked: bool,
-    pub transaction_aborted: bool,
-    pub pool_meta_absent: bool,
-    pub identity_initialized: Option<bool>,
-    pub identity_needs_repair: bool,
-    pub cluster_epoch: Option<u64>,
-    pub reason: Option<&'static str>,
-    pub phase: Option<&'static str>,
-    pub since_unix_secs: Option<i64>,
-}
-
-impl Default for PoolMetaWriteGateStatus {
-    fn default() -> Self {
-        Self {
-            writes_ready: true,
-            check_timed_out: false,
-            write_blocked: false,
-            transaction_aborted: false,
-            pool_meta_absent: false,
-            identity_initialized: None,
-            identity_needs_repair: false,
-            cluster_epoch: None,
-            reason: None,
-            phase: None,
-            since_unix_secs: None,
-        }
-    }
-}
-
 fn offset_unix_seconds(value: OffsetDateTime) -> u64 {
     u64::try_from(value.unix_timestamp()).unwrap_or(0)
 }
@@ -1097,15 +1064,11 @@ impl ECStore {
             return Err(Error::other("scanner publication lease TTL is not supported"));
         }
 
-        // Bind the original activity generation across the asynchronous checks;
-        // a completed namespace commit must never refresh an existing proof.
-        let namespace_generation = self.scanner_namespace_mutation_generation();
         let operation_gate = self.ctx.data_movement_operation_gate();
         let operation_guard = operation_gate.read_owned().await;
         if self.ctx.data_movement_generation_exhausted()
             || self.ctx.data_movement_operation_epoch_exhausted()
             || self.ctx.data_movement_generation() != expected_generation
-            || namespace_generation == u64::MAX
         {
             return Err(Error::other("scanner publication lease generation is stale"));
         }
@@ -1113,15 +1076,11 @@ impl ECStore {
             return Err(Error::other("scanner publication lease is blocked by data movement"));
         }
 
-        if self.scanner_namespace_mutation_generation() != namespace_generation {
-            return Err(Error::other("scanner publication lease generation is stale"));
-        }
-
         let token = Uuid::new_v4();
         let expires_at = tokio::time::Instant::now() + ttl;
         if !self
             .ctx
-            .install_scanner_publication_lease(token, expires_at, expected_generation, namespace_generation, operation_guard)
+            .install_scanner_publication_lease(token, expires_at, expected_generation, operation_guard)
             .await
         {
             return Err(Error::other("scanner publication lease capacity is exhausted"));
@@ -1155,16 +1114,8 @@ impl ECStore {
         if self.scanner_data_movement_snapshot_locked().await.1 || self.ctx.namespace_commits_pending() {
             return Err(Error::other("scanner publication lease is blocked by data movement"));
         }
-        let Some((lease_generation, lease_namespace_generation)) = self.ctx.scanner_publication_lease_generations(token).await
-        else {
+        if !self.ctx.scanner_publication_lease_is_active(token).await {
             return Err(Error::other("scanner publication lease is unknown or expired"));
-        };
-        let namespace_generation = self.scanner_namespace_mutation_generation();
-        if lease_generation != self.ctx.data_movement_generation()
-            || lease_namespace_generation != namespace_generation
-            || namespace_generation == u64::MAX
-        {
-            return Err(Error::other("scanner publication lease generation is stale"));
         }
         Ok(())
     }
@@ -1183,15 +1134,10 @@ impl ECStore {
         if self.scanner_data_movement_snapshot_locked().await.1 || self.ctx.namespace_commits_pending() {
             return Err(Error::other("scanner publication lease is blocked by data movement"));
         }
-        let Some((lease_generation, lease_namespace_generation)) = self.ctx.scanner_publication_lease_generations(token).await
-        else {
+        let Some(lease_generation) = self.ctx.scanner_publication_lease_generation(token).await else {
             return Err(Error::other("scanner publication lease is unknown or expired"));
         };
-        let namespace_generation = self.scanner_namespace_mutation_generation();
-        if lease_generation != self.ctx.data_movement_generation()
-            || lease_namespace_generation != namespace_generation
-            || namespace_generation == u64::MAX
-        {
+        if lease_generation != self.ctx.data_movement_generation() {
             return Err(Error::other("scanner publication lease generation is stale"));
         }
         Ok(operation_guard)
@@ -1841,7 +1787,7 @@ mod tests {
 
     // Build a minimal ECStore carrying an explicit instance context. Empty
     // pools/disks are sufficient: the Phase 5 accessors read only `self.ctx`.
-    pub(super) fn build_store_with_ctx(ctx: Arc<InstanceContext>) -> Arc<ECStore> {
+    fn build_store_with_ctx(ctx: Arc<InstanceContext>) -> Arc<ECStore> {
         let endpoint_pools = EndpointServerPools::default();
         Arc::new(ECStore {
             id: uuid::Uuid::new_v4(),
@@ -2585,88 +2531,6 @@ mod tests {
         assert!(error.to_string().contains("generation is stale"));
     }
 
-    #[tokio::test]
-    async fn scanner_publication_lease_rejects_namespace_change_during_admission() {
-        let ctx = Arc::new(InstanceContext::new());
-        let store = build_store_with_ctx(ctx.clone());
-        let snapshot_blocker = store.rebalance_meta.write().await;
-        let mut acquire =
-            Box::pin(store.acquire_scanner_publication_lease(0, crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL));
-        assert!(futures::poll!(&mut acquire).is_pending(), "acquisition reaches the blocked snapshot");
-        assert!(ctx.data_movement_operation_gate().try_write_owned().is_err());
-        drop(ctx.begin_namespace_commit());
-        assert_eq!(ctx.namespace_commit_generation(), 2);
-        assert!(!ctx.namespace_commits_pending());
-        drop(snapshot_blocker);
-        let error = tokio::time::timeout(Duration::from_secs(1), acquire)
-            .await
-            .expect("snapshot admission must finish")
-            .expect_err("acquisition must preserve its original namespace generation");
-        assert_eq!(error.to_string(), "Io error: scanner publication lease generation is stale");
-        assert!(ctx.data_movement_operation_gate().try_write_owned().is_ok(), "no lease was installed");
-    }
-
-    #[tokio::test]
-    async fn scanner_publication_lease_rechecks_namespace_after_validate_snapshot() {
-        let ctx = Arc::new(InstanceContext::new());
-        let store = build_store_with_ctx(ctx.clone());
-        let (token, generation) = store
-            .acquire_scanner_publication_lease(0, crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL)
-            .await
-            .expect("current lease");
-        let snapshot_blocker = store.rebalance_meta.write().await;
-        let mut validate = Box::pin(store.validate_scanner_publication_lease(token, generation));
-        assert!(futures::poll!(&mut validate).is_pending(), "target guard queues its first snapshot read");
-        let mut next_writer = Box::pin(store.rebalance_meta.write());
-        assert!(futures::poll!(&mut next_writer).is_pending());
-        drop(snapshot_blocker);
-        // Fair lock order admits the first read, then this queued writer, then
-        // validate's second snapshot. The first target check has already passed.
-        assert!(futures::poll!(&mut validate).is_pending(), "validate reaches its second snapshot");
-        let next_writer = next_writer.await;
-        drop(ctx.begin_namespace_commit());
-        assert_eq!(ctx.namespace_commit_generation(), 2);
-        assert!(!ctx.namespace_commits_pending());
-        drop(next_writer);
-        let error = tokio::time::timeout(Duration::from_secs(1), validate)
-            .await
-            .expect("validation must finish without nesting movement read locks")
-            .expect_err("the final snapshot must reject a completed namespace commit");
-        assert_eq!(error.to_string(), "Io error: scanner publication lease generation is stale");
-        assert!(
-            ctx.data_movement_operation_gate().try_write_owned().is_err(),
-            "stale lookup retains the lease permit"
-        );
-        assert!(store.release_scanner_publication_lease(token).await);
-        assert!(ctx.data_movement_operation_gate().try_write_owned().is_ok());
-    }
-
-    #[tokio::test]
-    async fn scanner_publication_lease_rejects_namespace_generation_exhaustion() {
-        let ctx = Arc::new(InstanceContext::new());
-        let store = build_store_with_ctx(ctx.clone());
-        let (token, generation) = store
-            .acquire_scanner_publication_lease(0, crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL)
-            .await
-            .expect("current lease");
-        ctx.set_namespace_commit_generation_for_test(u64::MAX);
-        assert_eq!(store.scanner_namespace_mutation_generation(), u64::MAX);
-        let acquire = store
-            .acquire_scanner_publication_lease(generation, crate::runtime::instance::SCANNER_PUBLICATION_LEASE_TTL)
-            .await
-            .expect_err("exhausted namespace cannot become a new lease baseline");
-        assert_eq!(acquire.to_string(), "Io error: scanner publication lease generation is stale");
-        let validate = store.validate_scanner_publication_lease(token, generation).await;
-        let target = store.acquire_scanner_publication_lease_guard(token).await;
-        assert!(validate.is_err() && target.is_err(), "exhaustion rejects both old-token entrances");
-        assert!(
-            ctx.data_movement_operation_gate().try_write_owned().is_err(),
-            "rejection must retain the old permit"
-        );
-        assert!(store.release_scanner_publication_lease(token).await);
-        assert!(ctx.data_movement_operation_gate().try_write_owned().is_ok());
-    }
-
     #[tokio::test(start_paused = true)]
     async fn scanner_publication_commit_scope_owns_permit_until_terminal_drain() {
         let store = build_store_with_ctx(Arc::new(InstanceContext::new()));

crates/ecstore/src/store/multipart.rs

@@ -526,8 +526,12 @@ impl ECStore {
         if self.single_pool() {
             self.apply_decommission_target_mutation_fence(0, object, &mut opts, mutation_fence)
                 .await;
-            let result = self.pools[0].new_multipart_upload(bucket, object, &opts).await?;
-            return Ok((result, 0, opts.expected_bucket_incarnation_id));
+            return self
+                .run_decommission_capacity_admitted_mutation(0, None, None, || async {
+                    self.pools[0].new_multipart_upload(bucket, object, &opts).await
+                })
+                .await
+                .map(|res| (res, 0, opts.expected_bucket_incarnation_id));
         }
 
         if opts.data_movement && opts.version_id.is_some() {
@@ -654,9 +658,7 @@ impl ECStore {
     ) -> Result<PartInfo> {
         check_put_object_part_args(bucket, object, upload_id)?;
         let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
-        if !self.single_pool() {
-            opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
-        }
+        opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
         let opts = &opts;
 
         if self.single_pool() {
@@ -980,9 +982,7 @@ impl ECStore {
     ) -> Result<ObjectInfo> {
         check_complete_multipart_args(bucket, object, upload_id)?;
         let (mut opts, _bucket_lifecycle_guard) = self.guard_multipart_bucket_incarnation(bucket, opts).await?;
-        if !self.single_pool() {
-            opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
-        }
+        opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
         let opts = &opts;
 
         if self.single_pool() {

crates/ecstore/src/store/object.rs

@@ -3123,9 +3123,6 @@ impl ECStore {
         Fut: std::future::Future<Output = Result<T>>,
     {
         let (lock_object, target_object) = objects;
-        if self.single_pool() {
-            return operation(opts).await;
-        }
         let (capacity_guard, has_active_decommission) = if capacity_releasing {
             self.acquire_decommission_capacity_release_fence_with_active_source().await?
         } else {
@@ -3223,9 +3220,6 @@ impl ECStore {
         F: FnOnce(HealOpts) -> Fut,
         Fut: std::future::Future<Output = Result<T>>,
     {
-        if self.single_pool() {
-            return operation(opts).await;
-        }
         let (capacity_guard, has_active_decommission) = self
             .acquire_external_decommission_capacity_fence_with_active_source(&[target_pool_idx], "heal")
             .await?;
@@ -4168,9 +4162,7 @@ impl ECStore {
             .select_put_object_pool_idx(bucket, object.as_str(), data.size(), &opts)
             .await?;
         let mut opts = opts;
-        if !self.single_pool() {
-            opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
-        }
+        opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
         self.pools[idx]
             .put_object_with_old_current_size(bucket, object.as_str(), data, &opts)
             .await
@@ -4178,24 +4170,6 @@ impl ECStore {
 
     #[instrument(level = "trace", skip(self))]
     pub(super) async fn handle_get_object_info(&self, bucket: &str, object: &str, opts: &ObjectOptions) -> Result<ObjectInfo> {
-        self.get_object_info_snapshot(bucket, object, opts, false).await
-    }
-
-    /// Return metadata for DELETE preflight, including an explicitly addressed
-    /// delete marker. Read APIs must keep using `get_object_info`; authorization
-    /// and Object Lock enforcement still belong to the caller and locked delete.
-    #[instrument(level = "trace", skip_all)]
-    pub async fn get_object_info_for_delete(&self, bucket: &str, object: &str, opts: &ObjectOptions) -> Result<ObjectInfo> {
-        self.get_object_info_snapshot(bucket, object, opts, true).await
-    }
-
-    async fn get_object_info_snapshot(
-        &self,
-        bucket: &str,
-        object: &str,
-        opts: &ObjectOptions,
-        allow_delete_marker: bool,
-    ) -> Result<ObjectInfo> {
         check_object_args(bucket, object)?;
 
         let object = encode_dir_object(object);
@@ -4206,8 +4180,6 @@ impl ECStore {
 
         let info = if self.single_pool() {
             self.pools[0].get_object_info(bucket, object.as_str(), &opts).await?
-        } else if allow_delete_marker {
-            self.get_latest_object_info_with_idx(bucket, object.as_str(), &opts).await?.0
         } else {
             self.get_latest_accessible_object_info_with_idx(bucket, object.as_str(), &opts)
                 .await?
@@ -4368,10 +4340,8 @@ impl ECStore {
                     object_lock_config_snapshot: dst_opts.object_lock_config_snapshot.clone(),
                     ..Default::default()
                 };
-                if !self.single_pool() {
-                    put_opts.decommission_capacity_admission =
-                        crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
-                }
+                put_opts.decommission_capacity_admission =
+                    crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
                 return if let Some(reader) = src_info.put_object_reader.as_mut() {
                     self.pools[pool_idx]
                         .put_object(dst_bucket, &dst_object, reader, &put_opts)
@@ -4406,10 +4376,8 @@ impl ECStore {
                         object_lock_config_snapshot: dst_opts.object_lock_config_snapshot.clone(),
                         ..Default::default()
                     };
-                    if !self.single_pool() {
-                        put_opts.decommission_capacity_admission =
-                            crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
-                    }
+                    put_opts.decommission_capacity_admission =
+                        crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
                     return self.pools[pool_idx]
                         .put_object(dst_bucket, &dst_object, reader, &put_opts)
                         .await;
@@ -4454,10 +4422,7 @@ impl ECStore {
             object_lock_config_snapshot: dst_opts.object_lock_config_snapshot.clone(),
             ..Default::default()
         };
-        if !self.single_pool() {
-            put_opts.decommission_capacity_admission =
-                crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
-        }
+        put_opts.decommission_capacity_admission = crate::bucket::metadata_sys::object_store_if_initialized_in(&self.ctx).await;
 
         if let Some(put_object_reader) = src_info.put_object_reader.as_mut() {
             return self.pools[pool_idx]
@@ -5092,7 +5057,7 @@ impl ECStore {
             }
         }
 
-        let _capacity_fence = if !self.single_pool() && latest_marker_objects.iter().any(|creates_marker| *creates_marker) {
+        let _capacity_fence = if latest_marker_objects.iter().any(|creates_marker| *creates_marker) {
             let target_pool_indices = (0..self.pools.len()).collect::<Vec<_>>();
             match self
                 .acquire_external_decommission_capacity_fence(&target_pool_indices, "batch_delete")
@@ -5410,6 +5375,7 @@ impl ECStore {
         // self-deadlocked on the inner commits.
         let object_name = object.as_str();
         if self.single_pool() {
+            opts.decommission_capacity_admission = Some(Arc::clone(&self));
             return self.pools[0]
                 .clone()
                 .restore_transitioned_object(bucket, object_name, &opts)

crates/ecstore/src/store/rebalance.rs

@@ -1146,11 +1146,7 @@ impl ECStore {
         }
 
         let backend = StorageAdminApi::backend_info(self).await;
-        rustfs_madmin::StorageInfo {
-            backend,
-            disks,
-            ..Default::default()
-        }
+        rustfs_madmin::StorageInfo { backend, disks }
     }
 
     #[instrument(skip(self))]

crates/filemeta/Cargo.toml

@@ -44,7 +44,6 @@ tokio = { workspace = true, features = ["io-util", "macros", "sync", "fs", "rt-m
 xxhash-rust = { workspace = true, features = ["xxh64", "xxh3"] }
 bytes = { workspace = true, features = ["serde"] }
 rustfs-utils = { workspace = true, features = ["hash", "http"] }
-rustfs-config = { workspace = true, features = ["constants"] }
 byteorder = { workspace = true }
 tracing.workspace = true
 thiserror.workspace = true

crates/filemeta/src/error.rs

@@ -37,9 +37,6 @@ pub enum Error {
     #[error("Method not allowed")]
     MethodNotAllowed,
 
-    #[error("You've exceeded the limit on the number of versions you can create on this object")]
-    MaxVersionsExceeded,
-
     #[error("Unexpected error")]
     Unexpected,
 
@@ -89,7 +86,6 @@ impl PartialEq for Error {
             (Error::FileCorrupt, Error::FileCorrupt) => true,
             (Error::DoneForNow, Error::DoneForNow) => true,
             (Error::MethodNotAllowed, Error::MethodNotAllowed) => true,
-            (Error::MaxVersionsExceeded, Error::MaxVersionsExceeded) => true,
             (Error::FileNotFound, Error::FileNotFound) => true,
             (Error::FileVersionNotFound, Error::FileVersionNotFound) => true,
             (Error::VolumeNotFound, Error::VolumeNotFound) => true,
@@ -115,7 +111,6 @@ impl Clone for Error {
             Error::FileCorrupt => Error::FileCorrupt,
             Error::DoneForNow => Error::DoneForNow,
             Error::MethodNotAllowed => Error::MethodNotAllowed,
-            Error::MaxVersionsExceeded => Error::MaxVersionsExceeded,
             Error::VolumeNotFound => Error::VolumeNotFound,
             Error::Io(e) => Error::Io(std::io::Error::new(e.kind(), e.to_string())),
             Error::RmpSerdeDecode(s) => Error::RmpSerdeDecode(s.clone()),

crates/filemeta/src/filemeta.rs

@@ -34,14 +34,11 @@ use rustfs_utils::http::{
 };
 use s3s::header::X_AMZ_RESTORE;
 use serde::{Deserialize, Serialize};
-#[cfg(test)]
-use std::cell::Cell;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
 use std::hash::Hasher;
 use std::io::{Read, Write};
-use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 use std::{collections::HashMap, io::Cursor};
 use time::OffsetDateTime;
 use time::format_description::well_known::Rfc3339;
@@ -70,42 +67,8 @@ const _XL_FLAG_INLINE_DATA: u8 = 1 << 2;
 const META_DATA_READ_DEFAULT: usize = 4 << 10;
 const MSGP_UINT32_SIZE: usize = 5;
 
-/// Default max object versions per object.
-pub const DEFAULT_OBJECT_MAX_VERSIONS: usize = rustfs_config::DEFAULT_API_OBJECT_MAX_VERSIONS;
-
-static OBJECT_MAX_VERSIONS: AtomicUsize = AtomicUsize::new(DEFAULT_OBJECT_MAX_VERSIONS);
-
-#[cfg(test)]
-thread_local! {
-    static OBJECT_MAX_VERSIONS_OVERRIDE: Cell<Option<usize>> = const { Cell::new(None) };
-}
-
-#[inline]
-pub fn object_max_versions() -> usize {
-    #[cfg(test)]
-    if let Some(limit) = OBJECT_MAX_VERSIONS_OVERRIDE.with(Cell::get) {
-        return limit;
-    }
-
-    OBJECT_MAX_VERSIONS.load(AtomicOrdering::Relaxed)
-}
-
-pub fn set_object_max_versions(limit: usize) -> Result<()> {
-    if limit == 0 {
-        return Err(Error::other("object max versions must be greater than 0"));
-    }
-    OBJECT_MAX_VERSIONS.store(limit, AtomicOrdering::Relaxed);
-    Ok(())
-}
-
-#[cfg(test)]
-fn set_object_max_versions_override_for_test(limit: Option<usize>) -> Option<usize> {
-    OBJECT_MAX_VERSIONS_OVERRIDE.with(|override_limit| {
-        let previous = override_limit.get();
-        override_limit.set(limit);
-        previous
-    })
-}
+/// Max object versions per object, default is 10000
+const DEFAULT_OBJECT_MAX_VERSIONS: usize = 10000;
 
 /// Returns the inline data map key for a version_id. "null" for null version.
 pub(crate) fn data_key_for_version(version_id: Option<Uuid>) -> String {
@@ -497,6 +460,18 @@ impl FileMeta {
             return Err(Error::other("file meta version invalid"));
         }
 
+        // check max versions limit
+        if self.versions.len() + 1 > DEFAULT_OBJECT_MAX_VERSIONS {
+            return Err(Error::other(
+                "You've exceeded the limit on the number of versions you can create on this object",
+            ));
+        }
+
+        if self.versions.is_empty() {
+            self.versions.push(FileMetaShallowVersion::try_from(version)?);
+            return Ok(());
+        }
+
         let vid = version.get_version_id();
         let vid_is_null = vid.is_none() || vid == Some(Uuid::nil());
         let existing_idx = if vid_is_null {
@@ -515,15 +490,6 @@ impl FileMeta {
             return self.set_idx(fidx, version);
         }
 
-        if self.versions.len() >= object_max_versions() {
-            return Err(Error::MaxVersionsExceeded);
-        }
-
-        if self.versions.is_empty() {
-            self.versions.push(FileMetaShallowVersion::try_from(version)?);
-            return Ok(());
-        }
-
         let new_shallow = FileMetaShallowVersion::try_from(version)?;
         let insert_pos = self
             .versions
@@ -1364,88 +1330,6 @@ mod test {
         }
     }
 
-    struct ObjectMaxVersionsRestore {
-        previous: Option<usize>,
-    }
-
-    impl Drop for ObjectMaxVersionsRestore {
-        fn drop(&mut self) {
-            set_object_max_versions_override_for_test(self.previous);
-        }
-    }
-
-    fn with_object_max_versions_for_test<R>(limit: usize, test: impl FnOnce() -> R) -> R {
-        let previous = set_object_max_versions_override_for_test(Some(limit));
-        let _restore = ObjectMaxVersionsRestore { previous };
-        test()
-    }
-
-    #[test]
-    fn add_version_filemata_rejects_new_version_above_configured_limit() {
-        with_object_max_versions_for_test(2, || {
-            let mut fm = FileMeta::new();
-            fm.add_version_filemata(valid_object_version(Uuid::from_u128(1), vec![10, 20]))
-                .expect("add first version within limit");
-            fm.add_version_filemata(valid_object_version(Uuid::from_u128(2), vec![10, 20]))
-                .expect("add second version at limit");
-
-            let err = fm
-                .add_version_filemata(valid_object_version(Uuid::from_u128(3), vec![10, 20]))
-                .expect_err("new version above limit must fail");
-
-            assert_eq!(err, Error::MaxVersionsExceeded);
-            assert_eq!(fm.versions.len(), 2, "failed insert must not mutate version list");
-        });
-    }
-
-    #[test]
-    fn add_version_filemata_allows_same_version_replacement_at_limit() {
-        with_object_max_versions_for_test(2, || {
-            let mut fm = FileMeta::new();
-            let target = Uuid::from_u128(10);
-            fm.add_version_filemata(valid_object_version(target, vec![10, 20]))
-                .expect("add target version");
-            fm.add_version_filemata(valid_object_version(Uuid::from_u128(20), vec![10, 20]))
-                .expect("add peer version at limit");
-
-            fm.add_version_filemata(valid_object_version(target, vec![30, 40]))
-                .expect("same version replacement at limit must succeed");
-
-            assert_eq!(fm.versions.len(), 2);
-            let replaced = fm
-                .versions
-                .iter()
-                .find(|version| version.header.version_id == Some(target))
-                .expect("target version must remain present")
-                .parse_version_meta()
-                .expect("parse replaced version");
-            assert_eq!(replaced.object.expect("object version").part_sizes, vec![30, 40]);
-        });
-    }
-
-    #[test]
-    fn add_version_allows_null_version_replacement_at_limit() {
-        with_object_max_versions_for_test(1, || {
-            let mut fm = FileMeta::new();
-            let mut first = FileInfo::new("object", 2, 2);
-            first.mod_time = Some(OffsetDateTime::now_utc());
-            first.version_id = None;
-            fm.add_version(first).expect("add initial null version");
-
-            let mut replacement = FileInfo::new("object", 2, 2);
-            replacement.mod_time = Some(OffsetDateTime::now_utc());
-            replacement.version_id = None;
-            replacement.size = 42;
-            fm.add_version(replacement)
-                .expect("null version replacement at limit must succeed");
-
-            assert_eq!(fm.versions.len(), 1);
-            assert_eq!(fm.versions[0].header.version_id, Some(Uuid::nil()));
-            let replaced = fm.versions[0].parse_version_meta().expect("parse null replacement");
-            assert_eq!(replaced.object.expect("object version").size, 42);
-        });
-    }
-
     #[test]
     fn add_version_filemata_uses_canonical_equal_time_order() {
         let mod_time = OffsetDateTime::from_unix_timestamp(1_700_000_000).expect("valid test timestamp");

crates/heal/src/heal/manager.rs

@@ -20,7 +20,7 @@ use crate::heal::{
     task::{HealOptions, HealPriority, HealRequest, HealTask, HealTaskStatus, HealType, demote_to_debug_when},
 };
 use crate::{Error, Result};
-use metrics::{counter, gauge, histogram};
+use metrics::{counter, gauge};
 use rustfs_concurrency::WorkloadAdmissionSnapshotProvider;
 use rustfs_concurrency::workload::{ForegroundPressure, foreground_pressure};
 #[cfg(test)]
@@ -34,7 +34,7 @@ use std::sync::LazyLock;
 use std::{
     collections::{BinaryHeap, HashMap, HashSet},
     sync::{Arc, Mutex as StdMutex, MutexGuard as StdMutexGuard},
-    time::{Duration, Instant, SystemTime},
+    time::{Duration, SystemTime},
 };
 use tokio::{
     sync::{Mutex, Notify, RwLock},
@@ -181,13 +181,6 @@ fn lock_displaced_terminals(
     }
 }
 
-fn lock_admission_telemetry(registry: &StdMutex<HealAdmissionTelemetry>) -> StdMutexGuard<'_, HealAdmissionTelemetry> {
-    match registry.lock() {
-        Ok(guard) => guard,
-        Err(poisoned) => poisoned.into_inner(),
-    }
-}
-
 fn record_displaced_terminal(
     registry: &StdMutex<HashMap<String, Arc<CompletedHealStatus>>>,
     request: &HealRequest,
@@ -391,61 +384,6 @@ impl HealSourceCounts {
     }
 }
 
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct HealAdmissionTelemetry {
-    pub accepted: u64,
-    pub merged: u64,
-    pub full: u64,
-    pub dropped: u64,
-    pub duplicate: u64,
-    pub overlap_rejected: u64,
-    pub displaced: u64,
-    pub force_start: u64,
-    pub max_start_duration_micros: u64,
-    pub max_lock_phase_micros: u64,
-}
-
-impl HealAdmissionTelemetry {
-    fn record(&mut self, observation: HealAdmissionObservation) {
-        match observation.result {
-            HealAdmissionResult::Accepted => self.accepted = self.accepted.saturating_add(1),
-            HealAdmissionResult::Merged => self.merged = self.merged.saturating_add(1),
-            HealAdmissionResult::Full => self.full = self.full.saturating_add(1),
-            HealAdmissionResult::Dropped(_) => self.dropped = self.dropped.saturating_add(1),
-        }
-        if observation.context == "duplicate" {
-            self.duplicate = self.duplicate.saturating_add(1);
-        }
-        if observation.context == "overlap_rejected" {
-            self.overlap_rejected = self.overlap_rejected.saturating_add(1);
-        }
-        if observation.displaced {
-            self.displaced = self.displaced.saturating_add(1);
-        }
-        if observation.force_start {
-            self.force_start = self.force_start.saturating_add(1);
-        }
-        self.max_start_duration_micros = self
-            .max_start_duration_micros
-            .max(duration_micros_saturated(observation.start_duration));
-        self.max_lock_phase_micros = self
-            .max_lock_phase_micros
-            .max(duration_micros_saturated(observation.lock_phase));
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-struct HealAdmissionObservation {
-    source: HealRequestSource,
-    result: HealAdmissionResult,
-    context: &'static str,
-    force_start: bool,
-    displaced: bool,
-    start_duration: Duration,
-    lock_phase: Duration,
-}
-
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct HealOperationsSnapshot {
@@ -458,18 +396,12 @@ pub struct HealOperationsSnapshot {
     pub queued_by_source: HealSourceCounts,
     pub active_by_source: HealSourceCounts,
     pub retrying_by_source: HealSourceCounts,
-    #[serde(default)]
-    pub admission: HealAdmissionTelemetry,
 }
 
 fn usize_to_u64_saturated(value: usize) -> u64 {
     u64::try_from(value).unwrap_or(u64::MAX)
 }
 
-fn duration_micros_saturated(duration: Duration) -> u64 {
-    u64::try_from(duration.as_micros()).unwrap_or(u64::MAX)
-}
-
 fn heal_type_matches_path(heal_type: &HealType, heal_path: &str) -> bool {
     let heal_path = heal_path.trim_matches('/');
     if heal_path.is_empty() || heal_path == LEGACY_ROOT_HEAL_PATH {
@@ -832,9 +764,6 @@ pub struct HealManager {
     notify: Arc<Notify>,
     /// Optional runtime workload snapshot provider used to protect foreground data-plane work.
     workload_provider: Option<WorkloadSnapshotProviderRef>,
-    /// Bounded, low-cardinality admission telemetry exposed through the
-    /// existing operations snapshot for cluster E2E assertions.
-    admission_telemetry: Arc<StdMutex<HealAdmissionTelemetry>>,
 }
 
 /// Where a task-id lookup resolved. The variants carry the resolved state
@@ -990,33 +919,6 @@ impl HealManager {
         .increment(1);
     }
 
-    fn record_admission_observation(&self, observation: HealAdmissionObservation) {
-        let result = observation.result.result_label().to_string();
-        let reason = observation.result.reason_label().to_string();
-        let source = observation.source.as_str().to_string();
-        let context = observation.context.to_string();
-        let force_start = observation.force_start.to_string();
-        histogram!(
-            "rustfs_heal_admission_start_duration_seconds",
-            "source" => source.clone(),
-            "result" => result.clone(),
-            "reason" => reason.clone(),
-            "context" => context.clone(),
-            "force_start" => force_start.clone()
-        )
-        .record(observation.start_duration.as_secs_f64());
-        histogram!(
-            "rustfs_heal_admission_lock_phase_seconds",
-            "source" => source,
-            "result" => result,
-            "reason" => reason,
-            "context" => context,
-            "force_start" => force_start
-        )
-        .record(observation.lock_phase.as_secs_f64());
-        lock_admission_telemetry(&self.admission_telemetry).record(observation);
-    }
-
     fn remove_mrf_repair_notice_targets_for_task(&self, task_id: &str) {
         let targets = lock_mrf_repair_notice_targets(&self.mrf_repair_notice_targets).remove(task_id);
         if let Some(targets) = targets {
@@ -1363,7 +1265,6 @@ impl HealManager {
             statistics: Arc::new(RwLock::new(HealStatistics::new())),
             notify: Arc::new(Notify::new()),
             workload_provider,
-            admission_telemetry: Arc::new(StdMutex::new(HealAdmissionTelemetry::default())),
         }
     }
 
@@ -1554,9 +1455,6 @@ impl HealManager {
         preserve_alias: bool,
         mrf_notice_target: Option<MrfRepairNoticeTarget>,
     ) -> Result<HealAdmissionReceipt> {
-        let admission_start = Instant::now();
-        let source = request.source;
-        let force_start = request.force_start;
         // HS-06 forceStart semantics (admin only): MinIO stops the old task
         // first and then starts the new one. Cancel any active admin task
         // overlapping this request's path before entering admission, so the
@@ -1607,7 +1505,6 @@ impl HealManager {
         // Match the scheduler's active -> queue order and keep retry ownership
         // in the same atomic view. Otherwise queue -> active and
         // active -> retrying transitions can slip between duplicate checks.
-        let lock_phase_start = Instant::now();
         let active_heals = self.active_heals.lock().await;
         #[cfg(test)]
         pause_duplicate_admission_after_active_lock(&request.id).await;
@@ -1642,17 +1539,7 @@ impl HealManager {
             drop(retrying_heals);
             drop(queue);
             drop(active_heals);
-            let lock_phase = lock_phase_start.elapsed();
             Self::record_admission_metric(request.source, admission, "duplicate");
-            self.record_admission_observation(HealAdmissionObservation {
-                source,
-                result: admission,
-                context: "duplicate",
-                force_start,
-                displaced: false,
-                start_duration: admission_start.elapsed(),
-                lock_phase,
-            });
 
             match admission {
                 HealAdmissionResult::Merged => {
@@ -1731,17 +1618,7 @@ impl HealManager {
                 drop(retrying_heals);
                 drop(queue);
                 drop(active_heals);
-                let lock_phase = lock_phase_start.elapsed();
                 Self::record_admission_metric(request.source, HealAdmissionResult::Dropped(reason), "overlap_rejected");
-                self.record_admission_observation(HealAdmissionObservation {
-                    source,
-                    result: HealAdmissionResult::Dropped(reason),
-                    context: "overlap_rejected",
-                    force_start,
-                    displaced: false,
-                    start_duration: admission_start.elapsed(),
-                    lock_phase,
-                });
                 warn!(
                     target: "rustfs::heal::manager",
                     event = EVENT_HEAL_QUEUE_ADMISSION,
@@ -1786,8 +1663,6 @@ impl HealManager {
         drop(retrying_heals);
         drop(queue);
         drop(active_heals);
-        let lock_phase = lock_phase_start.elapsed();
-        let displaced = displaced_terminal.is_some();
 
         if let (Some(displaced_task_id), Some(displaced_terminal)) = (displaced_task_id, displaced_terminal) {
             // The queue has already removed the displaced request, so the
@@ -1801,16 +1676,6 @@ impl HealManager {
             self.notify.notify_one();
         }
 
-        self.record_admission_observation(HealAdmissionObservation {
-            source,
-            result: admission,
-            context: "submit",
-            force_start,
-            displaced,
-            start_duration: admission_start.elapsed(),
-            lock_phase,
-        });
-
         Ok(HealAdmissionReceipt {
             result: admission,
             task_id,
@@ -2246,25 +2111,17 @@ impl HealManager {
         }
         publish_active_heal_count(&active_heals);
         publish_heal_queue_length(&queue);
-        let queue_length = usize_to_u64_saturated(queue.len());
-        let active_tasks = usize_to_u64_saturated(active_heals.len());
-        let retrying_tasks = usize_to_u64_saturated(retrying_heals.len());
-        drop(retrying_heals);
-        drop(queue);
-        drop(active_heals);
-        let admission = *lock_admission_telemetry(&self.admission_telemetry);
 
         HealOperationsSnapshot {
-            queue_length,
-            active_tasks,
-            retrying_tasks,
+            queue_length: usize_to_u64_saturated(queue.len()),
+            active_tasks: usize_to_u64_saturated(active_heals.len()),
+            retrying_tasks: usize_to_u64_saturated(retrying_heals.len()),
             queued_by_priority,
             active_by_priority,
             retrying_by_priority,
             queued_by_source,
             active_by_source,
             retrying_by_source,
-            admission,
         }
     }
 

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

@@ -313,7 +313,6 @@ impl HealManager {
                         completed_status_entry.outcome = Some(Arc::new(task.get_outcome().await));
                     }
                     let terminal_completion = !matches!(completed_status, HealTaskStatus::Retrying { .. });
-                    let completed_status_for_verified_events = completed_status_entry.clone();
                     // Keep retry ownership continuous: status snapshots acquire
                     // these locks in the same active -> retrying order.
                     let mut retrying_heals_guard = if let (Some((request, _, error)), Some(cancel_token)) =
@@ -359,15 +358,6 @@ impl HealManager {
                     tests::pause_completed_retention_handoff(&task_id).await;
 
                     if completed_task.is_some() {
-                        let notice_targets = if terminal_completion {
-                            take_mrf_repair_notice_targets(&mrf_repair_notice_targets_clone, &task_id)
-                        } else {
-                            Vec::new()
-                        };
-                        if terminal_completion {
-                            release_mrf_repair_notice_targets(&notice_targets);
-                        }
-                        publish_verified_mrf_repair_events(&notice_targets, &completed_status_for_verified_events);
                         // update statistics
                         let mut stats = statistics_clone.write().await;
                         match completed_status {
@@ -382,6 +372,14 @@ impl HealManager {
                         }
                         stats.update_running_tasks(usize_to_u64_saturated(active_count));
                         drop(stats);
+                        if terminal_completion {
+                            let notice_targets = take_mrf_repair_notice_targets(&mrf_repair_notice_targets_clone, &task_id);
+                            // Neither task status nor the diagnostic outcome
+                            // window supplies a storage-owned repair receipt.
+                            // Release only the ingress lease for rediscovery;
+                            // preserve the producer's existing retry hints.
+                            release_mrf_repair_notice_targets(notice_targets);
+                        }
                     }
 
                     if let (Some((retry_request, retry_delay, retry_error)), Some(retry_cancel_token)) =
@@ -707,7 +705,7 @@ fn move_mrf_repair_notice_targets(
     }
 }
 
-fn release_mrf_repair_notice_targets(targets: &[MrfRepairNoticeTarget]) {
+fn release_mrf_repair_notice_targets(targets: Vec<MrfRepairNoticeTarget>) {
     for target in targets {
         rustfs_common::mrf_channel::release_mrf_identity(
             target.kind,
@@ -720,73 +718,6 @@ fn release_mrf_repair_notice_targets(targets: &[MrfRepairNoticeTarget]) {
     }
 }
 
-pub(super) fn mrf_verified_repair_event_for_target(
-    target: &MrfRepairNoticeTarget,
-    outcome: &crate::heal::outcome::HealObjectOutcome,
-) -> Option<rustfs_common::mrf_channel::MrfVerifiedRepairEvent> {
-    use crate::heal::outcome::{HealObjectDisposition, HealObjectKind};
-    use rustfs_common::mrf_channel::{MrfKind, MrfVerifiedRepairDisposition};
-
-    let disposition = match outcome.disposition {
-        HealObjectDisposition::Repaired => MrfVerifiedRepairDisposition::Repaired,
-        HealObjectDisposition::VerifiedHealthy => MrfVerifiedRepairDisposition::VerifiedHealthy,
-        HealObjectDisposition::AuthoritativelyAbsent => MrfVerifiedRepairDisposition::AuthoritativelyAbsent,
-        _ => return None,
-    };
-    if target.kind != MrfKind::PartialWrite {
-        return None;
-    }
-    let expected_kind = HealObjectKind::Object;
-    if outcome.identity.kind != expected_kind
-        || outcome.identity.bucket.as_str() != target.bucket.as_ref()
-        || outcome.identity.object.as_str() != target.object.as_ref()
-    {
-        return None;
-    }
-    let version_id = target.version_id.filter(|bytes| *bytes != [0; 16]);
-    let expected_version = version_id.map(|bytes| uuid::Uuid::from_bytes(bytes).to_string());
-    if outcome.identity.version_id != expected_version {
-        return None;
-    }
-    let expected_pool = target.scope.and_then(|scope| usize::try_from(scope.pool_index).ok());
-    let expected_set = target.scope.and_then(|scope| usize::try_from(scope.set_index).ok());
-    if outcome.identity.pool_index != expected_pool || outcome.identity.set_index != expected_set {
-        return None;
-    }
-    let bucket_incarnation_id = outcome.identity.bucket_incarnation_id?;
-    Some(rustfs_common::mrf_channel::MrfVerifiedRepairEvent {
-        kind: target.kind,
-        bucket: target.bucket.clone(),
-        object: target.object.clone(),
-        version_id,
-        scope: target.scope,
-        lease: target.lease,
-        bucket_incarnation_id,
-        disposition,
-    })
-}
-
-pub(super) fn publish_verified_mrf_repair_events(targets: &[MrfRepairNoticeTarget], completed: &CompletedHealStatus) {
-    if completed.status != HealTaskStatus::Completed {
-        return;
-    }
-    let Some(outcome) = completed.outcome.as_ref() else {
-        return;
-    };
-    if outcome.execution != crate::heal::outcome::HealExecutionOutcome::Completed {
-        return;
-    }
-    for target in targets {
-        if let Some(event) = outcome
-            .objects
-            .iter()
-            .find_map(|object| mrf_verified_repair_event_for_target(target, object))
-        {
-            rustfs_common::mrf_channel::note_mrf_verified_repair(event);
-        }
-    }
-}
-
 pub(super) fn heal_request_set_key_for_task(task: &HealTask) -> Option<String> {
     match &task.heal_type {
         HealType::ErasureSet { set_disk_id, .. } => Some(set_disk_id.clone()),

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

@@ -1094,191 +1094,6 @@ fn queued_request_id_for_dedup_key_tracks_the_representative() {
     assert!(queue.queued_request_id_for_dedup_key(&first_key).is_none());
 }
 
-#[test]
-fn mrf_verified_repair_event_requires_positive_exact_identity() {
-    use crate::heal::outcome::{HealObjectIdentity, HealObjectKind, HealObjectOutcome};
-    use rustfs_common::mrf_channel::{MrfKind, MrfScope, MrfVerifiedRepairDisposition};
-
-    let version = uuid::Uuid::new_v4();
-    let incarnation = uuid::Uuid::new_v4();
-    let target = MrfRepairNoticeTarget {
-        bucket: Arc::from("bucket"),
-        object: Arc::from("object"),
-        version_id: Some(*version.as_bytes()),
-        kind: MrfKind::PartialWrite,
-        scope: Some(MrfScope {
-            pool_index: 1,
-            set_index: 2,
-        }),
-        lease: None,
-    };
-    let matching = HealObjectOutcome {
-        identity: HealObjectIdentity {
-            kind: HealObjectKind::Object,
-            bucket: "bucket".to_string(),
-            object: "object".to_string(),
-            version_id: Some(version.to_string()),
-            bucket_incarnation_id: Some(incarnation),
-            pool_index: Some(1),
-            set_index: Some(2),
-        },
-        disposition: HealObjectDisposition::Repaired,
-        detail: None,
-    };
-
-    let event = mrf_verified_repair_event_for_target(&target, &matching).expect("matching positive receipt should publish");
-    assert_eq!(event.kind, MrfKind::PartialWrite);
-    assert_eq!(event.bucket.as_ref(), "bucket");
-    assert_eq!(event.object.as_ref(), "object");
-    assert_eq!(event.version_id, Some(*version.as_bytes()));
-    assert_eq!(
-        event.scope,
-        Some(MrfScope {
-            pool_index: 1,
-            set_index: 2
-        })
-    );
-    assert_eq!(event.lease, None);
-    assert_eq!(event.bucket_incarnation_id, incarnation);
-    assert_eq!(event.disposition, MrfVerifiedRepairDisposition::Repaired);
-
-    assert!(
-        mrf_verified_repair_event_for_target(
-            &MrfRepairNoticeTarget {
-                kind: MrfKind::DecodeFailure,
-                ..target.clone()
-            },
-            &matching
-        )
-        .is_none(),
-        "only receipt-producing partial-write object heals can publish verified events today"
-    );
-
-    for rejected in [
-        HealObjectOutcome {
-            disposition: HealObjectDisposition::Unknown,
-            ..matching.clone()
-        },
-        HealObjectOutcome {
-            identity: HealObjectIdentity {
-                bucket_incarnation_id: None,
-                ..matching.identity.clone()
-            },
-            ..matching.clone()
-        },
-        HealObjectOutcome {
-            identity: HealObjectIdentity {
-                object: "other".to_string(),
-                ..matching.identity.clone()
-            },
-            ..matching.clone()
-        },
-        HealObjectOutcome {
-            identity: HealObjectIdentity {
-                pool_index: Some(3),
-                ..matching.identity.clone()
-            },
-            ..matching
-        },
-    ] {
-        assert!(
-            mrf_verified_repair_event_for_target(&target, &rejected).is_none(),
-            "legacy, incomplete or mismatched outcomes must not discharge MRF responsibility"
-        );
-    }
-}
-
-#[test]
-fn completed_mrf_notice_publishes_only_verified_positive_events() {
-    use crate::heal::outcome::{HealObjectIdentity, HealObjectKind, HealObjectOutcome, HealTaskOutcome};
-    use rustfs_common::mrf_channel::{MrfKind, MrfScope, take_mrf_verified_repair_events_for};
-
-    let bucket = Arc::<str>::from("verified-mrf-completed-bucket");
-    let _ = take_mrf_verified_repair_events_for(bucket.as_ref());
-    let version = uuid::Uuid::new_v4();
-    let incarnation = uuid::Uuid::new_v4();
-    let matching_target = MrfRepairNoticeTarget {
-        bucket: bucket.clone(),
-        object: Arc::from("object-a"),
-        version_id: Some(*version.as_bytes()),
-        kind: MrfKind::PartialWrite,
-        scope: Some(MrfScope {
-            pool_index: 1,
-            set_index: 2,
-        }),
-        lease: None,
-    };
-    let mismatch_target = MrfRepairNoticeTarget {
-        object: Arc::from("object-b"),
-        ..matching_target.clone()
-    };
-    let mut outcome = HealTaskOutcome::default();
-    outcome.execution = HealExecutionOutcome::Completed;
-    outcome.coverage = crate::heal::outcome::HealTraversalCoverage::Complete;
-    outcome.record(HealObjectOutcome {
-        identity: HealObjectIdentity {
-            kind: HealObjectKind::Object,
-            bucket: bucket.to_string(),
-            object: "object-a".to_string(),
-            version_id: Some(version.to_string()),
-            bucket_incarnation_id: Some(incarnation),
-            pool_index: Some(1),
-            set_index: Some(2),
-        },
-        disposition: HealObjectDisposition::VerifiedHealthy,
-        detail: None,
-    });
-    outcome.record(HealObjectOutcome {
-        identity: HealObjectIdentity {
-            kind: HealObjectKind::Object,
-            bucket: bucket.to_string(),
-            object: "object-b".to_string(),
-            version_id: Some(version.to_string()),
-            bucket_incarnation_id: None,
-            pool_index: Some(1),
-            set_index: Some(2),
-        },
-        disposition: HealObjectDisposition::Repaired,
-        detail: None,
-    });
-    let completed = CompletedHealStatus {
-        outcome: Some(Arc::new(outcome)),
-        ..completed_retention_fixture(SystemTime::now())
-    };
-
-    publish_verified_mrf_repair_events(&[matching_target.clone(), mismatch_target], &completed);
-
-    let events = take_mrf_verified_repair_events_for(bucket.as_ref());
-    assert_eq!(events.len(), 1);
-    assert_eq!(events[0].object.as_ref(), "object-a");
-    assert_eq!(events[0].lease, None);
-    assert_eq!(events[0].bucket_incarnation_id, incarnation);
-
-    let failed = CompletedHealStatus {
-        status: HealTaskStatus::Failed {
-            error: "terminal failure".to_string(),
-        },
-        ..completed.clone()
-    };
-    publish_verified_mrf_repair_events(std::slice::from_ref(&matching_target), &failed);
-    assert!(
-        take_mrf_verified_repair_events_for(bucket.as_ref()).is_empty(),
-        "failed terminal tasks must not publish a verified repair event"
-    );
-
-    let mut completed_with_errors_outcome = completed.outcome.as_ref().expect("completed outcome").as_ref().clone();
-    completed_with_errors_outcome.execution = crate::heal::outcome::HealExecutionOutcome::CompletedWithErrors;
-    let completed_with_errors = CompletedHealStatus {
-        outcome: Some(Arc::new(completed_with_errors_outcome)),
-        ..completed
-    };
-    publish_verified_mrf_repair_events(std::slice::from_ref(&matching_target), &completed_with_errors);
-    assert!(
-        take_mrf_verified_repair_events_for(bucket.as_ref()).is_empty(),
-        "non-success canonical outcomes must not publish a verified repair event"
-    );
-}
-
 #[test]
 fn test_priority_queue_ordering() {
     let mut queue = PriorityHealQueue::new();
@@ -2977,88 +2792,6 @@ async fn admin_force_start_cancels_overlapping_active_task_first() {
     );
 }
 
-#[tokio::test]
-async fn admission_snapshot_tracks_start_duplicate_force_start_and_displacement() {
-    let storage: Arc<dyn HealStorageAPI> = Arc::new(MockStorage);
-    let manager = Arc::new(HealManager::new(
-        storage,
-        Some(HealConfig {
-            queue_size: 1,
-            ..Default::default()
-        }),
-    ));
-
-    let mut paused = admin_prefix_request("bucket-a", "logs/");
-    paused.priority = HealPriority::Low;
-    let hook = Arc::new(DuplicateAdmissionTestHook {
-        request_id: paused.id.clone(),
-        active_lock_reached: Notify::new(),
-        active_lock_release: Notify::new(),
-    });
-    *DUPLICATE_ADMISSION_TEST_HOOK.lock().await = Some(hook.clone());
-
-    let submit_manager = Arc::clone(&manager);
-    let mut paused_submission = tokio::spawn(async move { submit_manager.submit_heal_request(paused).await });
-    tokio::time::timeout(Duration::from_secs(1), hook.active_lock_reached.notified())
-        .await
-        .expect("admission should reach the test-only lock phase hook");
-    assert!(
-        tokio::time::timeout(Duration::from_millis(10), &mut paused_submission)
-            .await
-            .is_err(),
-        "admission must wait while the lock-phase hook is held"
-    );
-    hook.active_lock_release.notify_one();
-    assert_eq!(
-        paused_submission
-            .await
-            .expect("paused admission task should join")
-            .expect("paused admission should succeed"),
-        HealAdmissionResult::Accepted
-    );
-    *DUPLICATE_ADMISSION_TEST_HOOK.lock().await = None;
-
-    let duplicate = admin_prefix_request("bucket-a", "logs/");
-    let duplicate_receipt = manager
-        .submit_heal_request_with_receipt(duplicate)
-        .await
-        .expect("duplicate admission should return a canonical receipt");
-    assert_eq!(duplicate_receipt.result, HealAdmissionResult::Merged);
-
-    let mut high = admin_prefix_request("bucket-b", "logs/");
-    high.priority = HealPriority::High;
-    assert_eq!(
-        manager
-            .submit_heal_request(high)
-            .await
-            .expect("higher priority admin request should displace queued low-priority work"),
-        HealAdmissionResult::Accepted
-    );
-
-    let mut forced = admin_prefix_request("bucket-c", "logs/");
-    forced.force_start = true;
-    assert_eq!(
-        manager
-            .submit_heal_request(forced)
-            .await
-            .expect("forceStart should keep explicit admission semantics"),
-        HealAdmissionResult::Accepted
-    );
-
-    let admission = manager.operations_snapshot().await.admission;
-    assert_eq!(admission.accepted, 3);
-    assert_eq!(admission.merged, 1);
-    assert_eq!(admission.full, 0);
-    assert_eq!(admission.dropped, 0);
-    assert_eq!(admission.duplicate, 1);
-    assert_eq!(admission.displaced, 1);
-    assert_eq!(admission.force_start, 1);
-    assert!(
-        admission.max_lock_phase_micros > 0,
-        "snapshot should expose a measurable queue/admission lock phase for p95-style external aggregation"
-    );
-}
-
 #[tokio::test]
 async fn test_operations_snapshot_counts_active_by_source_and_priority() {
     let storage: Arc<dyn HealStorageAPI> = Arc::new(MockStorage);