diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGeneratorRunner.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGeneratorRunner.java
index 8cc794f41f24..194420b7268c 100644
--- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGeneratorRunner.java
+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageGeneratorRunner.java
@@ -90,9 +90,11 @@
 
 public class NativeImageGeneratorRunner {
 
-    private volatile NativeImageGenerator generator;
+    public static final String NATIVE_IMAGE_MODULE_PREFIX = "org.graalvm.nativeimage.";
     public static final String IMAGE_BUILDER_ARG_FILE_OPTION = "--image-args-file=";
 
+    private volatile NativeImageGenerator generator;
+
     public enum BuildOutcome {
         SUCCESSFUL,
         FAILED,
@@ -189,11 +191,7 @@ public void run() {
 
     private static void checkBootModuleDependencies(boolean verbose) {
         Set<Module> allModules = ModuleLayer.boot().modules();
-        List<Module> builderModules = allModules.stream().filter(m -> m.isNamed() && m.getName().startsWith("org.graalvm.nativeimage.")).toList();
-        Set<Module> transitiveBuilderModules = new LinkedHashSet<>();
-        for (Module svmModule : builderModules) {
-            transitiveReaders(svmModule, allModules, transitiveBuilderModules);
-        }
+        Set<Module> transitiveBuilderModules = getNativeImageBuilderModules();
         if (verbose) {
             System.out.println(transitiveBuilderModules.stream()
                             .map(Module::getName)
@@ -234,6 +232,28 @@ private static void checkBootModuleDependencies(boolean verbose) {
         }
     }
 
+    /**
+     * Returns what are considered native-image builder modules: those are the modules with prefix
+     * {@value NativeImageGeneratorRunner#NATIVE_IMAGE_MODULE_PREFIX} and their reader modules.
+     */
+    public static Set<Module> getNativeImageBuilderModules() {
+        final var allModules = ModuleLayer.boot().modules();
+        List<Module> builderModules = new ArrayList<>(allModules.size());
+        for (Module m : allModules) {
+            if (m.isNamed()) {
+                if (m.getName().startsWith(NATIVE_IMAGE_MODULE_PREFIX)) {
+                    builderModules.add(m);
+                }
+            }
+        }
+
+        Set<Module> transitiveBuilderModules = new LinkedHashSet<>();
+        for (Module svmModule : builderModules) {
+            transitiveReaders(svmModule, allModules, transitiveBuilderModules);
+        }
+        return transitiveBuilderModules;
+    }
+
     public static void transitiveReaders(Module readModule, Set<Module> potentialReaders, Set<Module> actualReaders) {
         for (Module potentialReader : potentialReaders) {
             if (potentialReader.canRead(readModule)) {
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/SubstitutionReportFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/SubstitutionReportFeature.java
index 41ec30b59876..2757831c8017 100644
--- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/SubstitutionReportFeature.java
+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/SubstitutionReportFeature.java
@@ -30,9 +30,6 @@
 import java.util.TreeMap;
 import java.util.function.Function;
 
-import jdk.graal.compiler.options.Option;
-
-import com.oracle.svm.util.OriginalClassProvider;
 import com.oracle.graal.pointsto.meta.AnalysisField;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.AnalysisType;
@@ -44,27 +41,56 @@
 import com.oracle.svm.hosted.substitute.SubstitutionField;
 import com.oracle.svm.hosted.substitute.SubstitutionMethod;
 import com.oracle.svm.hosted.substitute.SubstitutionType;
+import com.oracle.svm.util.OriginalClassProvider;
 
+import jdk.graal.compiler.options.Option;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
+/// Feature that reports substitutions discovered during analysis: all with [Options#ReportPerformedSubstitutions],
+/// or only user-authored with [Options#ReportPerformedUserSubstitutions].
+/// > Note: The feature does not report `@Delete`, `@RecomputeFieldValue`, and `@InjectAccessors` annotations.
+///
+/// When enabled via [Options#ReportPerformedSubstitutions] or [Options#ReportPerformedUserSubstitutions],
+/// this feature scans the analysis universe after the analysis phase completes and collects substitutions:
+/// - type substitutions ([SubstitutionType])
+/// - method substitutions ([SubstitutionMethod])
+/// - field substitutions ([SubstitutionField])
+///
+/// The results are emitted as a CSV report using [ReportUtils] under the [SubstrateOptions#reportsPath()] directory.
+/// The report is named:
+/// `substitutions_<date>_<time>.csv` with the following columns:
+/// location, category (type/method/field), original, annotated
+/// where:
+/// - location: the originating code source (e.g., JAR URL) of the annotated (replacement) element
+/// - category: one of "type", "method", "field"
+/// - original: the original element being substituted
+/// - annotated: the annotated replacement element
 @AutomaticallyRegisteredFeature
 public class SubstitutionReportFeature implements InternalFeature {
 
     static class Options {
-        @Option(help = "Report performed substitutions")//
+        @Option(help = "Write a CSV report of all substitutions discovered during analysis to reports/substitutions<date>-<time>.csv. Columns: location, category (type/method/field), original, annotated.") //
         public static final HostedOptionKey<Boolean> ReportPerformedSubstitutions = new HostedOptionKey<>(false);
+
+        @Option(help = "Write a CSV report of user-authored substitutions originating from the application classpath or module path to reports/substitutions<date>-<time>.csv. Columns: location, category (type/method/field), original, annotated.") //
+        public static final HostedOptionKey<Boolean> ReportPerformedUserSubstitutions = new HostedOptionKey<>(false);
     }
 
-    private final boolean enabled = Options.ReportPerformedSubstitutions.getValue();
+    private final boolean enabled = Options.ReportPerformedSubstitutions.getValue() || Options.ReportPerformedUserSubstitutions.getValue();
+
+    /// Aggregated substitutions grouped by the [CodeSource] location (typically the JAR URL)
+    /// of the annotated (replacement) elements.
     private final Map<String, Substitutions> substitutions = new TreeMap<>();
 
+    /// Only participate in the image build when the reporting option is enabled.
     @Override
     public boolean isInConfiguration(IsInConfigurationAccess access) {
         return enabled;
     }
 
+    /// After analysis completes, collect all user-provided substitutions and write the CSV report.
     @Override
     public void afterAnalysis(AfterAnalysisAccess access) {
         FeatureImpl.AfterAnalysisAccessImpl accessImpl = (FeatureImpl.AfterAnalysisAccessImpl) access;
@@ -74,48 +100,61 @@ public void afterAnalysis(AfterAnalysisAccess access) {
         reportSubstitutions();
     }
 
+    /// Scans all reachable, non-array [AnalysisType] types and records those that are user
+    /// substitutions.
+    /// A [SubstitutionType] represents an annotated replacement for an original type.
     private void findSubstitutedTypes(FeatureImpl.AfterAnalysisAccessImpl access) {
         for (AnalysisType type : access.getUniverse().getTypes()) {
             if (type.isReachable() && !type.isArray()) {
                 ResolvedJavaType t = type.getWrapped();
-                if (t instanceof SubstitutionType) {
-                    SubstitutionType subType = (SubstitutionType) t;
-                    if (subType.isUserSubstitution()) {
-                        String jarLocation = getTypeClassFileLocation(subType.getAnnotated());
+                if (t instanceof SubstitutionType substType) {
+                    // Only report substitutions authored by users (filter out internal ones).
+                    if (shouldReport(substType.isUserSubstitution())) {
+                        String jarLocation = getTypeClassFileLocation(substType.getAnnotated());
                         substitutions.putIfAbsent(jarLocation, new Substitutions());
-                        substitutions.get(jarLocation).addType(subType);
+                        substitutions.get(jarLocation).addType(substType);
                     }
                 }
             }
         }
     }
 
+    /// Scans all [AnalysisMethod] methods in the analysis universe and records those that are
+    /// user substitutions.
+    /// A [SubstitutionMethod] holds both original and annotated (replacement) methods.
     private void findSubstitutedMethods(FeatureImpl.AfterAnalysisAccessImpl access) {
         for (AnalysisMethod method : access.getUniverse().getMethods()) {
-            if (method.wrapped instanceof SubstitutionMethod) {
-                SubstitutionMethod subMethod = (SubstitutionMethod) method.wrapped;
-                if (subMethod.isUserSubstitution()) {
-                    String jarLocation = getTypeClassFileLocation(subMethod.getAnnotated().getDeclaringClass());
+            if (method.wrapped instanceof SubstitutionMethod substMethod) {
+                if (shouldReport(substMethod.isUserSubstitution())) {
+                    String jarLocation = getTypeClassFileLocation(substMethod.getAnnotated().getDeclaringClass());
                     substitutions.putIfAbsent(jarLocation, new Substitutions());
-                    substitutions.get(jarLocation).addMethod(subMethod);
+                    substitutions.get(jarLocation).addMethod(substMethod);
                 }
             }
         }
     }
 
+    /// Scans all [AnalysisField] fields in the analysis universe and records those that are
+    /// user substitutions.
+    /// A [SubstitutionField] holds both original and annotated (replacement) fields.
     private void findSubstitutedFields(FeatureImpl.AfterAnalysisAccessImpl access) {
         for (AnalysisField field : access.getUniverse().getFields()) {
-            if (field.wrapped instanceof SubstitutionField) {
-                SubstitutionField subField = (SubstitutionField) field.wrapped;
-                if (subField.isUserSubstitution()) {
-                    String jarLocation = getTypeClassFileLocation(subField.getAnnotated().getDeclaringClass());
+            if (field.wrapped instanceof SubstitutionField substField) {
+                if (shouldReport(substField.isUserSubstitution())) {
+                    String jarLocation = getTypeClassFileLocation(substField.getAnnotated().getDeclaringClass());
                     substitutions.putIfAbsent(jarLocation, new Substitutions());
-                    substitutions.get(jarLocation).addField(subField);
+                    substitutions.get(jarLocation).addField(substField);
                 }
             }
         }
     }
 
+    /// Emits the CSV report with one row per discovered substitution.
+    /// The output file will be created under [SubstrateOptions#reportsPath()] with the name
+    /// `substitutions<date>_<time>.csv`. Rows are grouped by code source location and sorted using
+    /// human-readable formatting for types, methods, and fields (see
+    /// [#formatType(ResolvedJavaType)], [#formatMethod(ResolvedJavaMethod)],
+    /// [#formatField(ResolvedJavaField)]).
     private void reportSubstitutions() {
         ReportUtils.report("substitutions performed by native-image", SubstrateOptions.reportsPath(), "substitutions", "csv", pw -> {
             pw.println("location, category (type/method/field), original, annotated");
@@ -133,28 +172,50 @@ private void reportSubstitutions() {
         });
     }
 
+    private static boolean shouldReport(boolean userSubstitution) {
+        return userSubstitution || Options.ReportPerformedSubstitutions.getValue();
+    }
+
+    /// Fully-qualified type representation.
     private static String formatType(ResolvedJavaType t) {
         return t.toJavaName(true);
     }
 
+    /// Human-readable method representation.
+    /// Format: `pkg.Class#methodName`
     private static String formatMethod(ResolvedJavaMethod method) {
         return method.format("%H#%n");
     }
 
+    /// Human-readable field representation.
+    /// Format: `pkg.Class.fieldName`
     private static String formatField(ResolvedJavaField field) {
         return field.format("%H.%n");
     }
 
+    /// Determines the [CodeSource] (typically the JAR URL) that contains the given type (via
+    /// [OriginalClassProvider]).
+    /// Falls back to "unknown" when no code source is available (e.g., dynamically defined
+    /// classes).
     private static String getTypeClassFileLocation(ResolvedJavaType type) {
         Class<?> annotatedClass = OriginalClassProvider.getJavaClass(type);
         CodeSource source = annotatedClass.getProtectionDomain().getCodeSource();
-        return source == null ? "unknown" : source.getLocation().toString();
+        return source == null || source.getLocation() == null ? "unknown" : source.getLocation().toString();
     }
 
+    /// Formats a single CSV row representing one substitution. The JAR location is quoted to guard
+    /// against commas in URLs; other columns are formatted using the provided formatter.
     private static <T> String formatSubstitution(String jar, String type, T original, T annotated, Function<T, String> formatter) {
         return '\'' + jar + "'," + type + ',' + formatter.apply(original) + ',' + formatter.apply(annotated);
     }
 
+    /// Container for collected substitutions for a single code source location.
+    ///
+    /// Maps are keyed by the original element and map to the annotated (replacement) element.
+    /// TreeMaps are used with comparators based on the human-readable formatters (see
+    /// [#formatType(ResolvedJavaType)], [#formatMethod(ResolvedJavaMethod)],
+    /// [#formatField(ResolvedJavaField)]) so the output
+    /// remains stable and easy to consume.
     private static final class Substitutions {
         private final Map<ResolvedJavaType, ResolvedJavaType> substitutedTypes = new TreeMap<>(Comparator.comparing(SubstitutionReportFeature::formatType));
         private final Map<ResolvedJavaMethod, ResolvedJavaMethod> substitutedMethods = new TreeMap<>(Comparator.comparing(SubstitutionReportFeature::formatMethod));
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotationSubstitutionProcessor.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotationSubstitutionProcessor.java
index 5018e96cfa3a..609c7fff5696 100644
--- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotationSubstitutionProcessor.java
+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/AnnotationSubstitutionProcessor.java
@@ -83,6 +83,7 @@
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.ImageClassLoader;
 import com.oracle.svm.hosted.NativeImageGenerator;
+import com.oracle.svm.hosted.NativeImageGeneratorRunner;
 import com.oracle.svm.hosted.NativeImageOptions;
 import com.oracle.svm.hosted.SVMHost;
 import com.oracle.svm.hosted.ameta.FieldValueInterceptionSupport;
@@ -327,7 +328,7 @@ public ResolvedJavaMethod lookup(ResolvedJavaMethod method) {
                 }
 
                 PolymorphicSignatureWrapperMethod wrapperMethod = new PolymorphicSignatureWrapperMethod(substitutionBaseMethod, method);
-                SubstitutionMethod substitutionMethod = new SubstitutionMethod(method, wrapperMethod, false, true);
+                SubstitutionMethod substitutionMethod = new SubstitutionMethod(method, wrapperMethod, false, false);
                 synchronized (methodSubstitutions) {
                     /*
                      * It may happen that, during analysis, two threads are trying to register the
@@ -373,8 +374,9 @@ public void init(FieldValueInterceptionSupport newFieldValueInterceptionSupport)
         /* Sort by name to make processing order predictable for debugging. */
         annotatedClasses.sort(Comparator.comparing(Class::getName));
 
+        Set<Module> builderModules = NativeImageGeneratorRunner.getNativeImageBuilderModules();
         for (Class<?> annotatedClass : annotatedClasses) {
-            handleClass(annotatedClass);
+            handleClass(annotatedClass, builderModules);
         }
     }
 
@@ -382,7 +384,7 @@ protected List<Class<?>> findTargetClasses() {
         return imageClassLoader.findAnnotatedClasses(TargetClass.class, false);
     }
 
-    protected void handleClass(Class<?> annotatedClass) {
+    protected void handleClass(Class<?> annotatedClass, Set<Module> builderModules) {
         guarantee(Modifier.isFinal(annotatedClass.getModifiers()) || annotatedClass.isInterface(), "Annotated class must be final: %s", annotatedClass);
         guarantee(annotatedClass.getSuperclass() == Object.class || annotatedClass.isInterface(), "Annotated class must inherit directly from Object: %s", annotatedClass);
         guarantee(annotatedClass.getDeclaringClass() == null || Modifier.isStatic(annotatedClass.getModifiers()),
@@ -409,12 +411,13 @@ protected void handleClass(Class<?> annotatedClass) {
         int numAnnotations = (deleteAnnotation != null ? 1 : 0) + (substituteAnnotation != null ? 1 : 0);
         guarantee(numAnnotations <= 1, "Only one of @Delete or @Substitute can be used: %s", annotatedClass);
 
+        boolean userSubstitution = !builderModules.contains(annotatedClass.getModule());
         if (deleteAnnotation != null) {
             handleDeletedClass(originalClass, deleteAnnotation);
         } else if (substituteAnnotation != null) {
-            handleSubstitutionClass(annotatedClass, originalClass);
+            handleSubstitutionClass(annotatedClass, originalClass, userSubstitution);
         } else {
-            handleAliasClass(annotatedClass, originalClass, targetClassAnnotation);
+            handleAliasClass(annotatedClass, originalClass, targetClassAnnotation, userSubstitution);
         }
     }
 
@@ -422,7 +425,7 @@ private static String substitutionName(Class<?> originalClass) {
         return "Target_" + originalClass.getName().replace('.', '_').replace('$', '_');
     }
 
-    private void handleAliasClass(Class<?> annotatedClass, Class<?> originalClass, TargetClass targetClassAnnotation) {
+    private void handleAliasClass(Class<?> annotatedClass, Class<?> originalClass, TargetClass targetClassAnnotation, boolean userSubstitution) {
         if (VerifyNamingConventions.getValue() && targetClassAnnotation.classNameProvider() == TargetClass.NoClassNameProvider.class) {
             String expectedName = substitutionName(originalClass);
             // Checkstyle: allow Class.getSimpleName
@@ -441,17 +444,17 @@ private void handleAliasClass(Class<?> annotatedClass, Class<?> originalClass, T
         /* The aliases for array types are registered on demand. */
 
         for (Method annotatedMethod : annotatedClass.getDeclaredMethods()) {
-            handleMethodInAliasClass(annotatedMethod, originalClass);
+            handleMethodInAliasClass(annotatedMethod, originalClass, userSubstitution);
         }
         for (Constructor<?> annotatedMethod : annotatedClass.getDeclaredConstructors()) {
-            handleMethodInAliasClass(annotatedMethod, originalClass);
+            handleMethodInAliasClass(annotatedMethod, originalClass, userSubstitution);
         }
         for (Field annotatedField : annotatedClass.getDeclaredFields()) {
             handleFieldInAliasClass(annotatedField, originalClass);
         }
     }
 
-    private void handleMethodInAliasClass(Executable annotatedMethod, Class<?> originalClass) {
+    private void handleMethodInAliasClass(Executable annotatedMethod, Class<?> originalClass, boolean userSubstitution) {
         if (skipExcludedPlatform(annotatedMethod) || annotatedMethod.isSynthetic()) {
             return;
         }
@@ -512,7 +515,7 @@ private void handleMethodInAliasClass(Executable annotatedMethod, Class<?> origi
                 throw UserError.abort("@Uninterruptible may only be combined with @Substitute if the original method is effectively final: %s", annotatedMethod);
             }
 
-            SubstitutionMethod substitution = new SubstitutionMethod(original, annotated, false, true);
+            SubstitutionMethod substitution = new SubstitutionMethod(original, annotated, false, userSubstitution);
             if (substituteAnnotation.polymorphicSignature()) {
                 register(polymorphicMethodSubstitutions, annotated, original, substitution);
             }
@@ -735,8 +738,9 @@ private void registerAsDeleted(ResolvedJavaField annotated, ResolvedJavaField or
      *
      * @param substituteClass a {@link Substitute} annotated class whose {@link TargetElement}
      *            annotation denotes {@code originalClass}
+     * @param userSubstitution is the substitution coming from the classpath or the module path
      */
-    private void handleSubstitutionClass(Class<?> substituteClass, Class<?> originalClass) {
+    private void handleSubstitutionClass(Class<?> substituteClass, Class<?> originalClass, boolean userSubstitution) {
         // Not sure what happens if the target class is in a hierarchy - so prohibit that for now.
         guarantee(substituteClass.isInterface() == originalClass.isInterface(), "if original is interface, target must also be interface: %s", substituteClass);
         guarantee(originalClass.getSuperclass() == Object.class || originalClass.isInterface(), "target class must inherit directly from Object: %s", originalClass);
@@ -745,16 +749,16 @@ private void handleSubstitutionClass(Class<?> substituteClass, Class<?> original
         ResolvedJavaType original = metaAccess.lookupJavaType(originalClass);
         ResolvedJavaType substitute = metaAccess.lookupJavaType(substituteClass);
 
-        SubstitutionType substitution = new SubstitutionType(original, substitute, true);
+        SubstitutionType substitution = new SubstitutionType(original, substitute, userSubstitution);
         register(typeSubstitutions, substitute, original, substitution);
 
-        registerArrayTypes(original, substitute);
+        registerArrayTypes(original, substitute, userSubstitution);
 
         for (Method m : substituteClass.getDeclaredMethods()) {
-            handleAnnotatedMethodInSubstitutionClass(m, originalClass);
+            handleAnnotatedMethodInSubstitutionClass(m, originalClass, userSubstitution);
         }
         for (Constructor<?> c : substituteClass.getDeclaredConstructors()) {
-            handleAnnotatedMethodInSubstitutionClass(c, originalClass);
+            handleAnnotatedMethodInSubstitutionClass(c, originalClass, userSubstitution);
         }
         for (Method m : originalClass.getDeclaredMethods()) {
             handleOriginalMethodInSubstitutionClass(m, keepOriginalElements);
@@ -771,7 +775,7 @@ private void handleSubstitutionClass(Class<?> substituteClass, Class<?> original
                 guarantee(originalField == null || !(alias.isFinal() && !originalField.isFinal()), "a non-final field cannot be redeclared as final through substitution: %s", field);
                 register(fieldSubstitutions, field, originalField, alias);
             } else {
-                handleAnnotatedFieldInSubstitutionClass(f, originalClass);
+                handleAnnotatedFieldInSubstitutionClass(f, originalClass, userSubstitution);
             }
         }
 
@@ -785,19 +789,20 @@ private void handleSubstitutionClass(Class<?> substituteClass, Class<?> original
      * {@link #SUBSTITUTE_ARRAY_DIMENSIONS} dimensions.
      *
      * @param substitute the substitute class for {@code original}
+     * @param userSubstitution is the substitution coming from the classpath or the module path
      */
-    private void registerArrayTypes(ResolvedJavaType original, ResolvedJavaType substitute) {
+    private void registerArrayTypes(ResolvedJavaType original, ResolvedJavaType substitute, boolean userSubstitution) {
         ResolvedJavaType originalArray = original;
         ResolvedJavaType substituteArray = substitute;
         for (int i = 1; i <= SUBSTITUTE_ARRAY_DIMENSIONS; i++) {
             originalArray = originalArray.getArrayClass();
             substituteArray = substituteArray.getArrayClass();
-            SubstitutionType arrayTypeSubstitution = new SubstitutionType(originalArray, substituteArray, true);
+            SubstitutionType arrayTypeSubstitution = new SubstitutionType(originalArray, substituteArray, userSubstitution);
             register(typeSubstitutions, substituteArray, originalArray, arrayTypeSubstitution);
         }
     }
 
-    private void handleAnnotatedMethodInSubstitutionClass(Executable annotatedMethod, Class<?> originalClass) {
+    private void handleAnnotatedMethodInSubstitutionClass(Executable annotatedMethod, Class<?> originalClass, boolean userSubstitution) {
         if (skipExcludedPlatform(annotatedMethod)) {
             return;
         }
@@ -827,7 +832,7 @@ private void handleAnnotatedMethodInSubstitutionClass(Executable annotatedMethod
         if (original == null) {
             /* Optional target that is not present, so nothing to do. */
         } else if (substituteAnnotation != null) {
-            SubstitutionMethod substitution = new SubstitutionMethod(original, annotated, true, true);
+            SubstitutionMethod substitution = new SubstitutionMethod(original, annotated, true, userSubstitution);
             if (substituteAnnotation.polymorphicSignature()) {
                 register(polymorphicMethodSubstitutions, annotated, original, substitution);
             }
@@ -837,7 +842,7 @@ private void handleAnnotatedMethodInSubstitutionClass(Executable annotatedMethod
         }
     }
 
-    private void handleAnnotatedFieldInSubstitutionClass(Field annotatedField, Class<?> originalClass) {
+    private void handleAnnotatedFieldInSubstitutionClass(Field annotatedField, Class<?> originalClass, boolean userSubstitution) {
         if (skipExcludedPlatform(annotatedField)) {
             return;
         }
@@ -855,7 +860,7 @@ private void handleAnnotatedFieldInSubstitutionClass(Field annotatedField, Class
         if (original == null) {
             /* Optional target that is not present, so nothing to do. */
         } else {
-            register(fieldSubstitutions, annotated, original, new SubstitutionField(original, annotated, true));
+            register(fieldSubstitutions, annotated, original, new SubstitutionField(original, annotated, userSubstitution));
         }
     }
 
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionField.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionField.java
index 4544691813b2..c44f58b0a44c 100644
--- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionField.java
+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionField.java
@@ -41,18 +41,19 @@ public class SubstitutionField implements ResolvedJavaField, OriginalFieldProvid
 
     /**
      * This field is used in the {@link com.oracle.svm.hosted.SubstitutionReportFeature} class to
-     * determine {@link SubstitutionMethod} objects which correspond to annotated substitutions.
+     * determine {@link SubstitutionMethod} objects are user-defined substitutions (from the
+     * classpath).
      */
-    private final boolean isUserSubstitution;
+    private final boolean userSubstitution;
 
-    public SubstitutionField(ResolvedJavaField original, ResolvedJavaField annotated, boolean isUserSubstitution) {
+    public SubstitutionField(ResolvedJavaField original, ResolvedJavaField annotated, boolean userSubstitution) {
         this.original = original;
         this.annotated = annotated;
-        this.isUserSubstitution = isUserSubstitution;
+        this.userSubstitution = userSubstitution;
     }
 
     public boolean isUserSubstitution() {
-        return isUserSubstitution;
+        return userSubstitution;
     }
 
     public ResolvedJavaField getOriginal() {
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java
index 269ac462ce1a..0ac1d3cb31ee 100644
--- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java
+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionMethod.java
@@ -24,11 +24,6 @@
  */
 package com.oracle.svm.hosted.substitute;
 
-import static com.oracle.svm.core.util.VMError.intentionallyUnimplemented;
-import static com.oracle.svm.core.util.VMError.shouldNotReachHereAtRuntime;
-
-import java.lang.reflect.Type;
-
 import com.oracle.graal.pointsto.infrastructure.GraphProvider;
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
 import com.oracle.graal.pointsto.meta.HostedProviders;
@@ -36,7 +31,6 @@
 import com.oracle.svm.hosted.annotation.AnnotationWrapper;
 import com.oracle.svm.util.AnnotatedWrapper;
 import com.oracle.svm.util.OriginalMethodProvider;
-
 import jdk.graal.compiler.debug.DebugContext;
 import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.vm.ci.meta.Constant;
@@ -53,6 +47,11 @@
 import jdk.vm.ci.meta.annotation.Annotated;
 import jdk.vm.ci.meta.annotation.AnnotationsInfo;
 
+import java.lang.reflect.Type;
+
+import static com.oracle.svm.core.util.VMError.intentionallyUnimplemented;
+import static com.oracle.svm.core.util.VMError.shouldNotReachHereAtRuntime;
+
 public class SubstitutionMethod implements ResolvedJavaMethod, GraphProvider, OriginalMethodProvider, AnnotationWrapper, AnnotatedWrapper {
 
     private final ResolvedJavaMethod original;
@@ -62,15 +61,16 @@ public class SubstitutionMethod implements ResolvedJavaMethod, GraphProvider, Or
 
     /**
      * This field is used in the {@link com.oracle.svm.hosted.SubstitutionReportFeature} class to
-     * determine {@link SubstitutionMethod} objects which correspond to annotated substitutions.
+     * determine {@link SubstitutionMethod} objects are user-defined substitutions (from the
+     * classpath).
      */
-    private final boolean isUserSubstitution;
+    private final boolean userSubstitution;
 
-    public SubstitutionMethod(ResolvedJavaMethod original, ResolvedJavaMethod annotated, boolean inClassSubstitution, boolean isUserSubstitution) {
+    public SubstitutionMethod(ResolvedJavaMethod original, ResolvedJavaMethod annotated, boolean inClassSubstitution, boolean userSubstitution) {
         this.original = original;
         this.annotated = annotated;
         this.inClassSubstitution = inClassSubstitution;
-        this.isUserSubstitution = isUserSubstitution;
+        this.userSubstitution = userSubstitution;
 
         LocalVariableTable newLocalVariableTable = null;
         if (annotated.getLocalVariableTable() != null) {
@@ -92,7 +92,7 @@ public SubstitutionMethod(ResolvedJavaMethod original, ResolvedJavaMethod annota
     }
 
     public boolean isUserSubstitution() {
-        return isUserSubstitution;
+        return userSubstitution;
     }
 
     public ResolvedJavaMethod getOriginal() {
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionType.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionType.java
index 072ed88ad710..ccdf20bbb43f 100644
--- a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionType.java
+++ b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionType.java
@@ -58,21 +58,22 @@ public class SubstitutionType implements ResolvedJavaType, OriginalClassProvider
 
     /**
      * This field is used in the {@link com.oracle.svm.hosted.SubstitutionReportFeature} class to
-     * determine {@link SubstitutionType} objects which correspond to type.
+     * determine {@link SubstitutionType} objects are user-defined substitutions (from the
+     * classpath).
      */
-    private final boolean isUserSubstitution;
+    private final boolean userSubstitution;
 
     private final ResolvedJavaField[][] instanceFields;
 
-    public SubstitutionType(ResolvedJavaType original, ResolvedJavaType annotated, boolean isUserSubstitution) {
+    public SubstitutionType(ResolvedJavaType original, ResolvedJavaType annotated, boolean userSubstitution) {
         this.annotated = annotated;
         this.original = original;
-        this.isUserSubstitution = isUserSubstitution;
+        this.userSubstitution = userSubstitution;
         this.instanceFields = new ResolvedJavaField[][]{annotated.getInstanceFields(false), annotated.getInstanceFields(true)};
     }
 
     public boolean isUserSubstitution() {
-        return isUserSubstitution;
+        return userSubstitution;
     }
 
     public ResolvedJavaType getOriginal() {
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/DebuggerFeature.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/DebuggerFeature.java
index 45de02525ba2..74f64609303c 100644
--- a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/DebuggerFeature.java
+++ b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/DebuggerFeature.java
@@ -320,7 +320,7 @@ public void duringAnalysis(DuringAnalysisAccess access) {
 
             if (method.isReachable() && !methodsProcessedDuringAnalysis.contains(method)) {
                 methodsProcessedDuringAnalysis.add(method);
-                if (method.wrapped instanceof SubstitutionMethod subMethod && subMethod.isUserSubstitution()) {
+                if (method.wrapped instanceof SubstitutionMethod subMethod) {
                     if (subMethod.getOriginal().isNative()) {
                         accessImpl.registerAsRoot(method, isInvokeSpecial(method), "compiled entry point of substitution needed for interpreter");
                         continue;
@@ -472,7 +472,7 @@ public void beforeCompilation(BeforeCompilationAccess access) {
                 boolean needsMethodBody = InterpreterFeature.executableByInterpreter(aMethod) && InterpreterFeature.callableByInterpreter(hMethod, hMetaAccess);
                 // Test if the methods needs to be compiled for execution in the interpreter:
                 if (aMethod.getAnalyzedGraph() != null && //
-                                (aMethod.wrapped instanceof SubstitutionMethod subMethod && subMethod.isUserSubstitution() ||
+                                (aMethod.wrapped instanceof SubstitutionMethod ||
                                                 invocationPlugins.lookupInvocation(aMethod, invocationLookupOptions) != null)) {
                     // The method is substituted, or an invocation plugin is registered
                     SubstrateCompilationDirectives.singleton().registerForcedCompilation(hMethod);