You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by gn...@apache.org on 2026/07/11 22:55:28 UTC

(maven) branch maven-4.0.x updated: Backport #12454: mvnup upgrade strategies and compatibility improvements (#12467)

This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch maven-4.0.x
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/maven-4.0.x by this push:
     new 60d8f32fa6 Backport #12454: mvnup upgrade strategies and compatibility improvements (#12467)
60d8f32fa6 is described below

commit 60d8f32fa69494447ffe49a332cba46e0429652a
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Sun Jul 12 00:55:22 2026 +0200

    Backport #12454: mvnup upgrade strategies and compatibility improvements (#12467)
    
    * Fix #12430: mvnup upgrade strategies and compatibility improvements (#12454)
    
    * Fix #12430: Add HTTP-to-HTTPS repository URL upgrade strategy to mvnup
    
    Since Maven 3.8.1+, HTTP repositories are blocked by the
    maven-default-http-blocker mirror. This adds a RepositoryHttpsUpgradeStrategy
    that automatically converts http:// repository URLs to https:// in POM files.
    
    Well-known repositories (Apache snapshots/releases, Maven Central variants)
    are mapped to their canonical HTTPS equivalents. All other http:// URLs get
    a generic scheme upgrade.
    
    Handles repositories, pluginRepositories, distributionManagement (both
    repository and snapshotRepository), and profile-scoped repositories.
    
    Includes 27 tests covering well-known URL normalization, generic http->https
    conversion, all POM sections, profile-scoped repos, and edge cases.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12430: Add EnforcerVersionRangeStrategy and fix dependency dedup last-wins
    
    Add EnforcerVersionRangeStrategy that widens requireMavenVersion ranges
    excluding Maven 4 (e.g. [3.8.8,4) → [3.8.8,5)) in the maven-enforcer-plugin.
    Handles top-level and per-execution configurations, pluginManagement, and
    profile-scoped declarations.
    
    Fix CompatibilityFixStrategy dependency/plugin deduplication to use last-wins
    semantics (matching Maven 3 runtime behavior) instead of first-wins. Update
    log messages to include the kept version.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12429: Add quarkus-maven-plugin upgrade support to mvnup
    
    Add PluginUpgrade entries for quarkus-maven-plugin (both io.quarkus
    and io.quarkus.platform groupIds) with minimum version 3.26.0.
    When the plugin version references the same property as a Quarkus BOM,
    the strategy decouples it by introducing a separate quarkus-plugin.version
    property. After upgrading, emits a warning if the platform BOM version
    is significantly older than the plugin version.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12431: Silently ignore unrecognized CLI options from .mvn/maven.config
    
    mvnup inherits the Maven launcher's argument handling, which appends
    options from .mvn/maven.config. That file often contains build flags
    like -ntp, -U, or -T that mvnup does not recognize, causing a
    ParseException before any upgrades are applied.
    
    Override CLIManager.parse() to catch UnrecognizedOptionException and
    retry after removing the offending option, so mvnup works in projects
    with a .mvn/maven.config file.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12432: Warn about gmavenplus-plugin Maven 4 incompatibility
    
    gmavenplus-plugin (all versions up to 4.1.1) calls mutating methods
    on immutable lists returned by the Maven 4 API, causing
    UnsupportedOperationException on goals like removeStubs.
    
    Add a warning-only check to CompatibilityFixStrategy that detects
    known incompatible plugins and emits a warning with a link to the
    upstream issue tracker. The check does not modify the POM.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12433: Warn about third-party repository prefix filtering
    
    Maven 4's prefix-based artifact filtering may block resolution from
    repositories that do not publish a prefixes.txt file. When Maven 4
    auto-generates an incomplete prefix list, legitimate artifacts are
    rejected with ArtifactFilteredOutException.
    
    Add a warning for non-Maven-Central repositories detected in POMs,
    advising users to check prefix configuration if builds fail.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12434: Warn about property-interpolated module paths
    
    Maven 4 validates module paths during POM parsing, before property
    interpolation occurs. Paths like <module>spark-${spark.version}</module>
    are rejected because the literal string (with the unresolved
    expression) does not correspond to an existing directory.
    
    Add a warning for module/subproject elements containing ${...}
    expressions, both at root level and inside profiles.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12435: Warn about CI-friendly ${revision} missing dependency versions
    
    In CI-friendly projects using ${revision}, ${sha1}, or ${changelist}
    as the parent version, child modules with versionless dependencies
    may fail with 'dependencies.dependency.version is missing' because
    Maven 4 validates dependency completeness before fully resolving the
    parent's dependencyManagement chain.
    
    Add a warning that detects this pattern: a parent with a CI-friendly
    version expression and dependencies without explicit <version> elements.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Revert #12433: Remove incorrect prefix filtering warning
    
    Maven 4's prefix filtering defaults to permissive behavior when a
    repository has no prefixes.txt — artifacts are allowed through, not
    blocked. The warning was based on a misunderstanding of the default
    noInputOutcome=true setting. The actual issue is narrower: only
    auto-discovered prefix files with incomplete content can cause false
    negatives, and Maven already provides per-repository disable options
    and helpful hints in ArtifactFilteredOutException messages.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Address review feedback: fix option-arg stripping and inherited property guard
    
    - CLI option stripping: also remove trailing argument values for
      options like "-T 4" (two tokens) to prevent the value from being
      treated as a spurious goal.
    - BOM property decoupling: skip when the shared property is not
      declared in the current POM (inherited from parent), since we
      cannot resolve its actual value and introducing a new property
      could downgrade an already-sufficient inherited version.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12432: Convert gmavenplus-plugin to auto-upgrade and soften version gap warning
    
    - Move gmavenplus-plugin from KNOWN_INCOMPATIBLE_PLUGINS (permanent warning)
      to PluginUpgrade with minimum version 4.2.0. The Maven 4 incompatibility
      was fixed in groovy/GMavenPlus#328 (released in 4.2.0), and the Maven-side
      fix landed in MNG-8662.
    - Soften the Quarkus version gap warning: remove the unsubstantiated claim
      about binary incompatibility at 3.32.0 and replace with general version
      alignment advice.
    - Fix wrong Quarkus upstream reference in PR description (#46889 → #37627).
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix mvnup comment formatting: place override comments on their own line
    
    When mvnup inserts "Override version inherited from parent" comments
    before plugin elements, the comment was placed on the same line as
    the preceding </plugin> closing tag, causing POM formatting violations
    in projects that enforce XML formatting (e.g. via spotless).
    
    The fix sets precedingWhitespace on the Comment node to match the
    plugin element's indentation, ensuring the comment appears on its
    own line.
    
    Fixes gnodet/maven4-testing#23134
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Upgrade DomTrip to 1.6.0 and use Editor.insertCommentBefore API
    
    Replace the manual precedingWhitespace() workaround with the new
    Editor.insertCommentBefore() method added in DomTrip 1.6.0
    (maveniverse/domtrip#254), which handles whitespace automatically.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12430: Skip quarkus-maven-plugin upgrade for Quarkus 2.x projects
    
    Detect the Quarkus platform version before upgrading quarkus-maven-plugin.
    Projects using Quarkus 2.x (or 1.x) get their plugin upgrade skipped to
    prevent NoSuchMethodError and build failures from the 2.x→3.x jump.
    
    Detection checks dependencyManagement for quarkus-bom (resolving property
    references), then falls back to quarkus.platform.version / quarkus.version
    / quarkus-plugin.version properties. When the version cannot be determined,
    a warning is emitted.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix #12455: Add ResourceFilteringStrategy to prevent MalformedInputException on binary files
    
    Maven 4 strictly decodes filtered resources as UTF-8, causing
    MalformedInputException when binary files (.xlsx, .docx, etc.) are
    present in resource directories with <filtering>true</filtering>.
    
    This strategy scans all <resource> and <testResource> blocks. When
    filtering is enabled and the maven-resources-plugin does not already
    declare <nonFilteredFileExtensions>, adds a comprehensive list of 23
    binary file extensions (office docs, archives, fonts, executables,
    keystores) to pluginManagement. If a partial config exists, merges
    the missing extensions.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Extract DeduplicateDependenciesStrategy from CompatibilityFixStrategy
    
    Maven 4 rejects duplicate dependency/plugin declarations that Maven 3
    silently accepted. Extract the deduplication logic into a standalone
    strategy for clarity and independent control.
    
    The new strategy scans <dependencies>, <dependencyManagement>, and
    <plugins>/<pluginManagement> sections (including profiles) and removes
    duplicates using last-wins semantics matching Maven 3's runtime
    behavior. The key is groupId:artifactId:type:classifier for
    dependencies and groupId:artifactId for plugins.
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Address review feedback: fix Javadoc and expand binary extensions
    
    - DeduplicateDependenciesStrategy: clarify last-wins is intentional,
      not matching Maven 3's first-wins dependency resolution
    - EnforcerVersionRangeStrategy: document regex matches any 4.x upper
      bound, not just 4/4.0/4.0.0
    - ResourceFilteringStrategy: add 10 missing binary extensions (png,
      jpg, jpeg, gif, bmp, tiff, mp3, mp4, p12, pfx) and soften
      "comprehensive" wording to "common"
    - RepositoryHttpsUpgradeStrategy: fix misleading LinkedHashMap comment
      about prefix length ordering
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    * Revert unrecognized option retry loop in mvnup (see #12464)
    
    The retry loop silently swallowed unknown CLI options, masking user
    errors. The root cause is that the mvn launcher passes $MAVEN_ARGS
    to mvnup unconditionally — that should be fixed in the shell script
    instead (tracked in #12464).
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    ---------
    
    Co-authored-by: Claude Opus 4.6 <no...@anthropic.com>
    
    * Fix Spotless formatting in CompatibilityFixStrategy
    
    Co-Authored-By: Claude Opus 4.6 <no...@anthropic.com>
    
    ---------
    
    Co-authored-by: Claude Opus 4.6 <no...@anthropic.com>
---
 .../mvnup/goals/CompatibilityFixStrategy.java      |  357 +++---
 .../goals/DeduplicateDependenciesStrategy.java     |  295 +++++
 .../mvnup/goals/EnforcerVersionRangeStrategy.java  |  286 +++++
 .../invoker/mvnup/goals/PluginUpgradeStrategy.java |  364 +++++-
 .../goals/RepositoryHttpsUpgradeStrategy.java      |  290 +++++
 .../mvnup/goals/ResourceFilteringStrategy.java     |  426 +++++++
 .../mvnup/goals/CompatibilityFixStrategyTest.java  |  148 ---
 .../mvnup/goals/CompatibilityWarningTest.java      |  383 ++++++
 .../goals/DeduplicateDependenciesStrategyTest.java |  552 +++++++++
 .../goals/EnforcerVersionRangeStrategyTest.java    |  577 +++++++++
 .../mvnup/goals/PluginUpgradeStrategyTest.java     | 1275 ++++++++++++++------
 .../mvnup/goals/QuarkusPlatformVersionTest.java    |  439 +++++++
 .../goals/RepositoryHttpsUpgradeStrategyTest.java  |  768 ++++++++++++
 .../mvnup/goals/ResourceFilteringStrategyTest.java |  668 ++++++++++
 14 files changed, 6059 insertions(+), 769 deletions(-)

diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategy.java
index 9b52f5d062..c5efbe8042 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategy.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategy.java
@@ -19,7 +19,6 @@
 package org.apache.maven.cling.invoker.mvnup.goals;
 
 import java.nio.file.Path;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -50,6 +49,8 @@
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCIES;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY_MANAGEMENT;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.MODULE;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.MODULES;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PARENT;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGINS;
@@ -62,6 +63,9 @@
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.RELATIVE_PATH;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.REPOSITORIES;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.REPOSITORY;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.SUBPROJECT;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.SUBPROJECTS;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.VERSION;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Files.DEFAULT_PARENT_RELATIVE_PATH;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Plugins.DEFAULT_MAVEN_PLUGIN_GROUP_ID;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Plugins.MAVEN_PLUGIN_PREFIX;
@@ -81,6 +85,15 @@ public class CompatibilityFixStrategy extends AbstractUpgradeStrategy {
 
     private static final Set<String> VALID_COMBINE_CHILDREN_VALUES = Set.of(COMBINE_APPEND, COMBINE_MERGE);
 
+    /**
+     * Known incompatible plugins where even the latest version fails with Maven 4.
+     * Maps plugin key (groupId:artifactId) to a description of the incompatibility.
+     * <p>
+     * Note: plugins that have a fixed version available should be added to
+     * {@link PluginUpgradeStrategy} instead, so mvnup can auto-upgrade them.
+     */
+    private static final Map<String, String> KNOWN_INCOMPATIBLE_PLUGINS = Map.of();
+
     @Override
     public boolean isApplicable(UpgradeContext context) {
         UpgradeOptions options = getOptions(context);
@@ -144,14 +157,18 @@ public UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap)
 
                 hasIssues |= fixUnsupportedCombineChildrenAttributes(pomDocument, context);
                 hasIssues |= fixUnsupportedCombineSelfAttributes(pomDocument, context);
-                hasIssues |= fixDuplicateDependencies(pomDocument, context);
-                hasIssues |= fixDuplicatePlugins(pomDocument, context);
                 hasIssues |= fixUnsupportedRepositoryExpressions(pomDocument, context);
                 hasIssues |= fixDeprecatedPropertyExpressions(pomDocument, context);
                 hasIssues |= fixIncorrectParentRelativePaths(pomDocument, pomPath, pomMap, context);
                 hasIssues |= fixUndefinedPropertyExpressions(pomDocument, allDefinedProperties, context);
                 hasIssues |= fixUndefinedPropertyExpressionsInRepositories(pomDocument, allDefinedProperties, context);
 
+                // Warning-only checks: emit warnings for issues that cannot be auto-fixed
+                // These do not modify the POM and do not affect hasIssues
+                warnAboutIncompatiblePlugins(pomDocument, context);
+                warnAboutPropertyInterpolatedModulePaths(pomDocument, context);
+                warnAboutCiFriendlyMissingDependencyVersions(pomDocument, context);
+
                 if (hasIssues) {
                     context.success("Maven 4 compatibility issues fixed");
                     modifiedPoms.add(pomPath);
@@ -211,87 +228,6 @@ private boolean fixUnsupportedCombineSelfAttributes(Document pomDocument, Upgrad
         return !invalidElements.isEmpty();
     }
 
-    /**
-     * Fixes duplicate dependencies in dependencies and dependencyManagement sections.
-     */
-    private boolean fixDuplicateDependencies(Document pomDocument, UpgradeContext context) {
-        Element root = pomDocument.root();
-
-        // Collect all dependency containers to process
-        Stream<DependencyContainer> dependencyContainers = Stream.concat(
-                // Root level dependencies
-                Stream.of(
-                                new DependencyContainer(
-                                        root.childElement(DEPENDENCIES).orElse(null), DEPENDENCIES),
-                                new DependencyContainer(
-                                        root.childElement(DEPENDENCY_MANAGEMENT)
-                                                .flatMap(dm -> dm.childElement(DEPENDENCIES))
-                                                .orElse(null),
-                                        DEPENDENCY_MANAGEMENT))
-                        .filter(container -> container.element != null),
-                // Profile dependencies
-                root.childElement(PROFILES).stream()
-                        .flatMap(profiles -> profiles.childElements(PROFILE))
-                        .flatMap(profile -> Stream.of(
-                                        new DependencyContainer(
-                                                profile.childElement(DEPENDENCIES)
-                                                        .orElse(null),
-                                                "profile dependencies"),
-                                        new DependencyContainer(
-                                                profile.childElement(DEPENDENCY_MANAGEMENT)
-                                                        .flatMap(dm -> dm.childElement(DEPENDENCIES))
-                                                        .orElse(null),
-                                                "profile dependencyManagement"))
-                                .filter(container -> container.element != null)));
-
-        return dependencyContainers
-                .map(container -> fixDuplicateDependenciesInSection(container.element, context, container.sectionName))
-                .reduce(false, Boolean::logicalOr);
-    }
-
-    private static class DependencyContainer {
-        final Element element;
-        final String sectionName;
-
-        DependencyContainer(Element element, String sectionName) {
-            this.element = element;
-            this.sectionName = sectionName;
-        }
-    }
-
-    /**
-     * Fixes duplicate plugins in plugins and pluginManagement sections.
-     */
-    private boolean fixDuplicatePlugins(Document pomDocument, UpgradeContext context) {
-        Element root = pomDocument.root();
-
-        // Collect all build elements to process
-        Stream<BuildContainer> buildContainers = Stream.concat(
-                // Root level build
-                Stream.of(new BuildContainer(root.childElement(BUILD).orElse(null), BUILD))
-                        .filter(container -> container.element != null),
-                // Profile builds
-                root.childElement(PROFILES).stream()
-                        .flatMap(profiles -> profiles.childElements(PROFILE))
-                        .map(profile ->
-                                new BuildContainer(profile.childElement(BUILD).orElse(null), "profile build"))
-                        .filter(container -> container.element != null));
-
-        return buildContainers
-                .map(container -> fixPluginsInBuildElement(container.element, context, container.sectionName))
-                .reduce(false, Boolean::logicalOr);
-    }
-
-    private static class BuildContainer {
-        final Element element;
-        final String sectionName;
-
-        BuildContainer(Element element, String sectionName) {
-            this.element = element;
-            this.sectionName = sectionName;
-        }
-    }
-
     /**
      * Fixes unsupported repository URL expressions.
      */
@@ -394,6 +330,16 @@ private Set<String> collectEffectiveProperties(UpgradeContext context, Map<Path,
         return properties;
     }
 
+    private static class DependencyContainer {
+        final Element element;
+        final String sectionName;
+
+        DependencyContainer(Element element, String sectionName) {
+            this.element = element;
+            this.sectionName = sectionName;
+        }
+    }
+
     /**
      * Fixes dependencies with undefined property expressions by commenting them out.
      */
@@ -630,106 +576,6 @@ private Stream<Element> findElementsWithInvalidAttribute(
                         .flatMap(child -> findElementsWithInvalidAttribute(child, attributeName, validValues)));
     }
 
-    /**
-     * Helper methods extracted from BaseUpgradeGoal for compatibility fixes.
-     */
-    private boolean fixDuplicateDependenciesInSection(
-            Element dependenciesElement, UpgradeContext context, String sectionName) {
-        List<Element> dependencies =
-                dependenciesElement.childElements(DEPENDENCY).toList();
-        Map<String, Element> seenDependencies = new HashMap<>();
-
-        List<Element> duplicates = dependencies.stream()
-                .filter(dependency -> {
-                    String key = createDependencyKey(dependency);
-                    if (seenDependencies.containsKey(key)) {
-                        context.detail("Fixed: Removed duplicate dependency: " + key + " in " + sectionName);
-                        return true; // This is a duplicate
-                    } else {
-                        seenDependencies.put(key, dependency);
-                        return false; // This is the first occurrence
-                    }
-                })
-                .toList();
-
-        // Remove duplicates while preserving formatting
-        duplicates.forEach(DomUtils::removeElement);
-
-        return !duplicates.isEmpty();
-    }
-
-    private String createDependencyKey(Element dependency) {
-        String groupId = dependency.childText(MavenPomElements.Elements.GROUP_ID);
-        String artifactId = dependency.childText(MavenPomElements.Elements.ARTIFACT_ID);
-        String type = dependency.childText(MavenPomElements.Elements.TYPE);
-        String classifier = dependency.childText(MavenPomElements.Elements.CLASSIFIER);
-
-        return groupId + ":" + artifactId + ":" + (type != null ? type : "jar") + ":"
-                + (classifier != null ? classifier : "");
-    }
-
-    private boolean fixPluginsInBuildElement(Element buildElement, UpgradeContext context, String sectionName) {
-        boolean fixed = false;
-
-        Element pluginsElement = buildElement.childElement(PLUGINS).orElse(null);
-        if (pluginsElement != null) {
-            fixed |= fixDuplicatePluginsInSection(pluginsElement, context, sectionName + "/" + PLUGINS);
-        }
-
-        Element pluginManagementElement =
-                buildElement.childElement(PLUGIN_MANAGEMENT).orElse(null);
-        if (pluginManagementElement != null) {
-            Element managedPluginsElement =
-                    pluginManagementElement.childElement(PLUGINS).orElse(null);
-            if (managedPluginsElement != null) {
-                fixed |= fixDuplicatePluginsInSection(
-                        managedPluginsElement, context, sectionName + "/" + PLUGIN_MANAGEMENT + "/" + PLUGINS);
-            }
-        }
-
-        return fixed;
-    }
-
-    /**
-     * Fixes duplicate plugins within a specific plugins section.
-     */
-    private boolean fixDuplicatePluginsInSection(Element pluginsElement, UpgradeContext context, String sectionName) {
-        List<Element> plugins = pluginsElement.childElements(PLUGIN).toList();
-        Map<String, Element> seenPlugins = new HashMap<>();
-
-        List<Element> duplicates = plugins.stream()
-                .filter(plugin -> {
-                    String key = createPluginKey(plugin);
-                    if (key != null) {
-                        if (seenPlugins.containsKey(key)) {
-                            context.detail("Fixed: Removed duplicate plugin: " + key + " in " + sectionName);
-                            return true; // This is a duplicate
-                        } else {
-                            seenPlugins.put(key, plugin);
-                        }
-                    }
-                    return false; // This is the first occurrence or invalid plugin
-                })
-                .toList();
-
-        // Remove duplicates while preserving formatting
-        duplicates.forEach(DomUtils::removeElement);
-
-        return !duplicates.isEmpty();
-    }
-
-    private String createPluginKey(Element plugin) {
-        String groupId = plugin.childText(MavenPomElements.Elements.GROUP_ID);
-        String artifactId = plugin.childText(MavenPomElements.Elements.ARTIFACT_ID);
-
-        // Default groupId for Maven plugins
-        if (groupId == null && artifactId != null && artifactId.startsWith(MAVEN_PLUGIN_PREFIX)) {
-            groupId = DEFAULT_MAVEN_PLUGIN_GROUP_ID;
-        }
-
-        return (groupId != null && artifactId != null) ? groupId + ":" + artifactId : null;
-    }
-
     private boolean fixRepositoryExpressions(
             Element repositoriesElement, Document pomDocument, UpgradeContext context) {
         if (repositoriesElement == null) {
@@ -815,4 +661,147 @@ private Path findParentPomInMap(
                 .findFirst()
                 .orElse(null);
     }
+
+    // ---- Warning-only checks for Maven 4 compatibility issues that cannot be auto-fixed ----
+
+    /**
+     * Warns about plugins known to be incompatible with Maven 4 even at their latest version.
+     * These plugins call methods on immutable API objects or use removed internal APIs
+     * and require upstream fixes before they can work with Maven 4.
+     *
+     * @see <a href="https://github.com/apache/maven/issues/12432">#12432</a>
+     */
+    private void warnAboutIncompatiblePlugins(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+
+        Stream<Element> pluginContainers = Stream.concat(
+                // Root level build
+                root.childElement(BUILD).stream()
+                        .flatMap(build -> Stream.concat(
+                                build.childElement(PLUGINS).stream(),
+                                build.childElement(PLUGIN_MANAGEMENT).stream()
+                                        .flatMap(pm -> pm.childElement(PLUGINS).stream()))),
+                // Profile builds
+                root.childElement(PROFILES).stream()
+                        .flatMap(profiles -> profiles.childElements(PROFILE))
+                        .flatMap(profile -> profile.childElement(BUILD).stream())
+                        .flatMap(build -> Stream.concat(
+                                build.childElement(PLUGINS).stream(),
+                                build.childElement(PLUGIN_MANAGEMENT).stream()
+                                        .flatMap(pm -> pm.childElement(PLUGINS).stream()))));
+
+        pluginContainers.forEach(
+                pluginsElement -> pluginsElement.childElements(PLUGIN).forEach(pluginElement -> {
+                    String groupId = pluginElement.childText(MavenPomElements.Elements.GROUP_ID);
+                    String artifactId = pluginElement.childText(MavenPomElements.Elements.ARTIFACT_ID);
+
+                    if (groupId == null && artifactId != null && artifactId.startsWith(MAVEN_PLUGIN_PREFIX)) {
+                        groupId = DEFAULT_MAVEN_PLUGIN_GROUP_ID;
+                    }
+
+                    if (groupId != null && artifactId != null) {
+                        String pluginKey = groupId + ":" + artifactId;
+                        String warning = KNOWN_INCOMPATIBLE_PLUGINS.get(pluginKey);
+                        if (warning != null) {
+                            context.warning("Known Maven 4 incompatibility: " + pluginKey + " — " + warning);
+                        }
+                    }
+                }));
+    }
+
+    /**
+     * Warns about {@code <module>} (or {@code <subproject>}) elements that contain property
+     * expressions ({@code ${...}}). Maven 4 validates module paths during POM parsing,
+     * before profiles can set property values, so these paths are rejected as non-existent.
+     *
+     * @see <a href="https://github.com/apache/maven/issues/12434">#12434</a>
+     */
+    private void warnAboutPropertyInterpolatedModulePaths(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+
+        // Check root-level modules/subprojects
+        Stream.concat(
+                        root.childElement(MODULES).stream().flatMap(m -> m.childElements(MODULE)),
+                        root.childElement(SUBPROJECTS).stream().flatMap(s -> s.childElements(SUBPROJECT)))
+                .forEach(moduleElement -> {
+                    String path = moduleElement.textContentTrimmed();
+                    if (path != null && EXPRESSION_PATTERN.matcher(path).find()) {
+                        context.warning("Module path '" + path
+                                + "' contains a property expression. Maven 4 validates module paths"
+                                + " before property interpolation, which will cause a build failure"
+                                + " if the expression cannot be resolved at parse time.");
+                    }
+                });
+
+        // Check profile-level modules/subprojects
+        root.childElement(PROFILES)
+                .ifPresent(profiles -> profiles.childElements(PROFILE).forEach(profile -> {
+                    Stream.concat(
+                                    profile.childElement(MODULES).stream().flatMap(m -> m.childElements(MODULE)),
+                                    profile.childElement(SUBPROJECTS).stream()
+                                            .flatMap(s -> s.childElements(SUBPROJECT)))
+                            .forEach(moduleElement -> {
+                                String path = moduleElement.textContentTrimmed();
+                                if (path != null
+                                        && EXPRESSION_PATTERN.matcher(path).find()) {
+                                    context.warning("Profile module path '" + path
+                                            + "' contains a property expression. Maven 4 validates module"
+                                            + " paths before profile-driven property interpolation, which"
+                                            + " will cause a build failure when no profile is active.");
+                                }
+                            });
+                }));
+    }
+
+    /**
+     * Warns about CI-friendly projects using {@code ${revision}} (or {@code ${sha1}},
+     * {@code ${changelist}}) where child module dependencies lack explicit {@code <version>}
+     * elements and rely on {@code dependencyManagement} inherited from the parent.
+     * Maven 4 validates dependency completeness before fully resolving the parent's
+     * {@code dependencyManagement} chain when the parent's own version is a CI-friendly
+     * expression.
+     *
+     * @see <a href="https://github.com/apache/maven/issues/12435">#12435</a>
+     */
+    private void warnAboutCiFriendlyMissingDependencyVersions(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+
+        // Only check if this POM has a parent with a CI-friendly version
+        Element parentElement = root.childElement(PARENT).orElse(null);
+        if (parentElement == null) {
+            return;
+        }
+        String parentVersion = parentElement.childText(VERSION);
+        if (parentVersion == null || !isCiFriendlyExpression(parentVersion)) {
+            return;
+        }
+
+        // Check for dependencies without explicit versions
+        List<String> versionlessDeps = root.childElement(DEPENDENCIES).stream()
+                .flatMap(deps -> deps.childElements(DEPENDENCY))
+                .filter(dep -> dep.childElement(VERSION).isEmpty())
+                .map(dep -> {
+                    String gid = dep.childText(MavenPomElements.Elements.GROUP_ID);
+                    String aid = dep.childText(MavenPomElements.Elements.ARTIFACT_ID);
+                    return (gid != null ? gid : "?") + ":" + (aid != null ? aid : "?");
+                })
+                .toList();
+
+        if (!versionlessDeps.isEmpty()) {
+            context.warning("This module uses CI-friendly version '" + parentVersion
+                    + "' in its parent and has " + versionlessDeps.size()
+                    + " dependencies without explicit <version> elements (e.g., "
+                    + versionlessDeps.get(0)
+                    + "). Maven 4 may fail with 'dependencies.dependency.version is missing'"
+                    + " because dependency management inheritance is validated before the"
+                    + " CI-friendly parent version is fully resolved.");
+        }
+    }
+
+    /**
+     * Checks if a version string is a CI-friendly expression.
+     */
+    private static boolean isCiFriendlyExpression(String version) {
+        return version.contains("${revision}") || version.contains("${sha1}") || version.contains("${changelist}");
+    }
 }
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/DeduplicateDependenciesStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/DeduplicateDependenciesStrategy.java
new file mode 100644
index 0000000000..1eedd6202f
--- /dev/null
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/DeduplicateDependenciesStrategy.java
@@ -0,0 +1,295 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import eu.maveniverse.domtrip.Document;
+import eu.maveniverse.domtrip.Element;
+import eu.maveniverse.domtrip.maven.MavenPomElements;
+import org.apache.maven.api.cli.mvnup.UpgradeOptions;
+import org.apache.maven.api.di.Named;
+import org.apache.maven.api.di.Priority;
+import org.apache.maven.api.di.Singleton;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.BUILD;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCIES;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY_MANAGEMENT;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGINS;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN_MANAGEMENT;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILE;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILES;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Plugins.DEFAULT_MAVEN_PLUGIN_GROUP_ID;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Plugins.MAVEN_PLUGIN_PREFIX;
+
+/**
+ * Strategy for deduplicating dependency and plugin declarations in POM files.
+ *
+ * <p>Maven 4 rejects duplicate {@code <dependency>} entries (same groupId, artifactId,
+ * type, and classifier) that Maven 3 silently accepted. This strategy scans each POM's
+ * {@code <dependencies>} and {@code <dependencyManagement>/<dependencies>} sections and
+ * removes duplicates using last-wins semantics (keeping the last declaration). Note that
+ * Maven 3's dependency resolver uses first-wins for same-depth conflicts; last-wins is
+ * chosen here intentionally so the most recently added (and presumably most up-to-date)
+ * declaration is preserved.
+ *
+ * <p>The strategy also handles duplicate {@code <plugin>} entries in {@code <plugins>}
+ * and {@code <pluginManagement>/<plugins>} sections with the same last-wins semantics
+ * (which does match Maven 3's plugin configuration merging behavior).
+ *
+ * <p>Profile-scoped dependency and plugin sections are processed as well.
+ */
+@Named
+@Singleton
+@Priority(19)
+public class DeduplicateDependenciesStrategy extends AbstractUpgradeStrategy {
+
+    @Override
+    public boolean isApplicable(UpgradeContext context) {
+        UpgradeOptions options = getOptions(context);
+        return isOptionEnabled(options, options.model(), true);
+    }
+
+    @Override
+    public String getDescription() {
+        return "Deduplicating dependency and plugin declarations";
+    }
+
+    @Override
+    protected UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap) {
+        Set<Path> processedPoms = new HashSet<>();
+        Set<Path> modifiedPoms = new HashSet<>();
+        Set<Path> errorPoms = new HashSet<>();
+
+        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
+            Path pomPath = entry.getKey();
+            Document pomDocument = entry.getValue();
+            processedPoms.add(pomPath);
+
+            context.info(pomPath + " (checking for duplicate declarations)");
+            context.indent();
+
+            try {
+                boolean hasIssues = false;
+
+                hasIssues |= fixDuplicateDependencies(pomDocument, context);
+                hasIssues |= fixDuplicatePlugins(pomDocument, context);
+
+                if (hasIssues) {
+                    context.success("Duplicate declarations removed");
+                    modifiedPoms.add(pomPath);
+                } else {
+                    context.success("No duplicate declarations found");
+                }
+            } catch (Exception e) {
+                context.failure("Failed to deduplicate declarations: " + e.getMessage());
+                errorPoms.add(pomPath);
+            } finally {
+                context.unindent();
+            }
+        }
+
+        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);
+    }
+
+    /**
+     * Fixes duplicate dependencies in dependencies and dependencyManagement sections,
+     * including profile-scoped sections.
+     */
+    private boolean fixDuplicateDependencies(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+
+        Stream<DependencyContainer> dependencyContainers = Stream.concat(
+                // Root level dependencies
+                Stream.of(
+                                new DependencyContainer(
+                                        root.childElement(DEPENDENCIES).orElse(null), DEPENDENCIES),
+                                new DependencyContainer(
+                                        root.childElement(DEPENDENCY_MANAGEMENT)
+                                                .flatMap(dm -> dm.childElement(DEPENDENCIES))
+                                                .orElse(null),
+                                        DEPENDENCY_MANAGEMENT))
+                        .filter(container -> container.element != null),
+                // Profile dependencies
+                root.childElement(PROFILES).stream()
+                        .flatMap(profiles -> profiles.childElements(PROFILE))
+                        .flatMap(profile -> Stream.of(
+                                        new DependencyContainer(
+                                                profile.childElement(DEPENDENCIES)
+                                                        .orElse(null),
+                                                "profile dependencies"),
+                                        new DependencyContainer(
+                                                profile.childElement(DEPENDENCY_MANAGEMENT)
+                                                        .flatMap(dm -> dm.childElement(DEPENDENCIES))
+                                                        .orElse(null),
+                                                "profile dependencyManagement"))
+                                .filter(container -> container.element != null)));
+
+        return dependencyContainers
+                .map(container -> fixDuplicateDependenciesInSection(container.element, context, container.sectionName))
+                .reduce(false, Boolean::logicalOr);
+    }
+
+    /**
+     * Fixes duplicate plugins in plugins and pluginManagement sections,
+     * including profile-scoped sections.
+     */
+    private boolean fixDuplicatePlugins(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+
+        Stream<BuildContainer> buildContainers = Stream.concat(
+                // Root level build
+                Stream.of(new BuildContainer(root.childElement(BUILD).orElse(null), BUILD))
+                        .filter(container -> container.element != null),
+                // Profile builds
+                root.childElement(PROFILES).stream()
+                        .flatMap(profiles -> profiles.childElements(PROFILE))
+                        .map(profile ->
+                                new BuildContainer(profile.childElement(BUILD).orElse(null), "profile build"))
+                        .filter(container -> container.element != null));
+
+        return buildContainers
+                .map(container -> fixPluginsInBuildElement(container.element, context, container.sectionName))
+                .reduce(false, Boolean::logicalOr);
+    }
+
+    /**
+     * Deduplicates dependencies within a specific dependencies section using last-wins semantics.
+     * When a duplicate is found, the earlier occurrence is removed and the later one is kept,
+     * matching Maven 3's runtime behavior.
+     */
+    private boolean fixDuplicateDependenciesInSection(
+            Element dependenciesElement, UpgradeContext context, String sectionName) {
+        List<Element> dependencies =
+                dependenciesElement.childElements(DEPENDENCY).toList();
+        Map<String, Element> seenDependencies = new HashMap<>();
+        List<Element> duplicates = new ArrayList<>();
+
+        for (Element dependency : dependencies) {
+            String key = createDependencyKey(dependency);
+            Element previous = seenDependencies.put(key, dependency);
+            if (previous != null) {
+                duplicates.add(previous);
+                String keptVersion = dependency.childText(MavenPomElements.Elements.VERSION);
+                String versionInfo = keptVersion != null ? " (keeping version " + keptVersion + ")" : "";
+                context.detail(
+                        "Removed duplicate dependency declaration for " + key + versionInfo + " in " + sectionName);
+            }
+        }
+
+        duplicates.forEach(DomUtils::removeElement);
+
+        return !duplicates.isEmpty();
+    }
+
+    /**
+     * Creates a unique key for a dependency based on groupId, artifactId, type, and classifier.
+     * Type defaults to "jar" and classifier defaults to empty when not specified.
+     */
+    private String createDependencyKey(Element dependency) {
+        String groupId = dependency.childText(MavenPomElements.Elements.GROUP_ID);
+        String artifactId = dependency.childText(MavenPomElements.Elements.ARTIFACT_ID);
+        String type = dependency.childText(MavenPomElements.Elements.TYPE);
+        String classifier = dependency.childText(MavenPomElements.Elements.CLASSIFIER);
+
+        return groupId + ":" + artifactId + ":" + (type != null ? type : "jar") + ":"
+                + (classifier != null ? classifier : "");
+    }
+
+    /**
+     * Fixes duplicate plugins within a build element, covering both plugins and pluginManagement.
+     */
+    private boolean fixPluginsInBuildElement(Element buildElement, UpgradeContext context, String sectionName) {
+        boolean fixed = false;
+
+        Element pluginsElement = buildElement.childElement(PLUGINS).orElse(null);
+        if (pluginsElement != null) {
+            fixed |= fixDuplicatePluginsInSection(pluginsElement, context, sectionName + "/" + PLUGINS);
+        }
+
+        Element pluginManagementElement =
+                buildElement.childElement(PLUGIN_MANAGEMENT).orElse(null);
+        if (pluginManagementElement != null) {
+            Element managedPluginsElement =
+                    pluginManagementElement.childElement(PLUGINS).orElse(null);
+            if (managedPluginsElement != null) {
+                fixed |= fixDuplicatePluginsInSection(
+                        managedPluginsElement, context, sectionName + "/" + PLUGIN_MANAGEMENT + "/" + PLUGINS);
+            }
+        }
+
+        return fixed;
+    }
+
+    /**
+     * Deduplicates plugins within a specific plugins section using last-wins semantics.
+     */
+    private boolean fixDuplicatePluginsInSection(Element pluginsElement, UpgradeContext context, String sectionName) {
+        List<Element> plugins = pluginsElement.childElements(PLUGIN).toList();
+        Map<String, Element> seenPlugins = new HashMap<>();
+        List<Element> duplicates = new ArrayList<>();
+
+        for (Element plugin : plugins) {
+            String key = createPluginKey(plugin);
+            if (key != null) {
+                Element previous = seenPlugins.put(key, plugin);
+                if (previous != null) {
+                    duplicates.add(previous);
+                    String keptVersion = plugin.childText(MavenPomElements.Elements.VERSION);
+                    String versionInfo = keptVersion != null ? " (keeping version " + keptVersion + ")" : "";
+                    context.detail(
+                            "Removed duplicate plugin declaration for " + key + versionInfo + " in " + sectionName);
+                }
+            }
+        }
+
+        duplicates.forEach(DomUtils::removeElement);
+
+        return !duplicates.isEmpty();
+    }
+
+    /**
+     * Creates a unique key for a plugin based on groupId and artifactId.
+     * Defaults groupId to org.apache.maven.plugins for Maven plugins.
+     */
+    private String createPluginKey(Element plugin) {
+        String groupId = plugin.childText(MavenPomElements.Elements.GROUP_ID);
+        String artifactId = plugin.childText(MavenPomElements.Elements.ARTIFACT_ID);
+
+        if (groupId == null && artifactId != null && artifactId.startsWith(MAVEN_PLUGIN_PREFIX)) {
+            groupId = DEFAULT_MAVEN_PLUGIN_GROUP_ID;
+        }
+
+        return (groupId != null && artifactId != null) ? groupId + ":" + artifactId : null;
+    }
+
+    private record DependencyContainer(Element element, String sectionName) {}
+
+    private record BuildContainer(Element element, String sectionName) {}
+}
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/EnforcerVersionRangeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/EnforcerVersionRangeStrategy.java
new file mode 100644
index 0000000000..c3eefbf246
--- /dev/null
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/EnforcerVersionRangeStrategy.java
@@ -0,0 +1,286 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import eu.maveniverse.domtrip.Document;
+import eu.maveniverse.domtrip.Editor;
+import eu.maveniverse.domtrip.Element;
+import org.apache.maven.api.cli.mvnup.UpgradeOptions;
+import org.apache.maven.api.di.Named;
+import org.apache.maven.api.di.Priority;
+import org.apache.maven.api.di.Singleton;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.ARTIFACT_ID;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.BUILD;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.CONFIGURATION;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.GROUP_ID;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGINS;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN_MANAGEMENT;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILE;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILES;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.VERSION;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Plugins.DEFAULT_MAVEN_PLUGIN_GROUP_ID;
+
+/**
+ * Strategy for widening {@code requireMavenVersion} ranges in the {@code maven-enforcer-plugin}
+ * to allow Maven 4.
+ *
+ * <p>Many projects use the {@code maven-enforcer-plugin} with a {@code requireMavenVersion} rule
+ * that has an exclusive upper bound at version 4 (e.g., {@code [3.8.8,4)}, {@code [3,4)}),
+ * which blocks Maven 4 builds. This strategy widens such ranges to allow Maven 4 by changing
+ * the upper bound to 5 (e.g., {@code [3.8.8,4)} becomes {@code [3.8.8,5)}).
+ *
+ * <p>The strategy handles:
+ * <ul>
+ *   <li>{@code <configuration><rules><requireMavenVersion>} in plugin declarations</li>
+ *   <li>{@code <executions><execution><configuration><rules><requireMavenVersion>} in executions</li>
+ *   <li>Both {@code build/plugins} and {@code build/pluginManagement/plugins} sections</li>
+ *   <li>Profile-scoped enforcer plugin declarations</li>
+ * </ul>
+ */
+@Named
+@Singleton
+@Priority(18)
+public class EnforcerVersionRangeStrategy extends AbstractUpgradeStrategy {
+
+    private static final String ENFORCER_ARTIFACT_ID = "maven-enforcer-plugin";
+
+    private static final String RULES = "rules";
+    private static final String REQUIRE_MAVEN_VERSION = "requireMavenVersion";
+    private static final String EXECUTIONS = "executions";
+    private static final String EXECUTION = "execution";
+
+    /**
+     * Pattern to match Maven version ranges with an exclusive upper bound at any 4.x version.
+     * Captures:
+     *   Group 1: opening bracket ([ or ()
+     *   Group 2: lower bound (e.g., 3.8.8, 3, 3.6.3)
+     *   Group 3: upper bound starting with 4 (e.g., 4, 4.0, 4.0.0, 4.1, 4.2.1)
+     *
+     * Examples matched: [3.8.8,4), [3,4), (3.6.3,4), [3.8.8,4.0), [3.8.8,4.0.0), [3.8.8,4.1)
+     * Examples not matched: [3.8.8,), 3.8.8, [3.8.8,5), [3.8.8,4]
+     */
+    static final Pattern MAVEN4_EXCLUSIVE_UPPER_BOUND = Pattern.compile("^(\\[|\\()(.+?),\\s*(4(?:\\.\\d+)*)\\s*\\)$");
+
+    @Override
+    public boolean isApplicable(UpgradeContext context) {
+        UpgradeOptions options = getOptions(context);
+        return isOptionEnabled(options, options.model(), true);
+    }
+
+    @Override
+    public String getDescription() {
+        return "Widening RequireMavenVersion ranges to allow Maven 4";
+    }
+
+    @Override
+    protected UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap) {
+        Set<Path> processedPoms = new HashSet<>();
+        Set<Path> modifiedPoms = new HashSet<>();
+        Set<Path> errorPoms = new HashSet<>();
+
+        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
+            Path pomPath = entry.getKey();
+            Document pomDocument = entry.getValue();
+            processedPoms.add(pomPath);
+
+            context.info(pomPath + " (checking for RequireMavenVersion range restrictions)");
+            context.indent();
+
+            try {
+                boolean hasUpgrades = widenEnforcerVersionRanges(pomDocument, context);
+
+                if (hasUpgrades) {
+                    modifiedPoms.add(pomPath);
+                    context.success("RequireMavenVersion ranges widened to allow Maven 4");
+                } else {
+                    context.success("No RequireMavenVersion range restrictions found");
+                }
+            } catch (Exception e) {
+                context.failure("Failed to widen RequireMavenVersion ranges: " + e.getMessage());
+                errorPoms.add(pomPath);
+            } finally {
+                context.unindent();
+            }
+        }
+
+        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);
+    }
+
+    /**
+     * Finds and widens all RequireMavenVersion ranges in the POM document.
+     */
+    private boolean widenEnforcerVersionRanges(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+        boolean hasUpgrades = false;
+
+        // Process root-level build/plugins and build/pluginManagement/plugins
+        hasUpgrades |= processPluginSections(root, context);
+
+        // Process profile-scoped plugins
+        Element profiles = root.childElement(PROFILES).orElse(null);
+        if (profiles != null) {
+            for (Element profile : profiles.childElements(PROFILE).toList()) {
+                hasUpgrades |= processPluginSections(profile, context);
+            }
+        }
+
+        return hasUpgrades;
+    }
+
+    /**
+     * Processes both build/plugins and build/pluginManagement/plugins sections.
+     */
+    private boolean processPluginSections(Element parent, UpgradeContext context) {
+        Element buildElement = parent.childElement(BUILD).orElse(null);
+        if (buildElement == null) {
+            return false;
+        }
+
+        boolean hasUpgrades = false;
+
+        // Check build/plugins
+        Element pluginsElement = buildElement.childElement(PLUGINS).orElse(null);
+        if (pluginsElement != null) {
+            hasUpgrades |= processPluginsForEnforcer(pluginsElement, context);
+        }
+
+        // Check build/pluginManagement/plugins
+        Element pluginManagement = buildElement.childElement(PLUGIN_MANAGEMENT).orElse(null);
+        if (pluginManagement != null) {
+            Element managedPlugins = pluginManagement.childElement(PLUGINS).orElse(null);
+            if (managedPlugins != null) {
+                hasUpgrades |= processPluginsForEnforcer(managedPlugins, context);
+            }
+        }
+
+        return hasUpgrades;
+    }
+
+    /**
+     * Finds enforcer plugin elements and processes their requireMavenVersion rules.
+     */
+    private boolean processPluginsForEnforcer(Element pluginsElement, UpgradeContext context) {
+        return pluginsElement
+                .childElements(PLUGIN)
+                .filter(this::isEnforcerPlugin)
+                .map(plugin -> processEnforcerPlugin(plugin, context))
+                .reduce(false, Boolean::logicalOr);
+    }
+
+    /**
+     * Checks whether a plugin element is the maven-enforcer-plugin.
+     */
+    private boolean isEnforcerPlugin(Element plugin) {
+        String artifactId = plugin.childTextTrimmed(ARTIFACT_ID);
+        if (!ENFORCER_ARTIFACT_ID.equals(artifactId)) {
+            return false;
+        }
+        String groupId = plugin.childTextTrimmed(GROUP_ID);
+        return groupId == null || groupId.isEmpty() || DEFAULT_MAVEN_PLUGIN_GROUP_ID.equals(groupId);
+    }
+
+    /**
+     * Processes an enforcer plugin element, checking both top-level configuration
+     * and per-execution configurations for requireMavenVersion rules.
+     */
+    private boolean processEnforcerPlugin(Element plugin, UpgradeContext context) {
+        boolean hasUpgrades = false;
+
+        // Check top-level <configuration><rules><requireMavenVersion>
+        Element configuration = plugin.childElement(CONFIGURATION).orElse(null);
+        if (configuration != null) {
+            hasUpgrades |= processRulesElement(configuration, context);
+        }
+
+        // Check <executions><execution><configuration><rules><requireMavenVersion>
+        Element executionsElement = plugin.childElement(EXECUTIONS).orElse(null);
+        if (executionsElement != null) {
+            for (Element execution : executionsElement.childElements(EXECUTION).toList()) {
+                Element execConfig = execution.childElement(CONFIGURATION).orElse(null);
+                if (execConfig != null) {
+                    hasUpgrades |= processRulesElement(execConfig, context);
+                }
+            }
+        }
+
+        return hasUpgrades;
+    }
+
+    /**
+     * Processes a configuration element's rules for requireMavenVersion.
+     */
+    private boolean processRulesElement(Element configuration, UpgradeContext context) {
+        Element rules = configuration.childElement(RULES).orElse(null);
+        if (rules == null) {
+            return false;
+        }
+
+        Element requireMavenVersion = rules.childElement(REQUIRE_MAVEN_VERSION).orElse(null);
+        if (requireMavenVersion == null) {
+            return false;
+        }
+
+        Element versionElement = requireMavenVersion.childElement(VERSION).orElse(null);
+        if (versionElement == null) {
+            return false;
+        }
+
+        String versionRange = versionElement.textContentTrimmed();
+        if (versionRange == null || versionRange.isEmpty()) {
+            return false;
+        }
+
+        String widened = widenVersionRange(versionRange);
+        if (widened != null) {
+            Editor editor = new Editor(versionElement.document());
+            editor.setTextContent(versionElement, widened);
+            context.detail(
+                    "Widened RequireMavenVersion range from " + versionRange + " to " + widened + " to allow Maven 4");
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Widens a Maven version range that has an exclusive upper bound at 4.x.
+     *
+     * @param versionRange the version range string (e.g., "[3.8.8,4)")
+     * @return the widened range (e.g., "[3.8.8,5)"), or null if no widening is needed
+     */
+    static String widenVersionRange(String versionRange) {
+        Matcher matcher = MAVEN4_EXCLUSIVE_UPPER_BOUND.matcher(versionRange);
+        if (matcher.matches()) {
+            String openBracket = matcher.group(1);
+            String lowerBound = matcher.group(2);
+            return openBracket + lowerBound + ",5)";
+        }
+        return null;
+    }
+}
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java
index abf89d03d0..46bcb1e8b5 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategy.java
@@ -26,7 +26,6 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import eu.maveniverse.domtrip.Comment;
 import eu.maveniverse.domtrip.Document;
 import eu.maveniverse.domtrip.Editor;
 import eu.maveniverse.domtrip.Element;
@@ -46,6 +45,7 @@
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.BUILD;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCIES;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY_MANAGEMENT;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.GROUP_ID;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PARENT;
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN;
@@ -58,8 +58,8 @@
 import static eu.maveniverse.domtrip.maven.MavenPomElements.Plugins.MAVEN_PLUGIN_PREFIX;
 
 /**
- * Strategy for upgrading Maven plugins to recommended versions.
- * Handles plugin version upgrades in build/plugins and build/pluginManagement sections.
+ * Strategy for upgrading Maven plugins to recommended versions. Handles plugin version upgrades in build/plugins and
+ * build/pluginManagement sections.
  */
 @Named
 @Singleton
@@ -103,7 +103,19 @@ public class PluginUpgradeStrategy extends AbstractUpgradeStrategy {
                     "org.codehaus.mojo",
                     "jaxb2-maven-plugin",
                     "3.2.0",
-                    "Versions before 3.2.0 depend on jaxb-parent:3.0.0 which contains invalid XML rejected by Maven 4"));
+                    "Versions before 3.2.0 depend on jaxb-parent:3.0.0 which contains invalid XML rejected by Maven 4"),
+            new PluginUpgrade(
+                    "io.quarkus", "quarkus-maven-plugin", "3.26.0", "Maven 4 compatibility (Aether API changes)"),
+            new PluginUpgrade(
+                    "io.quarkus.platform",
+                    "quarkus-maven-plugin",
+                    "3.26.0",
+                    "Maven 4 compatibility (Aether API changes)"),
+            new PluginUpgrade(
+                    "org.codehaus.gmavenplus",
+                    "gmavenplus-plugin",
+                    "4.2.0",
+                    "Versions before 4.2.0 call mutating methods on immutable lists returned by Maven 4 API"));
 
     private static final List<PluginUpgrade> PLUGIN_DEPENDENCY_UPGRADES = List.of(new PluginUpgrade(
             "org.codehaus.mojo",
@@ -202,9 +214,8 @@ public UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap)
     }
 
     /**
-     * Upgrades plugins in the document.
-     * Checks both build/plugins and build/pluginManagement/plugins sections.
-     * Only processes plugins explicitly defined in the current POM document.
+     * Upgrades plugins in the document. Checks both build/plugins and build/pluginManagement/plugins sections. Only
+     * processes plugins explicitly defined in the current POM document.
      */
     private boolean upgradePluginsInDocument(Document pomDocument, UpgradeContext context) {
         Element root = pomDocument.root();
@@ -283,6 +294,15 @@ private Map<String, PluginUpgradeInfo> getPluginUpgradesMap() {
         upgrades.put(
                 "org.codehaus.mojo:jaxb2-maven-plugin",
                 new PluginUpgradeInfo("org.codehaus.mojo", "jaxb2-maven-plugin", "3.2.0"));
+        upgrades.put(
+                "io.quarkus:quarkus-maven-plugin",
+                new PluginUpgradeInfo("io.quarkus", "quarkus-maven-plugin", "3.26.0"));
+        upgrades.put(
+                "io.quarkus.platform:quarkus-maven-plugin",
+                new PluginUpgradeInfo("io.quarkus.platform", "quarkus-maven-plugin", "3.26.0"));
+        upgrades.put(
+                "org.codehaus.gmavenplus:gmavenplus-plugin",
+                new PluginUpgradeInfo("org.codehaus.gmavenplus", "gmavenplus-plugin", "4.2.0"));
         return upgrades;
     }
 
@@ -352,7 +372,32 @@ private boolean upgradePluginVersion(
             return false;
         }
 
+        // For Quarkus plugins, check the platform version before upgrading.
+        // Upgrading quarkus-maven-plugin to 3.x when the project uses Quarkus 2.x
+        // causes NoSuchMethodError and build failures.
+        if (isQuarkusPlugin(upgrade.groupId, upgrade.artifactId)) {
+            String platformVersion = detectQuarkusPlatformVersion(pomDocument);
+            if (platformVersion != null) {
+                int majorVersion = extractMajorVersion(platformVersion);
+                if (majorVersion >= 0 && majorVersion < 3) {
+                    context.warning("Skipping quarkus-maven-plugin upgrade: project uses Quarkus platform "
+                            + majorVersion + ".x (" + platformVersion
+                            + ") which is incompatible with plugin 3.x");
+                    return false;
+                }
+            } else {
+                context.warning("Could not determine Quarkus platform version — if the project uses "
+                        + "Quarkus 2.x, the plugin upgrade may cause build failures");
+            }
+        }
+
         if (isProperty) {
+            // For Quarkus plugins, check if the property is shared with a Quarkus BOM
+            if (isQuarkusPlugin(upgrade.groupId, upgrade.artifactId)
+                    && isPropertyUsedByQuarkusBom(pomDocument, propertyName)) {
+                return decoupleQuarkusPluginVersion(
+                        pomDocument, versionElement, propertyName, upgrade, sectionName, context);
+            }
             // Update property value if it's below minimum version
             return upgradePropertyVersion(pomDocument, propertyName, upgrade, sectionName, context);
         } else {
@@ -392,11 +437,9 @@ private boolean upgradePropertyVersion(
                 String currentVersion = propertyElement.textContentTrimmed();
                 if (isVersionBelow(currentVersion, upgrade.minVersion)) {
                     editor.setTextContent(propertyElement, upgrade.minVersion);
-                    context.detail("Upgraded property " + propertyName + " (for " + upgrade.groupId
-                            + ":"
-                            + upgrade.artifactId + ") from " + currentVersion + " to " + upgrade.minVersion
-                            + " in "
-                            + sectionName);
+                    context.detail(
+                            "Upgraded property " + propertyName + " (for " + upgrade.groupId + ":" + upgrade.artifactId
+                                    + ") from " + currentVersion + " to " + upgrade.minVersion + " in " + sectionName);
                     return true;
                 } else {
                     context.debug("Property " + propertyName + " version " + currentVersion + " is already >= "
@@ -453,8 +496,8 @@ private Map<String, PluginUpgradeInfo> getPluginDependencyUpgradesMap() {
     }
 
     /**
-     * Simple version comparison to check if current version is below minimum version.
-     * This is a basic implementation that works for most Maven plugin versions.
+     * Simple version comparison to check if current version is below minimum version. This is a basic implementation
+     * that works for most Maven plugin versions.
      */
     private boolean isVersionBelow(String currentVersion, String minVersion) {
         if (currentVersion == null || minVersion == null) {
@@ -479,9 +522,8 @@ public static List<PluginUpgrade> getPluginUpgrades() {
     }
 
     /**
-     * Analyzes plugins using effective models built from the temp directory.
-     * Returns analysis results with two maps: plugins needing pluginManagement entries
-     * and plugins needing direct build/plugins overrides.
+     * Analyzes plugins using effective models built from the temp directory. Returns analysis results with two maps:
+     * plugins needing pluginManagement entries and plugins needing direct build/plugins overrides.
      */
     private PluginAnalysisResults analyzePluginsUsingEffectiveModels(
             UpgradeContext context, Map<Path, Document> pomMap, Path tempDir) {
@@ -547,10 +589,9 @@ private PluginAnalysis analyzeEffectiveModelForPlugins(
     }
 
     /**
-     * Analyzes plugins from the effective model and determines which ones need upgrades.
-     * Separates plugins into those overridable via pluginManagement and those requiring
-     * a direct build/plugins entry (because the version is set explicitly in an inherited
-     * parent's build/plugins, not via pluginManagement).
+     * Analyzes plugins from the effective model and determines which ones need upgrades. Separates plugins into those
+     * overridable via pluginManagement and those requiring a direct build/plugins entry (because the version is set
+     * explicitly in an inherited parent's build/plugins, not via pluginManagement).
      */
     private PluginAnalysis analyzePluginsFromEffectiveModel(
             UpgradeContext context, Model effectiveModel, Map<String, PluginUpgrade> pluginUpgrades) {
@@ -630,9 +671,9 @@ private String getPluginKey(Plugin plugin) {
     }
 
     /**
-     * Finds the last local parent in the hierarchy where plugin management should be added.
-     * This implements the algorithm: start with the effective model, check if parent is in pomMap,
-     * if so continue to its parent, else that's the target.
+     * Finds the last local parent in the hierarchy where plugin management should be added. This implements the
+     * algorithm: start with the effective model, check if parent is in pomMap, if so continue to its parent, else
+     * that's the target.
      */
     private Path findLastLocalParentForPluginManagement(
             UpgradeContext context, Path tempPomPath, Map<Path, Document> pomMap, Path tempDir, Path commonRoot) {
@@ -781,7 +822,8 @@ private void addPluginManagementEntryFromUpgrade(
                 managedPluginsElement, upgrade.groupId(), upgrade.artifactId(), upgrade.minVersion());
 
         if (fromRemoteParent) {
-            managedPluginsElement.insertChildBefore(plugin, Comment.of(" Override version inherited from parent "));
+            new Editor(managedPluginsElement.document())
+                    .insertCommentBefore(plugin, " Override version inherited from parent ");
             context.detail("Added plugin management for " + upgrade.groupId() + ":" + upgrade.artifactId() + " version "
                     + upgrade.minVersion() + " (overrides version inherited from parent)");
         } else {
@@ -791,9 +833,8 @@ private void addPluginManagementEntryFromUpgrade(
     }
 
     /**
-     * Adds direct plugin entries in build/plugins for plugins inherited from remote parents.
-     * This is necessary when a parent POM sets an explicit version in its build/plugins
-     * that pluginManagement alone cannot override.
+     * Adds direct plugin entries in build/plugins for plugins inherited from remote parents. This is necessary when a
+     * parent POM sets an explicit version in its build/plugins that pluginManagement alone cannot override.
      */
     private boolean addDirectPluginOverrides(
             UpgradeContext context, Document pomDocument, Set<String> pluginKeys, Set<String> localPluginKeys) {
@@ -819,13 +860,12 @@ private boolean addDirectPluginOverrides(
                     Element plugin = DomUtils.createPlugin(
                             pluginsElement, upgrade.groupId(), upgrade.artifactId(), upgrade.minVersion());
                     if (!localPluginKeys.contains(pluginKey)) {
-                        pluginsElement.insertChildBefore(
-                                plugin, Comment.of(" Override version inherited from parent "));
+                        new Editor(pluginsElement.document())
+                                .insertCommentBefore(plugin, " Override version inherited from parent ");
                     }
                     hasUpgrades = true;
                     context.detail("Added " + upgrade.groupId() + ":" + upgrade.artifactId() + " version "
-                            + upgrade.minVersion()
-                            + " in build/plugins (overrides version locked by parent)");
+                            + upgrade.minVersion() + " in build/plugins (overrides version locked by parent)");
                 }
             }
         }
@@ -875,9 +915,254 @@ private record PluginAnalysisResults(
             Map<Path, Set<String>> pluginsNeedingManagement, Map<Path, Set<String>> pluginsNeedingDirectOverride) {}
 
     /**
-     * Holds plugin upgrade information for Maven 4 compatibility.
-     * This class contains the minimum version requirements for plugins
-     * that need to be upgraded to work properly with Maven 4.
+     * Checks if the given plugin is a Quarkus Maven plugin.
+     */
+    private boolean isQuarkusPlugin(String groupId, String artifactId) {
+        return "quarkus-maven-plugin".equals(artifactId)
+                && ("io.quarkus".equals(groupId) || "io.quarkus.platform".equals(groupId));
+    }
+
+    /**
+     * Detects the Quarkus platform version used by the project.
+     *
+     * <p>Checks the following sources in order:
+     * <ol>
+     *   <li>{@code <dependencyManagement>} for {@code io.quarkus.platform:quarkus-bom}
+     *       or {@code io.quarkus:quarkus-bom} — extracts the version (resolving property references)</li>
+     *   <li>Properties: {@code quarkus.platform.version}, {@code quarkus.version},
+     *       {@code quarkus-plugin.version}</li>
+     * </ol>
+     *
+     * @param pomDocument the POM document to inspect
+     * @return the detected Quarkus platform version string, or {@code null} if not found
+     */
+    String detectQuarkusPlatformVersion(Document pomDocument) {
+        Element root = pomDocument.root();
+
+        // 1. Check dependencyManagement for Quarkus BOM
+        Element depManagement = root.childElement(DEPENDENCY_MANAGEMENT).orElse(null);
+        if (depManagement != null) {
+            Element dependencies = depManagement.childElement(DEPENDENCIES).orElse(null);
+            if (dependencies != null) {
+                String bomVersion = dependencies
+                        .childElements(DEPENDENCY)
+                        .filter(dep -> {
+                            String gid = getChildText(dep, GROUP_ID);
+                            String aid = getChildText(dep, ARTIFACT_ID);
+                            return ("io.quarkus.platform".equals(gid) || "io.quarkus".equals(gid))
+                                    && "quarkus-bom".equals(aid);
+                        })
+                        .map(dep -> getChildText(dep, VERSION))
+                        .filter(v -> v != null && !v.isEmpty())
+                        .findFirst()
+                        .orElse(null);
+
+                if (bomVersion != null) {
+                    // Resolve property reference if needed
+                    String resolved = resolvePropertyValue(root, bomVersion);
+                    if (resolved != null) {
+                        return resolved;
+                    }
+                }
+            }
+        }
+
+        // 2. Check well-known properties
+        Element propertiesElement = root.childElement(PROPERTIES).orElse(null);
+        if (propertiesElement != null) {
+            for (String propName : List.of("quarkus.platform.version", "quarkus.version", "quarkus-plugin.version")) {
+                Element prop = propertiesElement.childElement(propName).orElse(null);
+                if (prop != null) {
+                    String value = prop.textContentTrimmed();
+                    if (value != null && !value.isEmpty() && !value.startsWith("${")) {
+                        return value;
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Resolves a version string that may be a property reference (e.g., {@code ${quarkus.version}}).
+     * Returns the resolved value, or the original string if not a property reference,
+     * or {@code null} if the property cannot be resolved.
+     */
+    private String resolvePropertyValue(Element root, String value) {
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+        if (!value.startsWith("${") || !value.endsWith("}")) {
+            return value;
+        }
+        String propertyName = value.substring(2, value.length() - 1);
+        Element propertiesElement = root.childElement(PROPERTIES).orElse(null);
+        if (propertiesElement != null) {
+            Element prop = propertiesElement.childElement(propertyName).orElse(null);
+            if (prop != null) {
+                String resolved = prop.textContentTrimmed();
+                if (resolved != null && !resolved.isEmpty() && !resolved.startsWith("${")) {
+                    return resolved;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Extracts the major version number from a version string (e.g., "2" from "2.16.7.Final").
+     *
+     * @return the major version number, or -1 if it cannot be parsed
+     */
+    private int extractMajorVersion(String version) {
+        if (version == null || version.isEmpty()) {
+            return -1;
+        }
+        String[] parts = version.split("\\.");
+        try {
+            return Integer.parseInt(parts[0]);
+        } catch (NumberFormatException e) {
+            return -1;
+        }
+    }
+
+    /**
+     * Checks if a property is used as the version of a Quarkus BOM in dependencyManagement.
+     * Quarkus BOMs are identified by having groupId io.quarkus or io.quarkus.platform,
+     * type "pom", and scope "import".
+     */
+    private boolean isPropertyUsedByQuarkusBom(Document pomDocument, String propertyName) {
+        Element root = pomDocument.root();
+        String propertyRef = "${" + propertyName + "}";
+
+        Element depManagement = root.childElement(DEPENDENCY_MANAGEMENT).orElse(null);
+        if (depManagement == null) {
+            return false;
+        }
+        Element dependencies = depManagement.childElement(DEPENDENCIES).orElse(null);
+        if (dependencies == null) {
+            return false;
+        }
+
+        return dependencies.childElements(DEPENDENCY).anyMatch(dep -> {
+            String groupId = getChildText(dep, GROUP_ID);
+            String version = getChildText(dep, VERSION);
+            String type = getChildText(dep, "type");
+            String scope = getChildText(dep, "scope");
+            return ("io.quarkus".equals(groupId) || "io.quarkus.platform".equals(groupId))
+                    && "pom".equals(type)
+                    && "import".equals(scope)
+                    && propertyRef.equals(version);
+        });
+    }
+
+    /**
+     * Decouples the Quarkus plugin version from a shared BOM property.
+     * Introduces a new property for the plugin version and updates the plugin's version element,
+     * leaving the BOM property unchanged.
+     */
+    private boolean decoupleQuarkusPluginVersion(
+            Document pomDocument,
+            Element versionElement,
+            String sharedPropertyName,
+            PluginUpgradeInfo upgrade,
+            String sectionName,
+            UpgradeContext context) {
+
+        // Resolve the current version from the shared property
+        Editor editor = new Editor(pomDocument);
+        Element root = editor.root();
+        Element propertiesElement = root.childElement(PROPERTIES).orElse(null);
+        String currentVersion = null;
+        if (propertiesElement != null) {
+            Element sharedProp =
+                    propertiesElement.childElement(sharedPropertyName).orElse(null);
+            if (sharedProp != null) {
+                currentVersion = sharedProp.textContentTrimmed();
+            }
+        }
+
+        if (currentVersion == null) {
+            // Property is inherited from parent — we cannot resolve its actual value here,
+            // so skip decoupling to avoid introducing a potentially unnecessary property
+            // that could downgrade an already-sufficient inherited version.
+            context.debug("Shared property " + sharedPropertyName
+                    + " not found in current POM (may be inherited) — skipping version decoupling");
+            return false;
+        }
+
+        if (!isVersionBelow(currentVersion, upgrade.minVersion)) {
+            context.debug("Quarkus plugin version (via shared property " + sharedPropertyName + ") " + currentVersion
+                    + " is already >= " + upgrade.minVersion);
+            return false;
+        }
+
+        // Introduce a new property for the plugin version
+        String newPropertyName = "quarkus-plugin.version";
+        if (propertiesElement == null) {
+            propertiesElement = DomUtils.insertNewElement(PROPERTIES, root);
+        }
+
+        // Add the new property if it doesn't already exist
+        Element existingProp = propertiesElement.childElement(newPropertyName).orElse(null);
+        if (existingProp != null) {
+            // Property already exists — update its value
+            editor.setTextContent(existingProp, upgrade.minVersion);
+        } else {
+            DomUtils.insertContentElement(propertiesElement, newPropertyName, upgrade.minVersion);
+        }
+
+        // Update the plugin's version element to reference the new property
+        editor.setTextContent(versionElement, "${" + newPropertyName + "}");
+
+        context.detail("Decoupled " + upgrade.groupId + ":" + upgrade.artifactId + " version from shared property "
+                + sharedPropertyName + ": introduced " + newPropertyName + "=" + upgrade.minVersion + " in "
+                + sectionName);
+
+        // Emit version gap warning
+        if (currentVersion != null) {
+            emitVersionGapWarning(context, currentVersion, upgrade.minVersion);
+        }
+
+        return true;
+    }
+
+    /**
+     * Emits a warning if the Quarkus platform BOM version is significantly older than the plugin version.
+     * Mismatched plugin and platform versions may cause unexpected behavior because the plugin
+     * is designed and tested against a specific platform version.
+     */
+    private void emitVersionGapWarning(UpgradeContext context, String platformVersion, String pluginVersion) {
+        // Only warn when there's a meaningful gap (different minor version)
+        String platformMinor = extractMinorVersion(platformVersion);
+        String pluginMinor = extractMinorVersion(pluginVersion);
+
+        if (platformMinor != null && pluginMinor != null && !platformMinor.equals(pluginMinor)) {
+            context.warning("quarkus-maven-plugin upgraded to " + pluginVersion
+                    + " for Maven 4 compatibility. Your Quarkus platform is still at " + platformVersion
+                    + ". Consider upgrading the platform to match — mismatched plugin and platform"
+                    + " versions may cause unexpected behavior.");
+        }
+    }
+
+    /**
+     * Extracts the minor version component (e.g., "26" from "3.26.0").
+     */
+    private String extractMinorVersion(String version) {
+        if (version == null) {
+            return null;
+        }
+        String[] parts = version.split("\\.");
+        if (parts.length >= 2) {
+            return parts[1];
+        }
+        return null;
+    }
+
+    /**
+     * Holds plugin upgrade information for Maven 4 compatibility. This class contains the minimum version requirements
+     * for plugins that need to be upgraded to work properly with Maven 4.
      */
     public static class PluginUpgradeInfo {
         /** The Maven groupId of the plugin */
@@ -892,9 +1177,12 @@ public static class PluginUpgradeInfo {
         /**
          * Creates a new plugin upgrade information holder.
          *
-         * @param groupId the Maven groupId of the plugin
-         * @param artifactId the Maven artifactId of the plugin
-         * @param minVersion the minimum version required for Maven 4 compatibility
+         * @param groupId
+         *            the Maven groupId of the plugin
+         * @param artifactId
+         *            the Maven artifactId of the plugin
+         * @param minVersion
+         *            the minimum version required for Maven 4 compatibility
          */
         PluginUpgradeInfo(String groupId, String artifactId, String minVersion) {
             this.groupId = groupId;
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/RepositoryHttpsUpgradeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/RepositoryHttpsUpgradeStrategy.java
new file mode 100644
index 0000000000..04fdad2140
--- /dev/null
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/RepositoryHttpsUpgradeStrategy.java
@@ -0,0 +1,290 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import eu.maveniverse.domtrip.Document;
+import eu.maveniverse.domtrip.Editor;
+import eu.maveniverse.domtrip.Element;
+import org.apache.maven.api.cli.mvnup.UpgradeOptions;
+import org.apache.maven.api.di.Named;
+import org.apache.maven.api.di.Priority;
+import org.apache.maven.api.di.Singleton;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN_REPOSITORIES;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN_REPOSITORY;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILE;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILES;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.REPOSITORIES;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.REPOSITORY;
+
+/**
+ * Strategy for upgrading HTTP repository URLs to HTTPS in POM files.
+ *
+ * <p>Since Maven 3.8.1+, HTTP repositories are blocked by the {@code maven-default-http-blocker}
+ * mirror, so any {@code http://} repository URL will cause build failures. This strategy
+ * automatically converts {@code http://} URLs to {@code https://}, using canonical HTTPS URLs
+ * for well-known repositories.
+ *
+ * <p>The strategy handles:
+ * <ul>
+ *   <li>{@code <repositories>/<repository>} URLs</li>
+ *   <li>{@code <pluginRepositories>/<pluginRepository>} URLs</li>
+ *   <li>{@code <distributionManagement>/<repository>} and {@code <snapshotRepository>} URLs</li>
+ *   <li>Profile-scoped repositories in all of the above sections</li>
+ * </ul>
+ */
+@Named
+@Singleton
+@Priority(15)
+public class RepositoryHttpsUpgradeStrategy extends AbstractUpgradeStrategy {
+
+    private static final String HTTP_SCHEME = "http://";
+
+    private static final String DISTRIBUTION_MANAGEMENT = "distributionManagement";
+    private static final String SNAPSHOT_REPOSITORY = "snapshotRepository";
+
+    /**
+     * Well-known repository URL mappings from HTTP to their canonical HTTPS equivalents.
+     * Uses a LinkedHashMap to preserve insertion order for predictable iteration.
+     */
+    private static final Map<String, String> WELL_KNOWN_URL_MAPPINGS = createWellKnownMappings();
+
+    private static Map<String, String> createWellKnownMappings() {
+        Map<String, String> mappings = new LinkedHashMap<>();
+        // Apache repository URLs
+        mappings.put("http://repository.apache.org/snapshots", "https://repository.apache.org/snapshots");
+        mappings.put("http://repository.apache.org/releases", "https://repository.apache.org/releases");
+        // Maven Central variants - all map to the canonical HTTPS URL
+        mappings.put("http://repo1.maven.org/maven2", "https://repo.maven.apache.org/maven2");
+        mappings.put("http://repo.maven.apache.org/maven2", "https://repo.maven.apache.org/maven2");
+        mappings.put("http://central.maven.org/maven2", "https://repo.maven.apache.org/maven2");
+        return mappings;
+    }
+
+    @Override
+    public boolean isApplicable(UpgradeContext context) {
+        UpgradeOptions options = getOptions(context);
+        return isOptionEnabled(options, options.model(), true);
+    }
+
+    @Override
+    public String getDescription() {
+        return "Upgrading HTTP repository URLs to HTTPS";
+    }
+
+    @Override
+    protected UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap) {
+        Set<Path> processedPoms = new HashSet<>();
+        Set<Path> modifiedPoms = new HashSet<>();
+        Set<Path> errorPoms = new HashSet<>();
+
+        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
+            Path pomPath = entry.getKey();
+            Document pomDocument = entry.getValue();
+            processedPoms.add(pomPath);
+
+            context.info(pomPath + " (checking for HTTP repository URLs)");
+            context.indent();
+
+            try {
+                boolean hasUpgrades = upgradeRepositoryUrls(pomDocument, context);
+
+                if (hasUpgrades) {
+                    modifiedPoms.add(pomPath);
+                    context.success("HTTP repository URLs upgraded to HTTPS");
+                } else {
+                    context.success("No HTTP repository URLs found");
+                }
+            } catch (Exception e) {
+                context.failure("Failed to upgrade repository URLs: " + e.getMessage());
+                errorPoms.add(pomPath);
+            } finally {
+                context.unindent();
+            }
+        }
+
+        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);
+    }
+
+    /**
+     * Upgrades all HTTP repository URLs in the POM document to HTTPS.
+     *
+     * @param pomDocument the POM document to process
+     * @param context the upgrade context for logging
+     * @return true if any URLs were upgraded
+     */
+    private boolean upgradeRepositoryUrls(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+        boolean hasUpgrades = false;
+
+        // Process root-level repositories and pluginRepositories
+        hasUpgrades |= upgradeRepositoriesSection(root, REPOSITORIES, REPOSITORY, "repositories", context);
+        hasUpgrades |=
+                upgradeRepositoriesSection(root, PLUGIN_REPOSITORIES, PLUGIN_REPOSITORY, "pluginRepositories", context);
+
+        // Process distributionManagement
+        hasUpgrades |= upgradeDistributionManagement(root, "distributionManagement", context);
+
+        // Process profile-scoped repositories
+        hasUpgrades |= upgradeProfileRepositories(root, context);
+
+        return hasUpgrades;
+    }
+
+    /**
+     * Upgrades repository URLs in a repositories or pluginRepositories section.
+     */
+    private boolean upgradeRepositoriesSection(
+            Element parent, String containerName, String elementType, String sectionLabel, UpgradeContext context) {
+        Element container = parent.childElement(containerName).orElse(null);
+        if (container == null) {
+            return false;
+        }
+
+        return container
+                .childElements(elementType)
+                .map(repo -> upgradeUrlElement(repo, sectionLabel, context))
+                .reduce(false, Boolean::logicalOr);
+    }
+
+    /**
+     * Upgrades repository and snapshotRepository URLs in the distributionManagement section.
+     */
+    private boolean upgradeDistributionManagement(Element parent, String sectionLabel, UpgradeContext context) {
+        Element distMgmt = parent.childElement(DISTRIBUTION_MANAGEMENT).orElse(null);
+        if (distMgmt == null) {
+            return false;
+        }
+
+        boolean hasUpgrades = false;
+
+        // Process <distributionManagement>/<repository>
+        Element repository = distMgmt.childElement(REPOSITORY).orElse(null);
+        if (repository != null) {
+            hasUpgrades |= upgradeUrlElement(repository, sectionLabel + "/repository", context);
+        }
+
+        // Process <distributionManagement>/<snapshotRepository>
+        Element snapshotRepository = distMgmt.childElement(SNAPSHOT_REPOSITORY).orElse(null);
+        if (snapshotRepository != null) {
+            hasUpgrades |= upgradeUrlElement(snapshotRepository, sectionLabel + "/snapshotRepository", context);
+        }
+
+        return hasUpgrades;
+    }
+
+    /**
+     * Upgrades repository URLs in profile-scoped sections.
+     */
+    private boolean upgradeProfileRepositories(Element root, UpgradeContext context) {
+        Element profiles = root.childElement(PROFILES).orElse(null);
+        if (profiles == null) {
+            return false;
+        }
+
+        return profiles.childElements(PROFILE)
+                .map(profile -> {
+                    boolean upgraded = false;
+                    upgraded |= upgradeRepositoriesSection(
+                            profile, REPOSITORIES, REPOSITORY, "profile/repositories", context);
+                    upgraded |= upgradeRepositoriesSection(
+                            profile, PLUGIN_REPOSITORIES, PLUGIN_REPOSITORY, "profile/pluginRepositories", context);
+                    upgraded |= upgradeDistributionManagement(profile, "profile/distributionManagement", context);
+                    return upgraded;
+                })
+                .reduce(false, Boolean::logicalOr);
+    }
+
+    /**
+     * Upgrades the URL element of a repository from HTTP to HTTPS.
+     *
+     * @param repositoryElement the repository element containing a url child
+     * @param sectionLabel the section label for logging
+     * @param context the upgrade context for logging
+     * @return true if the URL was upgraded
+     */
+    private boolean upgradeUrlElement(Element repositoryElement, String sectionLabel, UpgradeContext context) {
+        Element urlElement = repositoryElement.childElement("url").orElse(null);
+        if (urlElement == null) {
+            return false;
+        }
+
+        String url = urlElement.textContent();
+        if (url == null) {
+            return false;
+        }
+
+        String trimmedUrl = url.trim();
+        if (!trimmedUrl.startsWith(HTTP_SCHEME)) {
+            return false;
+        }
+
+        String repositoryId = repositoryElement.childText("id");
+        String idLabel = repositoryId != null ? repositoryId : "(no id)";
+
+        // Try well-known URL mappings first
+        String upgradedUrl = mapWellKnownUrl(trimmedUrl);
+        if (upgradedUrl == null) {
+            // Generic http -> https conversion
+            upgradedUrl = "https://" + trimmedUrl.substring(HTTP_SCHEME.length());
+        }
+
+        // Preserve original whitespace around the URL
+        String newUrl = url.replace(trimmedUrl, upgradedUrl);
+        Editor editor = new Editor(repositoryElement.document());
+        editor.setTextContent(urlElement, newUrl);
+
+        context.detail("Upgraded repository URL from " + trimmedUrl + " to " + upgradedUrl + " for " + idLabel + " in "
+                + sectionLabel);
+        return true;
+    }
+
+    /**
+     * Maps a well-known HTTP URL to its canonical HTTPS equivalent.
+     *
+     * @param httpUrl the HTTP URL to map
+     * @return the canonical HTTPS URL, or null if no well-known mapping exists
+     */
+    static String mapWellKnownUrl(String httpUrl) {
+        // Normalize: remove trailing slash for comparison
+        String normalized = httpUrl.endsWith("/") ? httpUrl.substring(0, httpUrl.length() - 1) : httpUrl;
+
+        for (Map.Entry<String, String> mapping : WELL_KNOWN_URL_MAPPINGS.entrySet()) {
+            if (normalized.equals(mapping.getKey()) || normalized.startsWith(mapping.getKey() + "/")) {
+                // Replace the matched prefix with the canonical HTTPS URL,
+                // preserving any trailing path segments
+                String remainder = normalized.substring(mapping.getKey().length());
+                String result = mapping.getValue() + remainder;
+                // Restore trailing slash if original had one
+                if (httpUrl.endsWith("/") && !result.endsWith("/")) {
+                    result += "/";
+                }
+                return result;
+            }
+        }
+        return null;
+    }
+}
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ResourceFilteringStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ResourceFilteringStrategy.java
new file mode 100644
index 0000000000..cc0fb1e9d8
--- /dev/null
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ResourceFilteringStrategy.java
@@ -0,0 +1,426 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import eu.maveniverse.domtrip.Document;
+import eu.maveniverse.domtrip.Element;
+import org.apache.maven.api.cli.mvnup.UpgradeOptions;
+import org.apache.maven.api.di.Named;
+import org.apache.maven.api.di.Priority;
+import org.apache.maven.api.di.Singleton;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.ARTIFACT_ID;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.BUILD;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.CONFIGURATION;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.GROUP_ID;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGINS;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN_MANAGEMENT;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILE;
+import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILES;
+
+/**
+ * Strategy for adding binary file extension exclusions to the maven-resources-plugin
+ * when resource filtering is enabled.
+ *
+ * <p>Maven 4 strictly decodes filtered resources as UTF-8, which causes
+ * {@code MalformedInputException} when binary files (e.g., {@code .xlsx}, {@code .docx})
+ * are present in a resource directory with {@code <filtering>true</filtering>}.
+ * Maven 3 was more lenient and silently handled these files.
+ *
+ * <p>This strategy scans all {@code <resource>} and {@code <testResource>} blocks.
+ * If any resource directory has filtering enabled and the {@code maven-resources-plugin}
+ * does not already declare {@code <nonFilteredFileExtensions>}, this strategy adds a
+ * list of common binary file extensions to prevent the exception.
+ *
+ * @see <a href="https://github.com/apache/maven/issues/12455">#12455</a>
+ */
+@Named
+@Singleton
+@Priority(17)
+public class ResourceFilteringStrategy extends AbstractUpgradeStrategy {
+
+    private static final String RESOURCES = "resources";
+    private static final String TEST_RESOURCES = "testResources";
+    private static final String RESOURCE = "resource";
+    private static final String TEST_RESOURCE = "testResource";
+    private static final String FILTERING = "filtering";
+    private static final String NON_FILTERED_FILE_EXTENSIONS = "nonFilteredFileExtensions";
+    private static final String NON_FILTERED_FILE_EXTENSION = "nonFilteredFileExtension";
+    private static final String MAVEN_RESOURCES_PLUGIN = "maven-resources-plugin";
+    private static final String MAVEN_PLUGINS_GROUP_ID = "org.apache.maven.plugins";
+
+    /**
+     * Common binary file extensions that should not be filtered.
+     * These extensions cover binary formats frequently found in Maven projects that would
+     * cause {@code MalformedInputException} when processed as UTF-8 text.
+     */
+    static final List<String> BINARY_EXTENSIONS = List.of(
+            // Document formats
+            "xlsx",
+            "xls",
+            "docx",
+            "doc",
+            "pptx",
+            "pdf",
+            // Archive and package formats
+            "zip",
+            "tar",
+            "gz",
+            "jar",
+            // Compiled and native binaries
+            "class",
+            "so",
+            "dll",
+            "exe",
+            // Image formats
+            "png",
+            "jpg",
+            "jpeg",
+            "gif",
+            "bmp",
+            "tiff",
+            "ico",
+            // Font formats
+            "woff",
+            "woff2",
+            "ttf",
+            "eot",
+            // Media formats
+            "mp3",
+            "mp4",
+            // Other binary formats
+            "swf",
+            "ser",
+            "keystore",
+            "jks",
+            "p12",
+            "pfx");
+
+    @Override
+    public boolean isApplicable(UpgradeContext context) {
+        UpgradeOptions options = getOptions(context);
+        return isOptionEnabled(options, options.model(), true);
+    }
+
+    @Override
+    public String getDescription() {
+        return "Adding binary file extension exclusions to resource filtering";
+    }
+
+    @Override
+    protected UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap) {
+        Set<Path> processedPoms = new HashSet<>();
+        Set<Path> modifiedPoms = new HashSet<>();
+        Set<Path> errorPoms = new HashSet<>();
+
+        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
+            Path pomPath = entry.getKey();
+            Document pomDocument = entry.getValue();
+            processedPoms.add(pomPath);
+
+            context.info(pomPath + " (checking for resource filtering of binary files)");
+            context.indent();
+
+            try {
+                boolean modified = fixResourceFiltering(pomDocument, context);
+
+                if (modified) {
+                    modifiedPoms.add(pomPath);
+                    context.success("Added nonFilteredFileExtensions to maven-resources-plugin");
+                } else {
+                    context.success("No resource filtering issues found");
+                }
+            } catch (Exception e) {
+                context.failure("Failed to fix resource filtering: " + e.getMessage());
+                errorPoms.add(pomPath);
+            } finally {
+                context.unindent();
+            }
+        }
+
+        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);
+    }
+
+    /**
+     * Checks if any resource or testResource block has filtering enabled,
+     * and if so, ensures the maven-resources-plugin has nonFilteredFileExtensions configured.
+     */
+    private boolean fixResourceFiltering(Document pomDocument, UpgradeContext context) {
+        Element root = pomDocument.root();
+        boolean modified = false;
+
+        // Check root-level build
+        modified |= fixResourceFilteringInBuild(root, pomDocument, context);
+
+        // Check profile-level builds
+        Element profiles = root.childElement(PROFILES).orElse(null);
+        if (profiles != null) {
+            for (Element profile : profiles.childElements(PROFILE).toList()) {
+                modified |= fixResourceFilteringInBuild(profile, pomDocument, context);
+            }
+        }
+
+        return modified;
+    }
+
+    /**
+     * Checks resources/testResources within a build element (root or profile)
+     * and adds nonFilteredFileExtensions if filtering is enabled.
+     */
+    private boolean fixResourceFilteringInBuild(Element parent, Document pomDocument, UpgradeContext context) {
+        Element build = parent.childElement(BUILD).orElse(null);
+        if (build == null) {
+            return false;
+        }
+
+        boolean hasFilteredResources = hasFilteringEnabled(build, RESOURCES, RESOURCE);
+        boolean hasFilteredTestResources = hasFilteringEnabled(build, TEST_RESOURCES, TEST_RESOURCE);
+
+        if (!hasFilteredResources && !hasFilteredTestResources) {
+            return false;
+        }
+
+        // Check if maven-resources-plugin already has nonFilteredFileExtensions configured
+        Set<String> existingExtensions = findExistingNonFilteredExtensions(parent);
+
+        if (existingExtensions == null) {
+            // No configuration exists at all — add the full list
+            addNonFilteredExtensions(parent, pomDocument, BINARY_EXTENSIONS, context);
+            return true;
+        }
+
+        // Configuration exists — check if any extensions are missing
+        Set<String> missingExtensions = new LinkedHashSet<>();
+        for (String ext : BINARY_EXTENSIONS) {
+            if (!existingExtensions.contains(ext)) {
+                missingExtensions.add(ext);
+            }
+        }
+
+        if (!missingExtensions.isEmpty()) {
+            mergeNonFilteredExtensions(parent, missingExtensions, context);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks if any resource/testResource in a build element has filtering enabled.
+     */
+    boolean hasFilteringEnabled(Element build, String containerName, String elementName) {
+        Element container = build.childElement(containerName).orElse(null);
+        if (container == null) {
+            return false;
+        }
+
+        for (Element resource : container.childElements(elementName).toList()) {
+            Element filteringElement = resource.childElement(FILTERING).orElse(null);
+            if (filteringElement != null && "true".equals(filteringElement.textContentTrimmed())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Finds existing nonFilteredFileExtensions from the maven-resources-plugin configuration.
+     * Searches both pluginManagement and direct plugins sections.
+     *
+     * @return the set of existing extensions, or null if no configuration exists
+     */
+    Set<String> findExistingNonFilteredExtensions(Element parent) {
+        Element build = parent.childElement(BUILD).orElse(null);
+        if (build == null) {
+            return null;
+        }
+
+        // Check pluginManagement first, then direct plugins
+        Element pluginElement = findResourcesPlugin(build, true);
+        if (pluginElement == null) {
+            pluginElement = findResourcesPlugin(build, false);
+        }
+
+        if (pluginElement == null) {
+            return null;
+        }
+
+        Element configuration = pluginElement.childElement(CONFIGURATION).orElse(null);
+        if (configuration == null) {
+            return null;
+        }
+
+        Element extensions =
+                configuration.childElement(NON_FILTERED_FILE_EXTENSIONS).orElse(null);
+        if (extensions == null) {
+            return null;
+        }
+
+        Set<String> result = new HashSet<>();
+        for (Element ext : extensions.childElements(NON_FILTERED_FILE_EXTENSION).toList()) {
+            String value = ext.textContentTrimmed();
+            if (value != null && !value.isEmpty()) {
+                result.add(value);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Finds the maven-resources-plugin element in the build section.
+     *
+     * @param build the build element
+     * @param inPluginManagement true to look in pluginManagement, false for direct plugins
+     * @return the plugin element, or null if not found
+     */
+    private Element findResourcesPlugin(Element build, boolean inPluginManagement) {
+        Element pluginsContainer;
+
+        if (inPluginManagement) {
+            Element pluginMgmt = build.childElement(PLUGIN_MANAGEMENT).orElse(null);
+            if (pluginMgmt == null) {
+                return null;
+            }
+            pluginsContainer = pluginMgmt.childElement(PLUGINS).orElse(null);
+        } else {
+            pluginsContainer = build.childElement(PLUGINS).orElse(null);
+        }
+
+        if (pluginsContainer == null) {
+            return null;
+        }
+
+        for (Element plugin : pluginsContainer.childElements(PLUGIN).toList()) {
+            String artifactId = plugin.childText(ARTIFACT_ID);
+            if (MAVEN_RESOURCES_PLUGIN.equals(artifactId)) {
+                String groupId = plugin.childText(GROUP_ID);
+                if (groupId == null || MAVEN_PLUGINS_GROUP_ID.equals(groupId)) {
+                    return plugin;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Adds nonFilteredFileExtensions configuration to the maven-resources-plugin
+     * in pluginManagement. Creates the pluginManagement/plugins/plugin structure
+     * if it does not exist.
+     */
+    private void addNonFilteredExtensions(
+            Element parent, Document pomDocument, List<String> extensions, UpgradeContext context) {
+        Element build = parent.childElement(BUILD).orElse(null);
+        if (build == null) {
+            build = DomUtils.insertNewElement(BUILD, parent);
+        }
+
+        // Prefer adding to pluginManagement so child modules inherit the config
+        Element pluginManagement = build.childElement(PLUGIN_MANAGEMENT).orElse(null);
+        if (pluginManagement == null) {
+            pluginManagement = DomUtils.insertNewElement(PLUGIN_MANAGEMENT, build);
+        }
+
+        Element plugins = pluginManagement.childElement(PLUGINS).orElse(null);
+        if (plugins == null) {
+            plugins = DomUtils.insertNewElement(PLUGINS, pluginManagement);
+        }
+
+        // Check if maven-resources-plugin already exists in pluginManagement
+        Element pluginElement = null;
+        for (Element plugin : plugins.childElements(PLUGIN).toList()) {
+            String artifactId = plugin.childText(ARTIFACT_ID);
+            if (MAVEN_RESOURCES_PLUGIN.equals(artifactId)) {
+                String groupId = plugin.childText(GROUP_ID);
+                if (groupId == null || MAVEN_PLUGINS_GROUP_ID.equals(groupId)) {
+                    pluginElement = plugin;
+                    break;
+                }
+            }
+        }
+
+        if (pluginElement == null) {
+            pluginElement = DomUtils.insertNewElement(PLUGIN, plugins);
+            DomUtils.insertContentElement(pluginElement, ARTIFACT_ID, MAVEN_RESOURCES_PLUGIN);
+        }
+
+        Element configuration = pluginElement.childElement(CONFIGURATION).orElse(null);
+        if (configuration == null) {
+            configuration = DomUtils.insertNewElement(CONFIGURATION, pluginElement);
+        }
+
+        Element extensionsElement = DomUtils.insertNewElement(NON_FILTERED_FILE_EXTENSIONS, configuration);
+        for (String ext : extensions) {
+            DomUtils.insertContentElement(extensionsElement, NON_FILTERED_FILE_EXTENSION, ext);
+        }
+
+        context.detail("Added " + NON_FILTERED_FILE_EXTENSIONS
+                + " to maven-resources-plugin to prevent MalformedInputException on binary files with Maven 4");
+    }
+
+    /**
+     * Merges missing extensions into the existing nonFilteredFileExtensions configuration.
+     */
+    private void mergeNonFilteredExtensions(Element parent, Set<String> missingExtensions, UpgradeContext context) {
+        Element build = parent.childElement(BUILD).orElse(null);
+        if (build == null) {
+            return;
+        }
+
+        // Find the existing configuration
+        Element pluginElement = findResourcesPlugin(build, true);
+        if (pluginElement == null) {
+            pluginElement = findResourcesPlugin(build, false);
+        }
+
+        if (pluginElement == null) {
+            return;
+        }
+
+        Element configuration = pluginElement.childElement(CONFIGURATION).orElse(null);
+        if (configuration == null) {
+            return;
+        }
+
+        Element extensionsElement =
+                configuration.childElement(NON_FILTERED_FILE_EXTENSIONS).orElse(null);
+        if (extensionsElement == null) {
+            return;
+        }
+
+        for (String ext : missingExtensions) {
+            DomUtils.insertContentElement(extensionsElement, NON_FILTERED_FILE_EXTENSION, ext);
+        }
+
+        context.detail("Merged " + missingExtensions.size()
+                + " missing binary file extensions into existing " + NON_FILTERED_FILE_EXTENSIONS
+                + " configuration to prevent MalformedInputException with Maven 4");
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategyTest.java
index 2d1e6a6332..18d845cbb3 100644
--- a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategyTest.java
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityFixStrategyTest.java
@@ -25,7 +25,6 @@
 import java.util.Optional;
 
 import eu.maveniverse.domtrip.Document;
-import eu.maveniverse.domtrip.Editor;
 import eu.maveniverse.domtrip.Element;
 import org.apache.maven.api.cli.mvnup.UpgradeOptions;
 import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
@@ -550,153 +549,6 @@ void shouldRemoveAllOccurrencesOfInvalidCombineSelf() throws Exception {
         }
     }
 
-    @Nested
-    @DisplayName("Duplicate Dependency Fixes")
-    class DuplicateDependencyFixesTests {
-
-        @Test
-        @DisplayName("should remove duplicate dependencies in dependencyManagement")
-        void shouldRemoveDuplicateDependenciesInDependencyManagement() throws Exception {
-            String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <dependencyManagement>
-                        <dependencies>
-                            <dependency>
-                                <groupId>org.apache.commons</groupId>
-                                <artifactId>commons-lang3</artifactId>
-                                <version>3.12.0</version>
-                            </dependency>
-                            <dependency>
-                                <groupId>org.apache.commons</groupId>
-                                <artifactId>commons-lang3</artifactId>
-                                <version>3.13.0</version>
-                            </dependency>
-                        </dependencies>
-                    </dependencyManagement>
-                </project>
-                """;
-
-            Document document = Document.of(pomXml);
-            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
-
-            UpgradeContext context = createMockContext();
-            UpgradeResult result = strategy.doApply(context, pomMap);
-
-            assertTrue(result.success(), "Compatibility fix should succeed");
-            assertTrue(result.modifiedCount() > 0, "Should have removed duplicate dependency");
-
-            // Verify only one dependency remains
-            Editor editor = new Editor(document);
-            Element root = editor.root();
-            Element dependencyManagement = DomUtils.findChildElement(root, "dependencyManagement");
-            Element dependencies = DomUtils.findChildElement(dependencyManagement, "dependencies");
-            var dependencyElements = dependencies.childElements("dependency").toList();
-            assertEquals(1, dependencyElements.size(), "Should have only one dependency after duplicate removal");
-        }
-
-        @Test
-        @DisplayName("should remove duplicate dependencies in regular dependencies")
-        void shouldRemoveDuplicateDependenciesInRegularDependencies() throws Exception {
-            String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <dependencies>
-                        <dependency>
-                            <groupId>junit</groupId>
-                            <artifactId>junit</artifactId>
-                            <version>4.13.2</version>
-                            <scope>test</scope>
-                        </dependency>
-                        <dependency>
-                            <groupId>junit</groupId>
-                            <artifactId>junit</artifactId>
-                            <version>4.13.2</version>
-                            <scope>test</scope>
-                        </dependency>
-                    </dependencies>
-                </project>
-                """;
-
-            Document document = Document.of(pomXml);
-            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
-
-            UpgradeContext context = createMockContext();
-            UpgradeResult result = strategy.doApply(context, pomMap);
-
-            assertTrue(result.success(), "Compatibility fix should succeed");
-            assertTrue(result.modifiedCount() > 0, "Should have removed duplicate dependency");
-
-            // Verify only one dependency remains
-            Editor editor = new Editor(document);
-            Element root = editor.root();
-            Element dependencies = DomUtils.findChildElement(root, "dependencies");
-            var dependencyElements = dependencies.childElements("dependency").toList();
-            assertEquals(1, dependencyElements.size(), "Should have only one dependency after duplicate removal");
-        }
-    }
-
-    @Nested
-    @DisplayName("Duplicate Plugin Fixes")
-    class DuplicatePluginFixesTests {
-
-        @Test
-        @DisplayName("should remove duplicate plugins in pluginManagement")
-        void shouldRemoveDuplicatePluginsInPluginManagement() throws Exception {
-            String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <pluginManagement>
-                            <plugins>
-                                <plugin>
-                                    <groupId>org.apache.maven.plugins</groupId>
-                                    <artifactId>maven-compiler-plugin</artifactId>
-                                    <version>3.11.0</version>
-                                </plugin>
-                                <plugin>
-                                    <groupId>org.apache.maven.plugins</groupId>
-                                    <artifactId>maven-compiler-plugin</artifactId>
-                                    <version>3.12.0</version>
-                                </plugin>
-                            </plugins>
-                        </pluginManagement>
-                    </build>
-                </project>
-                """;
-
-            Document document = Document.of(pomXml);
-            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
-
-            UpgradeContext context = createMockContext();
-            UpgradeResult result = strategy.doApply(context, pomMap);
-
-            assertTrue(result.success(), "Compatibility fix should succeed");
-            assertTrue(result.modifiedCount() > 0, "Should have removed duplicate plugin");
-
-            // Verify only one plugin remains
-            Editor editor = new Editor(document);
-            Element root = editor.root();
-            Element build = DomUtils.findChildElement(root, "build");
-            Element pluginManagement = DomUtils.findChildElement(build, "pluginManagement");
-            Element plugins = DomUtils.findChildElement(pluginManagement, "plugins");
-            var pluginElements = plugins.childElements("plugin").toList();
-            assertEquals(1, pluginElements.size(), "Should have only one plugin after duplicate removal");
-        }
-    }
-
     @Nested
     @DisplayName("Repository Expression Fixes")
     class RepositoryExpressionFixesTests {
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityWarningTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityWarningTest.java
new file mode 100644
index 0000000000..aa57acb1d8
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/CompatibilityWarningTest.java
@@ -0,0 +1,383 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
+import eu.maveniverse.domtrip.Document;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Tests for Maven 4 compatibility warnings emitted by {@link CompatibilityFixStrategy}.
+ * These cover warning-only checks that detect patterns known to fail with Maven 4
+ * but which cannot be auto-fixed.
+ */
+@DisplayName("CompatibilityFixStrategy Warnings")
+class CompatibilityWarningTest {
+
+    private CompatibilityFixStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new CompatibilityFixStrategy();
+    }
+
+    private UpgradeContext createMockContext() {
+        return TestUtils.createMockContext();
+    }
+
+    @Nested
+    @DisplayName("Incompatible Plugin Warnings (#12432)")
+    class IncompatiblePluginWarningTests {
+
+        @Test
+        @DisplayName("should not warn about gmavenplus-plugin (now handled by PluginUpgradeStrategy)")
+        void shouldNotWarnAboutGmavenplusPlugin() throws Exception {
+            // gmavenplus-plugin was fixed in 4.2.0 (groovy/GMavenPlus#328) and is now
+            // handled as a plugin upgrade rather than a permanent incompatibility warning
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.codehaus.gmavenplus</groupId>
+                                <artifactId>gmavenplus-plugin</artifactId>
+                                <version>4.1.1</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, never()).warn(argThat(msg -> msg.contains("Known Maven 4 incompatibility")));
+        }
+
+        @Test
+        @DisplayName("should not warn about compatible plugins")
+        void shouldNotWarnAboutCompatiblePlugins() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-compiler-plugin</artifactId>
+                                <version>3.13.0</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, never()).warn(argThat(msg -> msg.contains("Known Maven 4 incompatibility")));
+        }
+    }
+
+    @Nested
+    @DisplayName("Property-Interpolated Module Path Warnings (#12434)")
+    class PropertyInterpolatedModulePathTests {
+
+        @Test
+        @DisplayName("should warn about property expressions in module paths")
+        void shouldWarnAboutPropertyExpressionsInModulePaths() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <packaging>pom</packaging>
+                    <modules>
+                        <module>core</module>
+                        <module>spark-${spark.compat.version}</module>
+                        <module>v${spark.major.version}/mixed-spark</module>
+                    </modules>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, atLeastOnce())
+                    .warn(argThat(msg ->
+                            msg.contains("spark-${spark.compat.version}") && msg.contains("property expression")));
+        }
+
+        @Test
+        @DisplayName("should not warn about static module paths")
+        void shouldNotWarnAboutStaticModulePaths() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <packaging>pom</packaging>
+                    <modules>
+                        <module>core</module>
+                        <module>web</module>
+                    </modules>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, never()).warn(argThat(msg -> msg.contains("property expression")));
+        }
+
+        @Test
+        @DisplayName("should warn about property expressions in profile module paths")
+        void shouldWarnAboutPropertyExpressionsInProfileModulePaths() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <packaging>pom</packaging>
+                    <profiles>
+                        <profile>
+                            <id>spark-3.5</id>
+                            <modules>
+                                <module>spark-${spark.version}</module>
+                            </modules>
+                        </profile>
+                    </profiles>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, atLeastOnce())
+                    .warn(argThat(msg -> msg.contains("spark-${spark.version}") && msg.contains("profile")));
+        }
+    }
+
+    @Nested
+    @DisplayName("CI-Friendly Missing Dependency Version Warnings (#12435)")
+    class CiFriendlyDependencyVersionTests {
+
+        @Test
+        @DisplayName("should warn about versionless dependencies in CI-friendly project")
+        void shouldWarnAboutVersionlessDependenciesInCiFriendlyProject() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>parent</artifactId>
+                        <version>${revision}</version>
+                    </parent>
+                    <artifactId>child</artifactId>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.springframework</groupId>
+                            <artifactId>spring-context</artifactId>
+                        </dependency>
+                        <dependency>
+                            <groupId>io.protostuff</groupId>
+                            <artifactId>protostuff-core</artifactId>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, atLeastOnce())
+                    .warn(argThat(msg -> msg.contains("CI-friendly")
+                            && msg.contains("${revision}")
+                            && msg.contains("2 dependencies")));
+        }
+
+        @Test
+        @DisplayName("should not warn when parent version is not CI-friendly")
+        void shouldNotWarnWhenParentVersionNotCiFriendly() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>parent</artifactId>
+                        <version>1.0.0</version>
+                    </parent>
+                    <artifactId>child</artifactId>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.springframework</groupId>
+                            <artifactId>spring-context</artifactId>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, never()).warn(argThat(msg -> msg.contains("CI-friendly")));
+        }
+
+        @Test
+        @DisplayName("should not warn when dependencies have explicit versions")
+        void shouldNotWarnWhenDependenciesHaveVersions() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>parent</artifactId>
+                        <version>${revision}</version>
+                    </parent>
+                    <artifactId>child</artifactId>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.springframework</groupId>
+                            <artifactId>spring-context</artifactId>
+                            <version>6.0.0</version>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, never()).warn(argThat(msg -> msg.contains("CI-friendly")));
+        }
+
+        @Test
+        @DisplayName("should handle ${changelist} as CI-friendly expression")
+        void shouldHandleChangelistAsCiFriendly() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>parent</artifactId>
+                        <version>1.0.0${changelist}</version>
+                    </parent>
+                    <artifactId>child</artifactId>
+                    <dependencies>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, atLeastOnce()).warn(argThat(msg -> msg.contains("CI-friendly")));
+        }
+
+        @Test
+        @DisplayName("should not warn when no parent element exists")
+        void shouldNotWarnWhenNoParentExists() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.springframework</groupId>
+                            <artifactId>spring-context</artifactId>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            verify(context.logger, never()).warn(argThat(msg -> msg.contains("CI-friendly")));
+        }
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/DeduplicateDependenciesStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/DeduplicateDependenciesStrategyTest.java
new file mode 100644
index 0000000000..97e85ae0ec
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/DeduplicateDependenciesStrategyTest.java
@@ -0,0 +1,552 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
+import eu.maveniverse.domtrip.Document;
+import eu.maveniverse.domtrip.Element;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests for {@link DeduplicateDependenciesStrategy}.
+ */
+@DisplayName("DeduplicateDependenciesStrategy")
+class DeduplicateDependenciesStrategyTest {
+
+    private DeduplicateDependenciesStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new DeduplicateDependenciesStrategy();
+    }
+
+    private UpgradeContext createMockContext() {
+        return TestUtils.createMockContext();
+    }
+
+    @Nested
+    @DisplayName("Duplicate Dependency Removal")
+    class DuplicateDependencyTests {
+
+        @Test
+        @DisplayName("should remove duplicate dependencies keeping last occurrence")
+        void shouldRemoveDuplicateDependenciesKeepingLast() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>2.11.0</version>
+                        </dependency>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>2.15.0</version>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            // Should keep last (2.15.0), remove first (2.11.0)
+            assertTrue(xml.contains("<version>2.15.0</version>"), "Should keep last version");
+            assertFalse(xml.contains("<version>2.11.0</version>"), "Should remove first version");
+
+            Element deps = document.root().childElement("dependencies").orElse(null);
+            long count = deps.childElements("dependency").count();
+            assertEquals(1, count, "Should have only one dependency after dedup");
+        }
+
+        @Test
+        @DisplayName("should remove duplicate in dependencyManagement keeping last")
+        void shouldRemoveDuplicateInDependencyManagement() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>org.slf4j</groupId>
+                                <artifactId>slf4j-api</artifactId>
+                                <version>1.7.36</version>
+                            </dependency>
+                            <dependency>
+                                <groupId>org.slf4j</groupId>
+                                <artifactId>slf4j-api</artifactId>
+                                <version>2.0.9</version>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>2.0.9</version>"), "Should keep last version");
+            assertFalse(xml.contains("<version>1.7.36</version>"), "Should remove first version");
+        }
+
+        @Test
+        @DisplayName("should keep last when three duplicates exist")
+        void shouldKeepLastOfThreeDuplicates() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>1.0</version>
+                        </dependency>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>2.0</version>
+                        </dependency>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>3.0</version>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>3.0</version>"), "Should keep version 3.0 (last)");
+            assertFalse(xml.contains("<version>1.0</version>"), "Should remove version 1.0");
+            assertFalse(xml.contains("<version>2.0</version>"), "Should remove version 2.0");
+
+            Element deps = document.root().childElement("dependencies").orElse(null);
+            assertEquals(1, deps.childElements("dependency").count());
+        }
+
+        @Test
+        @DisplayName("should handle duplicates with same type and classifier")
+        void shouldHandleDuplicatesWithTypeAndClassifier() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>io.netty</groupId>
+                            <artifactId>netty-transport</artifactId>
+                            <version>4.1.0</version>
+                            <type>jar</type>
+                            <classifier>linux-x86_64</classifier>
+                        </dependency>
+                        <dependency>
+                            <groupId>io.netty</groupId>
+                            <artifactId>netty-transport</artifactId>
+                            <version>4.2.0</version>
+                            <type>jar</type>
+                            <classifier>linux-x86_64</classifier>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>4.2.0</version>"));
+            assertFalse(xml.contains("<version>4.1.0</version>"));
+        }
+
+        @Test
+        @DisplayName("should not treat different classifiers as duplicates")
+        void shouldNotDedupDifferentClassifiers() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>io.netty</groupId>
+                            <artifactId>netty-transport</artifactId>
+                            <version>4.1.0</version>
+                            <classifier>linux-x86_64</classifier>
+                        </dependency>
+                        <dependency>
+                            <groupId>io.netty</groupId>
+                            <artifactId>netty-transport</artifactId>
+                            <version>4.1.0</version>
+                            <classifier>linux-aarch_64</classifier>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(0, result.modifiedCount(), "Different classifiers are not duplicates");
+        }
+
+        @Test
+        @DisplayName("should handle profile-scoped duplicate dependencies")
+        void shouldHandleProfileDuplicateDependencies() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <profiles>
+                        <profile>
+                            <id>test-profile</id>
+                            <dependencies>
+                                <dependency>
+                                    <groupId>junit</groupId>
+                                    <artifactId>junit</artifactId>
+                                    <version>4.12</version>
+                                </dependency>
+                                <dependency>
+                                    <groupId>junit</groupId>
+                                    <artifactId>junit</artifactId>
+                                    <version>4.13.2</version>
+                                </dependency>
+                            </dependencies>
+                        </profile>
+                    </profiles>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>4.13.2</version>"), "Should keep last version");
+            assertFalse(xml.contains("<version>4.12</version>"), "Should remove first version");
+        }
+
+        @Test
+        @DisplayName("should keep property references in version")
+        void shouldKeepPropertyVersion() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>2.11.0</version>
+                        </dependency>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>${commons.io.version}</version>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("${commons.io.version}"),
+                    "Should keep the last occurrence which has property version");
+            assertFalse(xml.contains("<version>2.11.0</version>"));
+        }
+
+        @Test
+        @DisplayName("should not modify when no duplicates exist")
+        void shouldNotModifyWhenNoDuplicates() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencies>
+                        <dependency>
+                            <groupId>commons-io</groupId>
+                            <artifactId>commons-io</artifactId>
+                            <version>2.15.0</version>
+                        </dependency>
+                        <dependency>
+                            <groupId>commons-lang</groupId>
+                            <artifactId>commons-lang3</artifactId>
+                            <version>3.14.0</version>
+                        </dependency>
+                    </dependencies>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(0, result.modifiedCount(), "Should not modify when no duplicates");
+        }
+    }
+
+    @Nested
+    @DisplayName("Duplicate Plugin Removal")
+    class DuplicatePluginTests {
+
+        @Test
+        @DisplayName("should remove duplicate plugins keeping last occurrence")
+        void shouldRemoveDuplicatePlugins() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-compiler-plugin</artifactId>
+                                <version>3.11.0</version>
+                            </plugin>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-compiler-plugin</artifactId>
+                                <version>3.13.0</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>3.13.0</version>"), "Should keep last version");
+            assertFalse(xml.contains("<version>3.11.0</version>"), "Should remove first version");
+        }
+
+        @Test
+        @DisplayName("should remove duplicate plugins in pluginManagement")
+        void shouldRemoveDuplicatePluginsInPluginManagement() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-surefire-plugin</artifactId>
+                                    <version>3.1.0</version>
+                                </plugin>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-surefire-plugin</artifactId>
+                                    <version>3.2.5</version>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount());
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>3.2.5</version>"), "Should keep last version");
+            assertFalse(xml.contains("<version>3.1.0</version>"), "Should remove first version");
+        }
+
+        @Test
+        @DisplayName("should default groupId for maven plugins without explicit groupId")
+        void shouldDefaultGroupIdForMavenPlugins() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <artifactId>maven-jar-plugin</artifactId>
+                                <version>3.3.0</version>
+                            </plugin>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-jar-plugin</artifactId>
+                                <version>3.4.0</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(1, result.modifiedCount(), "Should detect duplicate even without explicit groupId");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>3.4.0</version>"), "Should keep last version");
+        }
+    }
+
+    @Nested
+    @DisplayName("Applicability")
+    class ApplicabilityTests {
+
+        @Test
+        @DisplayName("should be applicable with default options")
+        void shouldBeApplicableWithDefaults() {
+            UpgradeContext context = createMockContext();
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should be applicable when --all is set")
+        void shouldBeApplicableWithAll() {
+            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptionsWithAll(true));
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should be applicable when --model is true")
+        void shouldBeApplicableWithModelTrue() {
+            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptionsWithFixModel(true));
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should not be applicable when --model is false")
+        void shouldNotBeApplicableWithModelFalse() {
+            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptionsWithFixModel(false));
+            assertFalse(strategy.isApplicable(context));
+        }
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/EnforcerVersionRangeStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/EnforcerVersionRangeStrategyTest.java
new file mode 100644
index 0000000000..7317bdac5a
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/EnforcerVersionRangeStrategyTest.java
@@ -0,0 +1,577 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.Optional;
+
+import eu.maveniverse.domtrip.Document;
+import org.apache.maven.api.cli.mvnup.UpgradeOptions;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Unit tests for the {@link EnforcerVersionRangeStrategy} class.
+ * Tests widening of RequireMavenVersion ranges to allow Maven 4.
+ */
+@DisplayName("EnforcerVersionRangeStrategy")
+class EnforcerVersionRangeStrategyTest {
+
+    private EnforcerVersionRangeStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new EnforcerVersionRangeStrategy();
+    }
+
+    private UpgradeContext createMockContext() {
+        return TestUtils.createMockContext();
+    }
+
+    private UpgradeContext createMockContext(UpgradeOptions options) {
+        return TestUtils.createMockContext(options);
+    }
+
+    @Nested
+    @DisplayName("Applicability")
+    class ApplicabilityTests {
+
+        @Test
+        @DisplayName("should be applicable when --model option is true")
+        void shouldBeApplicableWhenModelOptionTrue() {
+            UpgradeOptions options = mock(UpgradeOptions.class);
+            when(options.model()).thenReturn(Optional.of(true));
+            when(options.all()).thenReturn(Optional.empty());
+            when(options.infer()).thenReturn(Optional.empty());
+            when(options.plugins()).thenReturn(Optional.empty());
+            when(options.modelVersion()).thenReturn(Optional.empty());
+
+            UpgradeContext context = createMockContext(options);
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should be applicable when --all option is specified")
+        void shouldBeApplicableWhenAllOptionSpecified() {
+            UpgradeOptions options = mock(UpgradeOptions.class);
+            when(options.all()).thenReturn(Optional.of(true));
+            when(options.model()).thenReturn(Optional.empty());
+            when(options.infer()).thenReturn(Optional.empty());
+            when(options.plugins()).thenReturn(Optional.empty());
+            when(options.modelVersion()).thenReturn(Optional.empty());
+
+            UpgradeContext context = createMockContext(options);
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should be applicable by default when no specific options provided")
+        void shouldBeApplicableByDefaultWhenNoSpecificOptions() {
+            UpgradeContext context = createMockContext(TestUtils.createDefaultOptions());
+            assertTrue(strategy.isApplicable(context));
+        }
+    }
+
+    @Nested
+    @DisplayName("Version Range Widening")
+    class VersionRangeWideningTests {
+
+        @Test
+        @DisplayName("should widen [3.8.8,4) to [3.8.8,5)")
+        void shouldWidenStandardRange() {
+            assertEquals("[3.8.8,5)", EnforcerVersionRangeStrategy.widenVersionRange("[3.8.8,4)"));
+        }
+
+        @Test
+        @DisplayName("should widen [3,4) to [3,5)")
+        void shouldWidenShortRange() {
+            assertEquals("[3,5)", EnforcerVersionRangeStrategy.widenVersionRange("[3,4)"));
+        }
+
+        @Test
+        @DisplayName("should widen (3.6.3,4) to (3.6.3,5)")
+        void shouldWidenExclusiveLowerBoundRange() {
+            assertEquals("(3.6.3,5)", EnforcerVersionRangeStrategy.widenVersionRange("(3.6.3,4)"));
+        }
+
+        @Test
+        @DisplayName("should widen [3.8.8,4.0) to [3.8.8,5)")
+        void shouldWidenRange4Dot0() {
+            assertEquals("[3.8.8,5)", EnforcerVersionRangeStrategy.widenVersionRange("[3.8.8,4.0)"));
+        }
+
+        @Test
+        @DisplayName("should widen [3.8.8,4.0.0) to [3.8.8,5)")
+        void shouldWidenRange4Dot0Dot0() {
+            assertEquals("[3.8.8,5)", EnforcerVersionRangeStrategy.widenVersionRange("[3.8.8,4.0.0)"));
+        }
+
+        @Test
+        @DisplayName("should not widen [3.8.8,) — open upper bound already allows 4.x")
+        void shouldNotWidenOpenUpperBound() {
+            assertNull(EnforcerVersionRangeStrategy.widenVersionRange("[3.8.8,)"));
+        }
+
+        @Test
+        @DisplayName("should not widen plain version 3.8.8")
+        void shouldNotWidenPlainVersion() {
+            assertNull(EnforcerVersionRangeStrategy.widenVersionRange("3.8.8"));
+        }
+
+        @Test
+        @DisplayName("should not widen [3.8.8,5) — already allows Maven 4")
+        void shouldNotWidenAlreadyWidened() {
+            assertNull(EnforcerVersionRangeStrategy.widenVersionRange("[3.8.8,5)"));
+        }
+
+        @Test
+        @DisplayName("should not widen [3.8.8,3.9) — upper bound is not at 4")
+        void shouldNotWidenNon4UpperBound() {
+            assertNull(EnforcerVersionRangeStrategy.widenVersionRange("[3.8.8,3.9)"));
+        }
+    }
+
+    @Nested
+    @DisplayName("Plugin Configuration")
+    class PluginConfigurationTests {
+
+        @Test
+        @DisplayName("should widen requireMavenVersion in top-level plugin configuration")
+        void shouldWidenInTopLevelConfiguration() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-enforcer-plugin</artifactId>
+                                <configuration>
+                                    <rules>
+                                        <requireMavenVersion>
+                                            <version>[3.8.8,4)</version>
+                                        </requireMavenVersion>
+                                    </rules>
+                                </configuration>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertTrue(result.modifiedCount() > 0);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("[3.8.8,5)"), "Version range should be widened to [3.8.8,5)");
+            assertFalse(xml.contains("[3.8.8,4)"), "Original range should be replaced");
+        }
+
+        @Test
+        @DisplayName("should widen requireMavenVersion in execution configuration")
+        void shouldWidenInExecutionConfiguration() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-enforcer-plugin</artifactId>
+                                <executions>
+                                    <execution>
+                                        <id>enforce-maven</id>
+                                        <goals>
+                                            <goal>enforce</goal>
+                                        </goals>
+                                        <configuration>
+                                            <rules>
+                                                <requireMavenVersion>
+                                                    <version>[3,4)</version>
+                                                </requireMavenVersion>
+                                            </rules>
+                                        </configuration>
+                                    </execution>
+                                </executions>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertTrue(result.modifiedCount() > 0);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("[3,5)"), "Version range should be widened to [3,5)");
+        }
+
+        @Test
+        @DisplayName("should widen requireMavenVersion in pluginManagement")
+        void shouldWidenInPluginManagement() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                    <configuration>
+                                        <rules>
+                                            <requireMavenVersion>
+                                                <version>[3.6.3,4)</version>
+                                            </requireMavenVersion>
+                                        </rules>
+                                    </configuration>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertTrue(result.modifiedCount() > 0);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("[3.6.3,5)"), "Version range should be widened");
+        }
+
+        @Test
+        @DisplayName("should not modify enforcer plugin with compatible version range")
+        void shouldNotModifyCompatibleRange() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-enforcer-plugin</artifactId>
+                                <configuration>
+                                    <rules>
+                                        <requireMavenVersion>
+                                            <version>[3.8.8,)</version>
+                                        </requireMavenVersion>
+                                    </rules>
+                                </configuration>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(0, result.modifiedCount(), "No changes expected for compatible range");
+        }
+
+        @Test
+        @DisplayName("should not modify non-enforcer plugins")
+        void shouldNotModifyNonEnforcerPlugins() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-compiler-plugin</artifactId>
+                                <version>3.11.0</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(0, result.modifiedCount(), "No changes expected for non-enforcer plugins");
+        }
+
+        @Test
+        @DisplayName("should handle enforcer plugin without explicit groupId")
+        void shouldHandleEnforcerWithoutGroupId() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <artifactId>maven-enforcer-plugin</artifactId>
+                                <configuration>
+                                    <rules>
+                                        <requireMavenVersion>
+                                            <version>[3.8.8,4)</version>
+                                        </requireMavenVersion>
+                                    </rules>
+                                </configuration>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertTrue(result.modifiedCount() > 0, "Should handle enforcer plugin without explicit groupId");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("[3.8.8,5)"));
+        }
+    }
+
+    @Nested
+    @DisplayName("Profile-Scoped")
+    class ProfileScopedTests {
+
+        @Test
+        @DisplayName("should widen requireMavenVersion in profile-scoped enforcer plugin")
+        void shouldWidenInProfileScopedPlugin() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <profiles>
+                        <profile>
+                            <id>enforce</id>
+                            <build>
+                                <plugins>
+                                    <plugin>
+                                        <groupId>org.apache.maven.plugins</groupId>
+                                        <artifactId>maven-enforcer-plugin</artifactId>
+                                        <configuration>
+                                            <rules>
+                                                <requireMavenVersion>
+                                                    <version>[3.8.8,4)</version>
+                                                </requireMavenVersion>
+                                            </rules>
+                                        </configuration>
+                                    </plugin>
+                                </plugins>
+                            </build>
+                        </profile>
+                    </profiles>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertTrue(result.modifiedCount() > 0);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("[3.8.8,5)"), "Profile-scoped range should be widened");
+        }
+    }
+
+    @Nested
+    @DisplayName("Edge Cases")
+    class EdgeCaseTests {
+
+        @Test
+        @DisplayName("should handle POM with no build section")
+        void shouldHandlePomWithNoBuild() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(0, result.modifiedCount());
+        }
+
+        @Test
+        @DisplayName("should handle enforcer plugin with no rules")
+        void shouldHandleEnforcerWithNoRules() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-enforcer-plugin</artifactId>
+                                <configuration>
+                                </configuration>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertEquals(0, result.modifiedCount());
+        }
+
+        @Test
+        @DisplayName("should widen both top-level and execution-level configurations")
+        void shouldWidenBothTopLevelAndExecutionLevel() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>org.apache.maven.plugins</groupId>
+                                <artifactId>maven-enforcer-plugin</artifactId>
+                                <configuration>
+                                    <rules>
+                                        <requireMavenVersion>
+                                            <version>[3.6.3,4)</version>
+                                        </requireMavenVersion>
+                                    </rules>
+                                </configuration>
+                                <executions>
+                                    <execution>
+                                        <id>enforce</id>
+                                        <configuration>
+                                            <rules>
+                                                <requireMavenVersion>
+                                                    <version>[3.8.8,4)</version>
+                                                </requireMavenVersion>
+                                            </rules>
+                                        </configuration>
+                                    </execution>
+                                </executions>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success());
+            assertTrue(result.modifiedCount() > 0);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("[3.6.3,5)"), "Top-level configuration range should be widened");
+            assertTrue(xml.contains("[3.8.8,5)"), "Execution-level configuration range should be widened");
+            assertFalse(xml.contains(",4)"), "No ranges with upper bound at 4 should remain");
+        }
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java
index 8c73fdce7f..1cda14cdd4 100644
--- a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/PluginUpgradeStrategyTest.java
@@ -47,8 +47,8 @@
 import static org.mockito.Mockito.when;
 
 /**
- * Unit tests for the {@link PluginUpgradeStrategy} class.
- * Tests plugin version upgrades, plugin management additions, and Maven 4 compatibility.
+ * Unit tests for the {@link PluginUpgradeStrategy} class. Tests plugin version upgrades, plugin management additions,
+ * and Maven 4 compatibility.
  */
 @DisplayName("PluginUpgradeStrategy")
 class PluginUpgradeStrategyTest {
@@ -161,23 +161,23 @@ void shouldUpgradePluginVersionWhenBelowMinimum() throws Exception {
         @DisplayName("should not modify plugin when version is already sufficient")
         void shouldNotModifyPluginWhenVersionAlreadySufficient() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-compiler-plugin</artifactId>
-                                <version>3.13.0</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-compiler-plugin</artifactId>
+                                    <version>3.13.0</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -193,23 +193,23 @@ void shouldNotModifyPluginWhenVersionAlreadySufficient() throws Exception {
         @DisplayName("should upgrade milestone version below release minimum")
         void shouldUpgradeMilestoneVersionBelowRelease() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-enforcer-plugin</artifactId>
-                                <version>3.0.0-M1</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                    <version>3.0.0-M1</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -232,25 +232,25 @@ void shouldUpgradeMilestoneVersionBelowRelease() throws Exception {
         @DisplayName("should upgrade plugin in pluginManagement")
         void shouldUpgradePluginInPluginManagement() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <pluginManagement>
-                            <plugins>
-                                <plugin>
-                                    <groupId>org.apache.maven.plugins</groupId>
-                                    <artifactId>maven-enforcer-plugin</artifactId>
-                                    <version>2.0.0</version>
-                                </plugin>
-                            </plugins>
-                        </pluginManagement>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <pluginManagement>
+                                <plugins>
+                                    <plugin>
+                                        <groupId>org.apache.maven.plugins</groupId>
+                                        <artifactId>maven-enforcer-plugin</artifactId>
+                                        <version>2.0.0</version>
+                                    </plugin>
+                                </plugins>
+                            </pluginManagement>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -274,26 +274,26 @@ void shouldUpgradePluginInPluginManagement() throws Exception {
         @DisplayName("should upgrade plugin with property version")
         void shouldUpgradePluginWithPropertyVersion() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <properties>
-                        <shade.plugin.version>3.0.0</shade.plugin.version>
-                    </properties>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-shade-plugin</artifactId>
-                                <version>${shade.plugin.version}</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <properties>
+                            <shade.plugin.version>3.0.0</shade.plugin.version>
+                        </properties>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-shade-plugin</artifactId>
+                                    <version>${shade.plugin.version}</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -317,23 +317,23 @@ void shouldUpgradePluginWithPropertyVersion() throws Exception {
         @DisplayName("should upgrade surefire plugin when below minimum")
         void shouldUpgradeSurefirePluginWhenBelowMinimum() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-surefire-plugin</artifactId>
-                                <version>3.1.2</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-surefire-plugin</artifactId>
+                                    <version>3.1.2</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -356,23 +356,23 @@ void shouldUpgradeSurefirePluginWhenBelowMinimum() throws Exception {
         @DisplayName("should upgrade failsafe plugin when below minimum")
         void shouldUpgradeFailsafePluginWhenBelowMinimum() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-failsafe-plugin</artifactId>
-                                <version>3.1.2</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-failsafe-plugin</artifactId>
+                                    <version>3.1.2</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -395,23 +395,23 @@ void shouldUpgradeFailsafePluginWhenBelowMinimum() throws Exception {
         @DisplayName("should upgrade surefire-report plugin when below minimum")
         void shouldUpgradeSurefireReportPluginWhenBelowMinimum() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-surefire-report-plugin</artifactId>
-                                <version>3.1.2</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-surefire-report-plugin</artifactId>
+                                    <version>3.1.2</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -434,23 +434,23 @@ void shouldUpgradeSurefireReportPluginWhenBelowMinimum() throws Exception {
         @DisplayName("should upgrade jaxb2-maven-plugin when below minimum")
         void shouldUpgradeJaxb2MavenPluginWhenBelowMinimum() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.codehaus.mojo</groupId>
-                                <artifactId>jaxb2-maven-plugin</artifactId>
-                                <version>3.1.0</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.codehaus.mojo</groupId>
+                                    <artifactId>jaxb2-maven-plugin</artifactId>
+                                    <version>3.1.0</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -473,23 +473,23 @@ void shouldUpgradeJaxb2MavenPluginWhenBelowMinimum() throws Exception {
         @DisplayName("should not upgrade when version is already higher")
         void shouldNotUpgradeWhenVersionAlreadyHigher() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.codehaus.mojo</groupId>
-                                <artifactId>flatten-maven-plugin</artifactId>
-                                <version>1.3.0</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.codehaus.mojo</groupId>
+                                    <artifactId>flatten-maven-plugin</artifactId>
+                                    <version>1.3.0</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -512,22 +512,22 @@ void shouldNotUpgradeWhenVersionAlreadyHigher() throws Exception {
         @DisplayName("should upgrade plugin without explicit groupId")
         void shouldUpgradePluginWithoutExplicitGroupId() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <artifactId>maven-shade-plugin</artifactId>
-                                <version>3.1.0</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <artifactId>maven-shade-plugin</artifactId>
+                                    <version>3.1.0</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -553,23 +553,23 @@ void shouldUpgradePluginWithoutExplicitGroupId() throws Exception {
         @DisplayName("should not upgrade plugin without version")
         void shouldNotUpgradePluginWithoutVersion() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.codehaus.mojo</groupId>
-                                <artifactId>exec-maven-plugin</artifactId>
-                                <!-- No version - inherited from parent or pluginManagement -->
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.codehaus.mojo</groupId>
+                                    <artifactId>exec-maven-plugin</artifactId>
+                                    <!-- No version - inherited from parent or pluginManagement -->
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -585,23 +585,23 @@ void shouldNotUpgradePluginWithoutVersion() throws Exception {
         @DisplayName("should not upgrade when property is not found")
         void shouldNotUpgradeWhenPropertyNotFound() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.codehaus.mojo</groupId>
-                                <artifactId>exec-maven-plugin</artifactId>
-                                <version>${exec.plugin.version}</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.codehaus.mojo</groupId>
+                                    <artifactId>exec-maven-plugin</artifactId>
+                                    <version>${exec.plugin.version}</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -622,35 +622,35 @@ class PluginDependencyUpgradeTests {
         @DisplayName("should upgrade extra-enforcer-rules dependency when below minimum")
         void shouldUpgradeExtraEnforcerRulesDependency() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-enforcer-plugin</artifactId>
-                                <version>3.5.0</version>
-                                <dependencies>
-                                    <dependency>
-                                        <groupId>org.codehaus.mojo</groupId>
-                                        <artifactId>extra-enforcer-rules</artifactId>
-                                        <version>1.0-beta-4</version>
-                                    </dependency>
-                                </dependencies>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
-
-            Document document = Document.of(pomXml);
-            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
-
-            UpgradeContext context = createMockContext();
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                    <version>3.5.0</version>
+                                    <dependencies>
+                                        <dependency>
+                                            <groupId>org.codehaus.mojo</groupId>
+                                            <artifactId>extra-enforcer-rules</artifactId>
+                                            <version>1.0-beta-4</version>
+                                        </dependency>
+                                    </dependencies>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
             UpgradeResult result = strategy.doApply(context, pomMap);
 
             assertTrue(result.success(), "Plugin dependency upgrade should succeed");
@@ -665,30 +665,30 @@ void shouldUpgradeExtraEnforcerRulesDependency() throws Exception {
         @DisplayName("should not upgrade extra-enforcer-rules when version is already sufficient")
         void shouldNotUpgradeExtraEnforcerRulesWhenSufficient() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-enforcer-plugin</artifactId>
-                                <version>3.5.0</version>
-                                <dependencies>
-                                    <dependency>
-                                        <groupId>org.codehaus.mojo</groupId>
-                                        <artifactId>extra-enforcer-rules</artifactId>
-                                        <version>1.8.0</version>
-                                    </dependency>
-                                </dependencies>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                    <version>3.5.0</version>
+                                    <dependencies>
+                                        <dependency>
+                                            <groupId>org.codehaus.mojo</groupId>
+                                            <artifactId>extra-enforcer-rules</artifactId>
+                                            <version>1.8.0</version>
+                                        </dependency>
+                                    </dependencies>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -709,23 +709,23 @@ class PluginManagementTests {
         @DisplayName("should add pluginManagement before existing plugins section")
         void shouldAddPluginManagementBeforeExistingPluginsSection() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-compiler-plugin</artifactId>
-                                <version>3.8.1</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-compiler-plugin</artifactId>
+                                    <version>3.8.1</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -819,19 +819,19 @@ void shouldInjectPluginManagementWithCommentForRemoteParentPlugins() throws Exce
             // still get a pluginManagement override with a comment explaining it overrides
             // the parent, so that Maven 4 incompatible plugin versions get upgraded.
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <parent>
-                        <groupId>org.apache</groupId>
-                        <artifactId>apache</artifactId>
-                        <version>23</version>
-                    </parent>
-                    <groupId>org.example</groupId>
-                    <artifactId>test-child</artifactId>
-                    <version>1.0.0-SNAPSHOT</version>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <parent>
+                            <groupId>org.apache</groupId>
+                            <artifactId>apache</artifactId>
+                            <version>23</version>
+                        </parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>test-child</artifactId>
+                        <version>1.0.0-SNAPSHOT</version>
+                    </project>
+                    """;
 
             Path tempDir = Files.createTempDirectory("mvnup-test-");
             try {
@@ -858,6 +858,9 @@ void shouldInjectPluginManagementWithCommentForRemoteParentPlugins() throws Exce
                 assertTrue(
                         xml.contains("<artifactId>maven-enforcer-plugin</artifactId>"),
                         "Should add pluginManagement for maven-enforcer-plugin");
+                // Verify the comment is on its own line, not appended to the previous closing tag
+                assertFalse(
+                        xml.contains("</plugin><!--"), "Comment should be on its own line, not appended to </plugin>");
             } finally {
                 try (var walk = Files.walk(tempDir)) {
                     walk.sorted(java.util.Comparator.reverseOrder()).forEach(p -> {
@@ -878,19 +881,19 @@ void shouldOverrideRemoteParentPluginViaPluginManagementWithComment() throws Exc
             // In this case, adding a pluginManagement override with a comment in the child
             // is sufficient; no direct build/plugins entry should be added for enforcer.
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <parent>
-                        <groupId>org.apache</groupId>
-                        <artifactId>apache</artifactId>
-                        <version>23</version>
-                    </parent>
-                    <groupId>org.example</groupId>
-                    <artifactId>test-child</artifactId>
-                    <version>1.0.0-SNAPSHOT</version>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <parent>
+                            <groupId>org.apache</groupId>
+                            <artifactId>apache</artifactId>
+                            <version>23</version>
+                        </parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>test-child</artifactId>
+                        <version>1.0.0-SNAPSHOT</version>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Path pomPath = Paths.get("/project/pom.xml").toAbsolutePath();
@@ -918,6 +921,8 @@ void shouldOverrideRemoteParentPluginViaPluginManagementWithComment() throws Exc
             assertTrue(
                     xml.contains("Override version inherited from parent"),
                     "Should add comment explaining the override");
+            // Verify the comment is on its own line, not appended to the previous closing tag
+            assertFalse(xml.contains("</plugin><!--"), "Comment should be on its own line, not appended to </plugin>");
 
             // Verify NO direct build/plugins entry for enforcer (PM override is sufficient)
             Element buildPlugins = root.childElement("build")
@@ -940,28 +945,28 @@ void shouldOverrideRemoteParentPluginViaPluginManagementWithComment() throws Exc
         @DisplayName("should not duplicate plugin in build/plugins when already locally declared")
         void shouldNotDuplicatePluginInBuildPluginsWhenAlreadyDeclared() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <parent>
-                        <groupId>org.apache</groupId>
-                        <artifactId>apache</artifactId>
-                        <version>23</version>
-                    </parent>
-                    <groupId>org.example</groupId>
-                    <artifactId>test-child</artifactId>
-                    <version>1.0.0-SNAPSHOT</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-enforcer-plugin</artifactId>
-                                <version>3.0.0</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <parent>
+                            <groupId>org.apache</groupId>
+                            <artifactId>apache</artifactId>
+                            <version>23</version>
+                        </parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>test-child</artifactId>
+                        <version>1.0.0-SNAPSHOT</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                    <version>3.0.0</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Path pomPath = Paths.get("/project/pom.xml").toAbsolutePath();
@@ -1009,27 +1014,27 @@ void shouldInjectPluginManagementForLocallyDeclaredPluginWithoutVersion() throws
             // Since the child does declare the plugin, mvnup should add a pluginManagement
             // entry to override the inherited version.
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <parent>
-                        <groupId>org.apache</groupId>
-                        <artifactId>apache</artifactId>
-                        <version>23</version>
-                    </parent>
-                    <groupId>org.example</groupId>
-                    <artifactId>test-child</artifactId>
-                    <version>1.0.0-SNAPSHOT</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-enforcer-plugin</artifactId>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <parent>
+                            <groupId>org.apache</groupId>
+                            <artifactId>apache</artifactId>
+                            <version>23</version>
+                        </parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>test-child</artifactId>
+                        <version>1.0.0-SNAPSHOT</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Path tempDir = Files.createTempDirectory("mvnup-test-");
             try {
@@ -1074,17 +1079,17 @@ class ErrorHandlingTests {
         @DisplayName("should warn when effective model analysis fails for POM with unresolvable remote parent")
         void shouldWarnWhenEffectiveModelAnalysisFailsForUnresolvableRemoteParent() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <parent>
-                        <groupId>com.nonexistent.test</groupId>
-                        <artifactId>nonexistent-parent</artifactId>
-                        <version>1.0.0</version>
-                    </parent>
-                    <artifactId>test-child</artifactId>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <parent>
+                            <groupId>com.nonexistent.test</groupId>
+                            <artifactId>nonexistent-parent</artifactId>
+                            <version>1.0.0</version>
+                        </parent>
+                        <artifactId>test-child</artifactId>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -1104,6 +1109,42 @@ void shouldWarnWhenEffectiveModelAnalysisFailsForUnresolvableRemoteParent() thro
         @DisplayName("should handle malformed POM gracefully")
         void shouldHandleMalformedPOMGracefully() throws Exception {
             String malformedPomXml = """
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <!-- Missing required elements -->
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
+
+            Document document = Document.of(malformedPomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            // Strategy should handle malformed POMs gracefully
+            assertNotNull(result, "Result should not be null");
+            assertTrue(result.processedPoms().contains(Paths.get("pom.xml")), "POM should be marked as processed");
+        }
+    }
+
+    @Nested
+    @DisplayName("Quarkus Plugin Upgrades")
+    class QuarkusPluginUpgradeTests {
+
+        @Test
+        @DisplayName("should upgrade quarkus-maven-plugin with io.quarkus groupId when below minimum")
+        void shouldUpgradeQuarkusPluginWithIoQuarkusGroupId() throws Exception {
+            String pomXml = """
                 <?xml version="1.0" encoding="UTF-8"?>
                 <project xmlns="http://maven.apache.org/POM/4.0.0">
                     <modelVersion>4.0.0</modelVersion>
@@ -1113,22 +1154,458 @@ void shouldHandleMalformedPOMGracefully() throws Exception {
                     <build>
                         <plugins>
                             <plugin>
-                                <!-- Missing required elements -->
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>3.16.3</version>
                             </plugin>
                         </plugins>
                     </build>
                 </project>
                 """;
 
-            Document document = Document.of(malformedPomXml);
+            Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
 
             UpgradeContext context = createMockContext();
             UpgradeResult result = strategy.doApply(context, pomMap);
 
-            // Strategy should handle malformed POMs gracefully
-            assertNotNull(result, "Result should not be null");
-            assertTrue(result.processedPoms().contains(Paths.get("pom.xml")), "POM should be marked as processed");
+            assertTrue(result.success(), "Plugin upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have upgraded quarkus-maven-plugin");
+
+            Editor editor = new Editor(document);
+            String version = editor.root()
+                    .path("build", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.26.0", version, "quarkus-maven-plugin should be upgraded to 3.26.0");
+        }
+
+        @Test
+        @DisplayName("should upgrade quarkus-maven-plugin with io.quarkus.platform groupId when below minimum")
+        void shouldUpgradeQuarkusPluginWithPlatformGroupId() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>3.16.3</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Plugin upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have upgraded quarkus-maven-plugin");
+
+            Editor editor = new Editor(document);
+            String version = editor.root()
+                    .path("build", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.26.0", version, "quarkus-maven-plugin should be upgraded to 3.26.0");
+        }
+
+        @Test
+        @DisplayName("should not upgrade quarkus-maven-plugin when version is already sufficient")
+        void shouldNotUpgradeQuarkusPluginWhenVersionSufficient() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>3.31.4</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            Editor editor = new Editor(document);
+            String version = editor.root()
+                    .path("build", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.31.4", version, "Version 3.31.4 should be preserved");
+        }
+
+        @Test
+        @DisplayName("should decouple plugin version from shared BOM property")
+        void shouldDecouplePluginVersionFromSharedBomProperty() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.platform.version>3.16.3</quarkus.platform.version>
+                    </properties>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Plugin upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POM");
+
+            // BOM property should be unchanged
+            Editor editor = new Editor(document);
+            String bomVersion = editor.root()
+                    .path("properties", "quarkus.platform.version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.16.3", bomVersion, "BOM property should remain unchanged at 3.16.3");
+
+            // New property should be introduced
+            String pluginVersion = editor.root()
+                    .path("properties", "quarkus-plugin.version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.26.0", pluginVersion, "New quarkus-plugin.version property should be 3.26.0");
+
+            // Plugin version should reference the new property
+            String pluginVersionRef = editor.root()
+                    .path("build", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals(
+                    "${quarkus-plugin.version}",
+                    pluginVersionRef,
+                    "Plugin should reference the new quarkus-plugin.version property");
+        }
+
+        @Test
+        @DisplayName("should not decouple when plugin has its own property not shared with BOM")
+        void shouldNotDecoupleWhenPluginHasOwnProperty() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus-plugin.version>3.16.3</quarkus-plugin.version>
+                    </properties>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>${quarkus-plugin.version}</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Plugin upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have upgraded quarkus-maven-plugin");
+
+            // The property should be upgraded directly (no decoupling needed)
+            Editor editor = new Editor(document);
+            String version = editor.root()
+                    .path("properties", "quarkus-plugin.version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.26.0", version, "Property should be upgraded directly to 3.26.0");
+
+            // Plugin should still reference the same property
+            String pluginVersionRef = editor.root()
+                    .path("build", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals(
+                    "${quarkus-plugin.version}", pluginVersionRef, "Plugin should still reference the same property");
+        }
+
+        @Test
+        @DisplayName("should not decouple when BOM version is already sufficient")
+        void shouldNotDecoupleWhenBomVersionSufficient() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.platform.version>3.31.4</quarkus.platform.version>
+                    </properties>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            // No new property should be introduced — version is already sufficient
+            Editor editor = new Editor(document);
+            String bomVersion = editor.root()
+                    .path("properties", "quarkus.platform.version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.31.4", bomVersion, "BOM property should remain unchanged");
+
+            // No quarkus-plugin.version should exist
+            Element newProp =
+                    editor.root().path("properties", "quarkus-plugin.version").orElse(null);
+            assertTrue(newProp == null, "Should not introduce new property when version is already sufficient");
+        }
+
+        @Test
+        @DisplayName("should emit version gap warning when decoupling")
+        void shouldEmitVersionGapWarningWhenDecoupling() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.platform.version>3.16.3</quarkus.platform.version>
+                    </properties>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            // Verify warning was emitted about the version gap
+            verify(context.logger, atLeastOnce())
+                    .warn(argThat(msg -> msg.contains("quarkus-maven-plugin upgraded to 3.26.0")
+                            && msg.contains("3.16.3")
+                            && msg.contains("mismatched plugin and platform")));
+        }
+
+        @Test
+        @DisplayName("should include quarkus-maven-plugin in predefined plugin upgrades")
+        void shouldIncludeQuarkusPluginInPredefinedUpgrades() {
+            List<PluginUpgrade> upgrades = PluginUpgradeStrategy.getPluginUpgrades();
+
+            boolean hasIoQuarkus = upgrades.stream()
+                    .anyMatch(u -> "io.quarkus".equals(u.groupId()) && "quarkus-maven-plugin".equals(u.artifactId()));
+            boolean hasIoQuarkusPlatform = upgrades.stream()
+                    .anyMatch(u ->
+                            "io.quarkus.platform".equals(u.groupId()) && "quarkus-maven-plugin".equals(u.artifactId()));
+
+            assertTrue(hasIoQuarkus, "Should include io.quarkus:quarkus-maven-plugin upgrade");
+            assertTrue(hasIoQuarkusPlatform, "Should include io.quarkus.platform:quarkus-maven-plugin upgrade");
+
+            // Verify the reason text
+            upgrades.stream()
+                    .filter(u -> "quarkus-maven-plugin".equals(u.artifactId()))
+                    .forEach(u -> assertEquals(
+                            "Maven 4 compatibility (Aether API changes)",
+                            u.reason(),
+                            "Quarkus plugin upgrade should have the correct reason"));
+        }
+
+        @Test
+        @DisplayName("should upgrade quarkus-maven-plugin in pluginManagement")
+        void shouldUpgradeQuarkusPluginInPluginManagement() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <groupId>io.quarkus</groupId>
+                                    <artifactId>quarkus-maven-plugin</artifactId>
+                                    <version>3.16.3</version>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Plugin upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have upgraded quarkus-maven-plugin in pluginManagement");
+
+            Editor editor = new Editor(document);
+            String version = editor.root()
+                    .path("build", "pluginManagement", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals("3.26.0", version, "quarkus-maven-plugin in pluginManagement should be upgraded to 3.26.0");
+        }
+
+        @Test
+        @DisplayName("should not decouple when shared property is inherited from parent POM")
+        void shouldNotDecoupleWhenSharedPropertyIsInherited() throws Exception {
+            // The shared property is NOT declared in this POM — it's inherited from a parent.
+            // We cannot resolve its value, so decoupling should be skipped to avoid
+            // introducing a quarkus-plugin.version=3.26.0 that might downgrade an already-sufficient version.
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <parent>
+                        <groupId>org.example</groupId>
+                        <artifactId>parent</artifactId>
+                        <version>1.0.0</version>
+                    </parent>
+                    <artifactId>child</artifactId>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            Editor editor = new Editor(document);
+            Element newProp =
+                    editor.root().path("properties", "quarkus-plugin.version").orElse(null);
+            assertTrue(
+                    newProp == null, "Should not introduce quarkus-plugin.version when shared property is inherited");
+
+            // The plugin version reference should remain unchanged
+            String pluginVersion = editor.root()
+                    .path("build", "plugins", "plugin", "version")
+                    .map(Element::textContentTrimmed)
+                    .orElse(null);
+            assertEquals(
+                    "${quarkus.platform.version}",
+                    pluginVersion,
+                    "Plugin version should remain as the inherited property reference");
         }
     }
 
@@ -1155,23 +1632,23 @@ class XmlFormattingTests {
         @DisplayName("should format pluginManagement with proper indentation")
         void shouldFormatPluginManagementWithProperIndentation() throws Exception {
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-compiler-plugin</artifactId>
-                                <version>3.1</version>
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-compiler-plugin</artifactId>
+                                    <version>3.1</version>
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
@@ -1200,23 +1677,23 @@ void shouldFormatPluginManagementWithProperIndentation() throws Exception {
         void shouldFormatPluginManagementWithProperIndentationWhenAdded() throws Exception {
             // Use a POM that will trigger pluginManagement addition by having a plugin without version
             String pomXml = """
-                <?xml version="1.0" encoding="UTF-8"?>
-                <project xmlns="http://maven.apache.org/POM/4.0.0">
-                    <modelVersion>4.0.0</modelVersion>
-                    <groupId>test</groupId>
-                    <artifactId>test</artifactId>
-                    <version>1.0.0</version>
-                    <build>
-                        <plugins>
-                            <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-enforcer-plugin</artifactId>
-                                <!-- No version - should trigger pluginManagement addition -->
-                            </plugin>
-                        </plugins>
-                    </build>
-                </project>
-                """;
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <project xmlns="http://maven.apache.org/POM/4.0.0">
+                        <modelVersion>4.0.0</modelVersion>
+                        <groupId>test</groupId>
+                        <artifactId>test</artifactId>
+                        <version>1.0.0</version>
+                        <build>
+                            <plugins>
+                                <plugin>
+                                    <groupId>org.apache.maven.plugins</groupId>
+                                    <artifactId>maven-enforcer-plugin</artifactId>
+                                    <!-- No version - should trigger pluginManagement addition -->
+                                </plugin>
+                            </plugins>
+                        </build>
+                    </project>
+                    """;
 
             Document document = Document.of(pomXml);
             Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/QuarkusPlatformVersionTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/QuarkusPlatformVersionTest.java
new file mode 100644
index 0000000000..7b2f2b82cb
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/QuarkusPlatformVersionTest.java
@@ -0,0 +1,439 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+
+import eu.maveniverse.domtrip.Document;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests for Quarkus platform version detection and the Quarkus 2.x upgrade skip behavior
+ * in {@link PluginUpgradeStrategy}.
+ */
+@DisplayName("Quarkus Platform Version Detection and Skip")
+class QuarkusPlatformVersionTest {
+
+    private PluginUpgradeStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new PluginUpgradeStrategy();
+    }
+
+    private UpgradeContext createMockContext() {
+        return TestUtils.createMockContext();
+    }
+
+    @Nested
+    @DisplayName("Platform Version Detection")
+    class PlatformVersionDetectionTests {
+
+        @Test
+        @DisplayName("should detect version from quarkus-bom with io.quarkus.platform groupId")
+        void shouldDetectFromQuarkusPlatformBom() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>2.16.7.Final</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertEquals("2.16.7.Final", strategy.detectQuarkusPlatformVersion(document));
+        }
+
+        @Test
+        @DisplayName("should detect version from quarkus-bom with io.quarkus groupId")
+        void shouldDetectFromQuarkusBom() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>3.15.0</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertEquals("3.15.0", strategy.detectQuarkusPlatformVersion(document));
+        }
+
+        @Test
+        @DisplayName("should resolve property reference in BOM version")
+        void shouldResolvePropertyInBomVersion() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.platform.version>2.16.7.Final</quarkus.platform.version>
+                    </properties>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertEquals("2.16.7.Final", strategy.detectQuarkusPlatformVersion(document));
+        }
+
+        @Test
+        @DisplayName("should fall back to quarkus.platform.version property when no BOM present")
+        void shouldFallbackToQuarkusPlatformVersionProperty() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.platform.version>2.16.7.Final</quarkus.platform.version>
+                    </properties>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertEquals("2.16.7.Final", strategy.detectQuarkusPlatformVersion(document));
+        }
+
+        @Test
+        @DisplayName("should fall back to quarkus.version property")
+        void shouldFallbackToQuarkusVersionProperty() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.version>2.13.5.Final</quarkus.version>
+                    </properties>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertEquals("2.13.5.Final", strategy.detectQuarkusPlatformVersion(document));
+        }
+
+        @Test
+        @DisplayName("should return null when no Quarkus version can be detected")
+        void shouldReturnNullWhenNoQuarkusVersion() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertNull(strategy.detectQuarkusPlatformVersion(document));
+        }
+    }
+
+    @Nested
+    @DisplayName("Quarkus 2.x Upgrade Skip")
+    class Quarkus2xUpgradeSkipTests {
+
+        @Test
+        @DisplayName("should skip quarkus-maven-plugin upgrade when project uses Quarkus 2.x BOM")
+        void shouldSkipQuarkusUpgradeWhenQuarkus2xBom() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>2.16.7.Final</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>2.16.7.Final</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("<version>2.16.7.Final</version>"),
+                    "quarkus-maven-plugin should NOT be upgraded when project uses Quarkus 2.x");
+            assertFalse(xml.contains("<version>3.26.0</version>"), "quarkus-maven-plugin should NOT be set to 3.26.0");
+        }
+
+        @Test
+        @DisplayName("should skip quarkus-maven-plugin upgrade when Quarkus 2.x version comes from property")
+        void shouldSkipQuarkusUpgradeWhenQuarkus2xProperty() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.platform.version>2.16.7.Final</quarkus.platform.version>
+                    </properties>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>${quarkus.platform.version}</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>2.16.7.Final</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("<version>2.16.7.Final</version>"),
+                    "quarkus-maven-plugin should NOT be upgraded when project uses Quarkus 2.x (via property)");
+        }
+
+        @Test
+        @DisplayName("should still upgrade quarkus-maven-plugin when project uses Quarkus 3.x")
+        void shouldUpgradeQuarkusPluginWhenQuarkus3x() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>3.15.0</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>3.15.0</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("<version>3.26.0</version>"),
+                    "quarkus-maven-plugin should be upgraded when project uses Quarkus 3.x");
+        }
+
+        @Test
+        @DisplayName("should skip quarkus-maven-plugin upgrade when quarkus.version property is 2.x")
+        void shouldSkipQuarkusUpgradeFromQuarkusVersionProperty() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <properties>
+                        <quarkus.version>2.13.5.Final</quarkus.version>
+                    </properties>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>2.13.5.Final</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("<version>2.13.5.Final</version>"),
+                    "quarkus-maven-plugin should NOT be upgraded when quarkus.version property is 2.x");
+        }
+
+        @Test
+        @DisplayName("should skip upgrade for io.quarkus.platform groupId with Quarkus 2.x")
+        void shouldSkipQuarkusPlatformGroupIdUpgradeWithQuarkus2x() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <dependencyManagement>
+                        <dependencies>
+                            <dependency>
+                                <groupId>io.quarkus</groupId>
+                                <artifactId>quarkus-bom</artifactId>
+                                <version>2.16.7.Final</version>
+                                <type>pom</type>
+                                <scope>import</scope>
+                            </dependency>
+                        </dependencies>
+                    </dependencyManagement>
+                    <build>
+                        <plugins>
+                            <plugin>
+                                <groupId>io.quarkus.platform</groupId>
+                                <artifactId>quarkus-maven-plugin</artifactId>
+                                <version>2.16.7.Final</version>
+                            </plugin>
+                        </plugins>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("<version>2.16.7.Final</version>"),
+                    "quarkus-maven-plugin should NOT be upgraded for io.quarkus.platform with Quarkus 2.x");
+        }
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/RepositoryHttpsUpgradeStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/RepositoryHttpsUpgradeStrategyTest.java
new file mode 100644
index 0000000000..3bd7ef4cc1
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/RepositoryHttpsUpgradeStrategyTest.java
@@ -0,0 +1,768 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.Optional;
+
+import eu.maveniverse.domtrip.Document;
+import org.apache.maven.api.cli.mvnup.UpgradeOptions;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Unit tests for the {@link RepositoryHttpsUpgradeStrategy} class.
+ * Tests HTTP to HTTPS repository URL upgrades for all POM sections.
+ */
+@DisplayName("RepositoryHttpsUpgradeStrategy")
+class RepositoryHttpsUpgradeStrategyTest {
+
+    private RepositoryHttpsUpgradeStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new RepositoryHttpsUpgradeStrategy();
+    }
+
+    private UpgradeContext createMockContext() {
+        return TestUtils.createMockContext();
+    }
+
+    private UpgradeContext createMockContext(UpgradeOptions options) {
+        return TestUtils.createMockContext(options);
+    }
+
+    @Nested
+    @DisplayName("Applicability")
+    class ApplicabilityTests {
+
+        @Test
+        @DisplayName("should be applicable when --model option is true")
+        void shouldBeApplicableWhenModelOptionTrue() {
+            UpgradeOptions options = mock(UpgradeOptions.class);
+            when(options.model()).thenReturn(Optional.of(true));
+            when(options.all()).thenReturn(Optional.empty());
+            when(options.infer()).thenReturn(Optional.empty());
+            when(options.plugins()).thenReturn(Optional.empty());
+            when(options.modelVersion()).thenReturn(Optional.empty());
+
+            UpgradeContext context = createMockContext(options);
+
+            assertTrue(strategy.isApplicable(context), "Strategy should be applicable when --model is true");
+        }
+
+        @Test
+        @DisplayName("should be applicable when --all option is specified")
+        void shouldBeApplicableWhenAllOptionSpecified() {
+            UpgradeOptions options = mock(UpgradeOptions.class);
+            when(options.all()).thenReturn(Optional.of(true));
+            when(options.model()).thenReturn(Optional.empty());
+            when(options.infer()).thenReturn(Optional.empty());
+            when(options.plugins()).thenReturn(Optional.empty());
+            when(options.modelVersion()).thenReturn(Optional.empty());
+
+            UpgradeContext context = createMockContext(options);
+
+            assertTrue(strategy.isApplicable(context), "Strategy should be applicable when --all is specified");
+        }
+
+        @Test
+        @DisplayName("should be applicable by default when no specific options provided")
+        void shouldBeApplicableByDefaultWhenNoSpecificOptions() {
+            UpgradeOptions options = TestUtils.createDefaultOptions();
+
+            UpgradeContext context = createMockContext(options);
+
+            assertTrue(strategy.isApplicable(context), "Strategy should be applicable by default");
+        }
+
+        @Test
+        @DisplayName("should not be applicable when --model option is false and other options set")
+        void shouldNotBeApplicableWhenModelOptionFalseAndOtherOptionsSet() {
+            UpgradeOptions options = mock(UpgradeOptions.class);
+            when(options.model()).thenReturn(Optional.of(false));
+            when(options.all()).thenReturn(Optional.empty());
+            when(options.infer()).thenReturn(Optional.empty());
+            when(options.plugins()).thenReturn(Optional.of(true));
+            when(options.modelVersion()).thenReturn(Optional.empty());
+
+            UpgradeContext context = createMockContext(options);
+
+            assertFalse(strategy.isApplicable(context), "Strategy should not be applicable when --model is false");
+        }
+    }
+
+    @Nested
+    @DisplayName("Well-Known URL Mappings")
+    class WellKnownUrlMappingTests {
+
+        @Test
+        @DisplayName("should map Apache snapshots repository URL")
+        void shouldMapApacheSnapshotsUrl() {
+            assertEquals(
+                    "https://repository.apache.org/snapshots",
+                    RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://repository.apache.org/snapshots"));
+        }
+
+        @Test
+        @DisplayName("should map Apache releases repository URL")
+        void shouldMapApacheReleasesUrl() {
+            assertEquals(
+                    "https://repository.apache.org/releases",
+                    RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://repository.apache.org/releases"));
+        }
+
+        @Test
+        @DisplayName("should map repo1.maven.org to canonical HTTPS URL")
+        void shouldMapRepo1MavenOrg() {
+            assertEquals(
+                    "https://repo.maven.apache.org/maven2",
+                    RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://repo1.maven.org/maven2"));
+        }
+
+        @Test
+        @DisplayName("should map repo.maven.apache.org to canonical HTTPS URL")
+        void shouldMapRepoMavenApacheOrg() {
+            assertEquals(
+                    "https://repo.maven.apache.org/maven2",
+                    RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://repo.maven.apache.org/maven2"));
+        }
+
+        @Test
+        @DisplayName("should map central.maven.org to canonical HTTPS URL")
+        void shouldMapCentralMavenOrg() {
+            assertEquals(
+                    "https://repo.maven.apache.org/maven2",
+                    RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://central.maven.org/maven2"));
+        }
+
+        @Test
+        @DisplayName("should preserve trailing slash for well-known URLs")
+        void shouldPreserveTrailingSlash() {
+            assertEquals(
+                    "https://repo.maven.apache.org/maven2/",
+                    RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://repo1.maven.org/maven2/"));
+        }
+
+        @Test
+        @DisplayName("should return null for unknown URLs")
+        void shouldReturnNullForUnknownUrls() {
+            assertNull(RepositoryHttpsUpgradeStrategy.mapWellKnownUrl("http://example.com/repo"));
+        }
+    }
+
+    @Nested
+    @DisplayName("Repository URL Upgrades")
+    class RepositoryUrlUpgradeTests {
+
+        @Test
+        @DisplayName("should upgrade HTTP repository URL to HTTPS")
+        void shouldUpgradeHttpRepositoryUrl() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>my-repo</id>
+                            <url>http://example.com/maven2</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("https://example.com/maven2"), "URL should be upgraded to HTTPS");
+            assertFalse(
+                    xml.contains("http://example.com/maven2"),
+                    "Original HTTP URL should be replaced (excluding xmlns)");
+        }
+
+        @Test
+        @DisplayName("should upgrade well-known Apache snapshots URL")
+        void shouldUpgradeWellKnownApacheSnapshotsUrl() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>apache-snapshots</id>
+                            <url>http://repository.apache.org/snapshots</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://repository.apache.org/snapshots"),
+                    "URL should be upgraded to canonical HTTPS URL");
+        }
+
+        @Test
+        @DisplayName("should normalize repo1.maven.org to canonical URL")
+        void shouldNormalizeRepo1MavenOrg() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>central</id>
+                            <url>http://repo1.maven.org/maven2</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://repo.maven.apache.org/maven2"),
+                    "URL should be normalized to canonical Maven Central HTTPS URL");
+        }
+
+        @Test
+        @DisplayName("should not modify URLs already using HTTPS")
+        void shouldNotModifyHttpsUrls() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>central</id>
+                            <url>https://repo.maven.apache.org/maven2</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertEquals(0, result.modifiedCount(), "No POMs should be modified");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("https://repo.maven.apache.org/maven2"), "HTTPS URL should remain unchanged");
+        }
+
+        @Test
+        @DisplayName("should handle POM with no repositories")
+        void shouldHandlePomWithNoRepositories() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertEquals(0, result.modifiedCount(), "No POMs should be modified");
+        }
+    }
+
+    @Nested
+    @DisplayName("Plugin Repository URL Upgrades")
+    class PluginRepositoryUrlUpgradeTests {
+
+        @Test
+        @DisplayName("should upgrade HTTP pluginRepository URL to HTTPS")
+        void shouldUpgradeHttpPluginRepositoryUrl() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <pluginRepositories>
+                        <pluginRepository>
+                            <id>my-plugin-repo</id>
+                            <url>http://plugins.example.com/maven2</url>
+                        </pluginRepository>
+                    </pluginRepositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("https://plugins.example.com/maven2"), "Plugin repository URL should be upgraded");
+        }
+    }
+
+    @Nested
+    @DisplayName("Distribution Management URL Upgrades")
+    class DistributionManagementUrlUpgradeTests {
+
+        @Test
+        @DisplayName("should upgrade distributionManagement repository URL")
+        void shouldUpgradeDistributionManagementRepositoryUrl() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <distributionManagement>
+                        <repository>
+                            <id>releases</id>
+                            <url>http://repository.apache.org/releases</url>
+                        </repository>
+                    </distributionManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://repository.apache.org/releases"),
+                    "Distribution management repository URL should be upgraded");
+        }
+
+        @Test
+        @DisplayName("should upgrade distributionManagement snapshotRepository URL")
+        void shouldUpgradeDistributionManagementSnapshotRepositoryUrl() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <distributionManagement>
+                        <snapshotRepository>
+                            <id>snapshots</id>
+                            <url>http://repository.apache.org/snapshots</url>
+                        </snapshotRepository>
+                    </distributionManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://repository.apache.org/snapshots"),
+                    "Snapshot repository URL should be upgraded");
+        }
+
+        @Test
+        @DisplayName("should upgrade both repository and snapshotRepository in distributionManagement")
+        void shouldUpgradeBothRepositoryAndSnapshotRepository() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <distributionManagement>
+                        <repository>
+                            <id>releases</id>
+                            <url>http://nexus.example.com/releases</url>
+                        </repository>
+                        <snapshotRepository>
+                            <id>snapshots</id>
+                            <url>http://nexus.example.com/snapshots</url>
+                        </snapshotRepository>
+                    </distributionManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("https://nexus.example.com/releases"), "Repository URL should be upgraded");
+            assertTrue(
+                    xml.contains("https://nexus.example.com/snapshots"), "Snapshot repository URL should be upgraded");
+        }
+    }
+
+    @Nested
+    @DisplayName("Profile-Scoped Repository URL Upgrades")
+    class ProfileScopedRepositoryUrlUpgradeTests {
+
+        @Test
+        @DisplayName("should upgrade HTTP repository URLs in profiles")
+        void shouldUpgradeHttpRepositoryUrlsInProfiles() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <profiles>
+                        <profile>
+                            <id>staging</id>
+                            <repositories>
+                                <repository>
+                                    <id>staging-repo</id>
+                                    <url>http://staging.example.com/maven2</url>
+                                </repository>
+                            </repositories>
+                        </profile>
+                    </profiles>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://staging.example.com/maven2"),
+                    "Profile repository URL should be upgraded to HTTPS");
+        }
+
+        @Test
+        @DisplayName("should upgrade HTTP pluginRepository URLs in profiles")
+        void shouldUpgradeHttpPluginRepositoryUrlsInProfiles() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <profiles>
+                        <profile>
+                            <id>staging</id>
+                            <pluginRepositories>
+                                <pluginRepository>
+                                    <id>staging-plugins</id>
+                                    <url>http://staging.example.com/plugins</url>
+                                </pluginRepository>
+                            </pluginRepositories>
+                        </profile>
+                    </profiles>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://staging.example.com/plugins"),
+                    "Profile plugin repository URL should be upgraded to HTTPS");
+        }
+    }
+
+    @Nested
+    @DisplayName("Multiple Repositories")
+    class MultipleRepositoriesTests {
+
+        @Test
+        @DisplayName("should upgrade multiple HTTP repository URLs in a single POM")
+        void shouldUpgradeMultipleHttpRepositoryUrls() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>central</id>
+                            <url>http://repo1.maven.org/maven2</url>
+                        </repository>
+                        <repository>
+                            <id>custom</id>
+                            <url>http://custom.example.com/repo</url>
+                        </repository>
+                        <repository>
+                            <id>secure</id>
+                            <url>https://secure.example.com/repo</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            // Well-known URL should be normalized
+            assertTrue(
+                    xml.contains("https://repo.maven.apache.org/maven2"),
+                    "repo1.maven.org should be normalized to canonical URL");
+            // Generic HTTP should be upgraded
+            assertTrue(xml.contains("https://custom.example.com/repo"), "Custom HTTP URL should be upgraded to HTTPS");
+            // HTTPS should remain unchanged
+            assertTrue(xml.contains("https://secure.example.com/repo"), "Existing HTTPS URL should remain unchanged");
+        }
+
+        @Test
+        @DisplayName("should upgrade repositories across all sections")
+        void shouldUpgradeRepositoriesAcrossAllSections() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>repo1</id>
+                            <url>http://repo.example.com/releases</url>
+                        </repository>
+                    </repositories>
+                    <pluginRepositories>
+                        <pluginRepository>
+                            <id>plugin-repo1</id>
+                            <url>http://plugins.example.com/releases</url>
+                        </pluginRepository>
+                    </pluginRepositories>
+                    <distributionManagement>
+                        <repository>
+                            <id>dist-repo</id>
+                            <url>http://dist.example.com/releases</url>
+                        </repository>
+                    </distributionManagement>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("https://repo.example.com/releases"), "Repository URL should be upgraded");
+            assertTrue(
+                    xml.contains("https://plugins.example.com/releases"), "Plugin repository URL should be upgraded");
+            assertTrue(
+                    xml.contains("https://dist.example.com/releases"),
+                    "Distribution management repository URL should be upgraded");
+        }
+    }
+
+    @Nested
+    @DisplayName("Edge Cases")
+    class EdgeCaseTests {
+
+        @Test
+        @DisplayName("should handle repository with no URL element")
+        void shouldHandleRepositoryWithNoUrlElement() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>no-url-repo</id>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed without errors");
+            assertEquals(0, result.modifiedCount(), "No POMs should be modified");
+        }
+
+        @Test
+        @DisplayName("should handle repository with no id element")
+        void shouldHandleRepositoryWithNoIdElement() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <url>http://example.com/maven2</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Upgrade should succeed");
+            assertTrue(result.modifiedCount() > 0, "Should have modified POMs");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("https://example.com/maven2"), "URL should be upgraded even without id");
+        }
+
+        @Test
+        @DisplayName("should normalize central.maven.org to canonical URL")
+        void shouldNormalizeCentralMavenOrg() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <repositories>
+                        <repository>
+                            <id>central</id>
+                            <url>http://central.maven.org/maven2</url>
+                        </repository>
+                    </repositories>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(
+                    xml.contains("https://repo.maven.apache.org/maven2"),
+                    "central.maven.org should be normalized to canonical Maven Central URL");
+        }
+    }
+}
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ResourceFilteringStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ResourceFilteringStrategyTest.java
new file mode 100644
index 0000000000..79e0b51074
--- /dev/null
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ResourceFilteringStrategyTest.java
@@ -0,0 +1,668 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.cling.invoker.mvnup.goals;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.Set;
+
+import eu.maveniverse.domtrip.Document;
+import eu.maveniverse.domtrip.Element;
+import org.apache.maven.cling.invoker.mvnup.UpgradeContext;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests for {@link ResourceFilteringStrategy}.
+ */
+@DisplayName("ResourceFilteringStrategy")
+class ResourceFilteringStrategyTest {
+
+    private ResourceFilteringStrategy strategy;
+
+    @BeforeEach
+    void setUp() {
+        strategy = new ResourceFilteringStrategy();
+    }
+
+    private UpgradeContext createMockContext() {
+        return TestUtils.createMockContext();
+    }
+
+    @Nested
+    @DisplayName("Filtering Detection")
+    class FilteringDetectionTests {
+
+        @Test
+        @DisplayName("should detect filtering enabled in resources")
+        void shouldDetectFilteringInResources() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Element build = document.root().childElement("build").orElse(null);
+            assertNotNull(build);
+            assertTrue(strategy.hasFilteringEnabled(build, "resources", "resource"));
+        }
+
+        @Test
+        @DisplayName("should detect filtering enabled in testResources")
+        void shouldDetectFilteringInTestResources() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <testResources>
+                            <testResource>
+                                <directory>src/test/resources</directory>
+                                <filtering>true</filtering>
+                            </testResource>
+                        </testResources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Element build = document.root().childElement("build").orElse(null);
+            assertNotNull(build);
+            assertTrue(strategy.hasFilteringEnabled(build, "testResources", "testResource"));
+        }
+
+        @Test
+        @DisplayName("should not detect filtering when set to false")
+        void shouldNotDetectFilteringWhenFalse() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>false</filtering>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Element build = document.root().childElement("build").orElse(null);
+            assertNotNull(build);
+            assertFalse(strategy.hasFilteringEnabled(build, "resources", "resource"));
+        }
+
+        @Test
+        @DisplayName("should not detect filtering when no filtering element present")
+        void shouldNotDetectFilteringWhenAbsent() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Element build = document.root().childElement("build").orElse(null);
+            assertNotNull(build);
+            assertFalse(strategy.hasFilteringEnabled(build, "resources", "resource"));
+        }
+    }
+
+    @Nested
+    @DisplayName("Existing Extensions Detection")
+    class ExistingExtensionsTests {
+
+        @Test
+        @DisplayName("should find existing nonFilteredFileExtensions in pluginManagement")
+        void shouldFindExistingExtensionsInPluginManagement() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <artifactId>maven-resources-plugin</artifactId>
+                                    <configuration>
+                                        <nonFilteredFileExtensions>
+                                            <nonFilteredFileExtension>pdf</nonFilteredFileExtension>
+                                            <nonFilteredFileExtension>zip</nonFilteredFileExtension>
+                                        </nonFilteredFileExtensions>
+                                    </configuration>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Set<String> extensions = strategy.findExistingNonFilteredExtensions(document.root());
+            assertNotNull(extensions);
+            assertEquals(2, extensions.size());
+            assertTrue(extensions.contains("pdf"));
+            assertTrue(extensions.contains("zip"));
+        }
+
+        @Test
+        @DisplayName("should return null when no maven-resources-plugin configured")
+        void shouldReturnNullWhenNoResourcesPlugin() {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            assertNull(strategy.findExistingNonFilteredExtensions(document.root()));
+        }
+    }
+
+    @Nested
+    @DisplayName("Full Strategy Application")
+    class StrategyApplicationTests {
+
+        @Test
+        @DisplayName("should add nonFilteredFileExtensions when filtering is enabled and no config exists")
+        void shouldAddExtensionsWhenFilteringEnabled() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<nonFilteredFileExtensions>"), "Should have added nonFilteredFileExtensions");
+            assertTrue(xml.contains("<nonFilteredFileExtension>xlsx</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>docx</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>pdf</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>jar</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>keystore</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>jks</nonFilteredFileExtension>"));
+            // Should be in pluginManagement
+            assertTrue(xml.contains("<pluginManagement>"), "Should have created pluginManagement");
+            assertTrue(xml.contains("maven-resources-plugin"), "Should reference maven-resources-plugin");
+        }
+
+        @Test
+        @DisplayName("should not modify POM when filtering is not enabled")
+        void shouldNotModifyWhenNoFiltering() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(0, result.modifiedCount(), "Should not have modified any POM");
+        }
+
+        @Test
+        @DisplayName("should not modify POM when nonFilteredFileExtensions already covers all binary types")
+        void shouldNotModifyWhenExtensionsAlreadyComplete() throws Exception {
+            StringBuilder extensionsXml = new StringBuilder();
+            for (String ext : ResourceFilteringStrategy.BINARY_EXTENSIONS) {
+                extensionsXml
+                        .append("                                <nonFilteredFileExtension>")
+                        .append(ext)
+                        .append("</nonFilteredFileExtension>\n");
+            }
+
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <artifactId>maven-resources-plugin</artifactId>
+                                    <configuration>
+                                        <nonFilteredFileExtensions>
+                """ + extensionsXml + """
+                                        </nonFilteredFileExtensions>
+                                    </configuration>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(0, result.modifiedCount(), "Should not have modified any POM");
+        }
+
+        @Test
+        @DisplayName("should merge missing extensions into existing configuration")
+        void shouldMergeMissingExtensions() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <artifactId>maven-resources-plugin</artifactId>
+                                    <configuration>
+                                        <nonFilteredFileExtensions>
+                                            <nonFilteredFileExtension>pdf</nonFilteredFileExtension>
+                                        </nonFilteredFileExtensions>
+                                    </configuration>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            // Original extension still present
+            assertTrue(xml.contains("<nonFilteredFileExtension>pdf</nonFilteredFileExtension>"));
+            // New extensions added
+            assertTrue(xml.contains("<nonFilteredFileExtension>xlsx</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>docx</nonFilteredFileExtension>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>jar</nonFilteredFileExtension>"));
+        }
+
+        @Test
+        @DisplayName("should handle testResources with filtering enabled")
+        void shouldHandleTestResourcesFiltering() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <testResources>
+                            <testResource>
+                                <directory>src/test/resources</directory>
+                                <filtering>true</filtering>
+                            </testResource>
+                        </testResources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<nonFilteredFileExtensions>"));
+        }
+
+        @Test
+        @DisplayName("should handle filtering in profile resources")
+        void shouldHandleProfileResourcesFiltering() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <profiles>
+                        <profile>
+                            <id>production</id>
+                            <build>
+                                <resources>
+                                    <resource>
+                                        <directory>src/main/resources</directory>
+                                        <filtering>true</filtering>
+                                    </resource>
+                                </resources>
+                            </build>
+                        </profile>
+                    </profiles>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<nonFilteredFileExtensions>"));
+        }
+
+        @Test
+        @DisplayName("should add to existing pluginManagement without duplicating plugin entry")
+        void shouldAddToExistingPluginManagement() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <artifactId>maven-compiler-plugin</artifactId>
+                                    <version>3.11.0</version>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("maven-resources-plugin"), "Should have added maven-resources-plugin");
+            assertTrue(xml.contains("maven-compiler-plugin"), "Should still have maven-compiler-plugin");
+            assertTrue(xml.contains("<nonFilteredFileExtensions>"));
+        }
+
+        @Test
+        @DisplayName("should not modify POM with no build section")
+        void shouldNotModifyWithNoBuildSection() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(0, result.modifiedCount(), "Should not have modified any POM");
+        }
+
+        @Test
+        @DisplayName("should add config to existing maven-resources-plugin in pluginManagement")
+        void shouldAddConfigToExistingResourcesPlugin() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                        <pluginManagement>
+                            <plugins>
+                                <plugin>
+                                    <artifactId>maven-resources-plugin</artifactId>
+                                    <version>3.3.1</version>
+                                </plugin>
+                            </plugins>
+                        </pluginManagement>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            UpgradeResult result = strategy.doApply(context, pomMap);
+
+            assertTrue(result.success(), "Strategy should succeed");
+            assertEquals(1, result.modifiedCount(), "Should have modified 1 POM");
+
+            String xml = DomUtils.toXml(document);
+            assertTrue(xml.contains("<version>3.3.1</version>"), "Should preserve existing version");
+            assertTrue(xml.contains("<nonFilteredFileExtensions>"));
+            assertTrue(xml.contains("<nonFilteredFileExtension>xlsx</nonFilteredFileExtension>"));
+        }
+
+        @Test
+        @DisplayName("should include all binary extensions")
+        void shouldIncludeAllBinaryExtensions() throws Exception {
+            String pomXml = """
+                <?xml version="1.0" encoding="UTF-8"?>
+                <project xmlns="http://maven.apache.org/POM/4.0.0">
+                    <modelVersion>4.0.0</modelVersion>
+                    <groupId>test</groupId>
+                    <artifactId>test</artifactId>
+                    <version>1.0.0</version>
+                    <build>
+                        <resources>
+                            <resource>
+                                <directory>src/main/resources</directory>
+                                <filtering>true</filtering>
+                            </resource>
+                        </resources>
+                    </build>
+                </project>
+                """;
+
+            Document document = Document.of(pomXml);
+            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+            UpgradeContext context = createMockContext();
+            strategy.doApply(context, pomMap);
+
+            String xml = DomUtils.toXml(document);
+            for (String ext : ResourceFilteringStrategy.BINARY_EXTENSIONS) {
+                assertTrue(
+                        xml.contains("<nonFilteredFileExtension>" + ext + "</nonFilteredFileExtension>"),
+                        "Should include extension: " + ext);
+            }
+
+            assertEquals(33, ResourceFilteringStrategy.BINARY_EXTENSIONS.size(), "Should have exactly 33 extensions");
+        }
+    }
+
+    @Nested
+    @DisplayName("Applicability")
+    class ApplicabilityTests {
+
+        @Test
+        @DisplayName("should be applicable with default options")
+        void shouldBeApplicableWithDefaults() {
+            UpgradeContext context = createMockContext();
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should be applicable when --all is set")
+        void shouldBeApplicableWithAll() {
+            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptionsWithAll(true));
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should be applicable when --model is true")
+        void shouldBeApplicableWithModelTrue() {
+            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptionsWithFixModel(true));
+            assertTrue(strategy.isApplicable(context));
+        }
+
+        @Test
+        @DisplayName("should not be applicable when --model is false")
+        void shouldNotBeApplicableWithModelFalse() {
+            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptionsWithFixModel(false));
+            assertFalse(strategy.isApplicable(context));
+        }
+    }
+}