diff --git a/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/CheckForObsoletePreserveAttributeStep.cs b/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/CheckForObsoletePreserveAttributeStep.cs
index fb80578ef9a..9099132cf6c 100644
--- a/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/CheckForObsoletePreserveAttributeStep.cs
+++ b/src/Xamarin.Android.Build.Tasks/Linker/MonoDroid.Tuner/CheckForObsoletePreserveAttributeStep.cs
@@ -9,7 +9,7 @@ namespace MonoDroid.Tuner;
 
 /// <summary>
 /// Post-trimming step that warns when an assembly references the obsolete
-/// Android.Runtime.PreserveAttribute. Runs as part of PostTrimmingPipeline
+/// Android.Runtime.PreserveAttribute. Runs as part of AssemblyModifierPipeline
 /// so the assemblies are already loaded by Mono.Cecil and the check is free.
 /// </summary>
 class CheckForObsoletePreserveAttributeStep : IAssemblyModifierPipelineStep
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets
index b4ecd0f5fe6..ce892d97165 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets
@@ -126,6 +126,23 @@ This file contains the NativeAOT-specific MSBuild logic for .NET for Android.
     <SetNdkPathForIlc NdkBinDirectory="$(_NdkBinDir)" />
   </Target>
 
+  <!--
+    The standard NativeAOT targets (_ComputeManagedAssemblyForILLink) replace @(ManagedAssemblyToLink)
+    with framework-only assemblies, removing the user assembly. This is fine in the standard NativeAOT
+    flow where RunILLink=false (ILC does its own trimming). But Android re-enables ILLink (RunILLink=true
+    above), so the user assembly must be in @(ManagedAssemblyToLink) for two reasons:
+      1. ILLink needs it in AssemblyPaths to process it (not just as a root name)
+      2. _RunILLink's Inputs include @(ManagedAssemblyToLink), so changes to the user assembly
+         correctly trigger ILLink to re-run on incremental builds
+  -->
+  <Target Name="_AndroidFixManagedAssemblyToLinkForILLink"
+      AfterTargets="_ComputeManagedAssemblyForILLink"
+      Condition="'$(NativeCompilationDuringPublish)' == 'true'">
+    <ItemGroup>
+      <ManagedAssemblyToLink Include="@(IntermediateAssembly)" />
+    </ItemGroup>
+  </Target>
+
   <Target Name="_AndroidComputeIlcCompileInputs">
     <PropertyGroup>
       <!-- Turn trimmer warnings back to original value -->
@@ -150,6 +167,8 @@ This file contains the NativeAOT-specific MSBuild logic for .NET for Android.
       <IlcCompileInput Remove="@(IlcCompileInput)" />
       <IlcCompileInput Include="$(IntermediateLinkDir)$(TargetName)$(TargetExt)" />
       <_AndroidILLinkAssemblies Include="@(ManagedAssemblyToLink->'$(IntermediateLinkDir)%(Filename)%(Extension)')" Condition="Exists('$(IntermediateLinkDir)%(Filename)%(Extension)')" />
+      <!-- Exclude the user assembly: it's already in IlcCompileInput above and must not also appear in IlcReference -->
+      <_AndroidILLinkAssemblies Remove="$(IntermediateLinkDir)$(TargetName)$(TargetExt)" />
       <IlcReference Remove="@(IlcReference)" />
       <IlcReference Include="@(PrivateSdkAssemblies)" />
       <IlcReference Include="@(_AndroidILLinkAssemblies)" />
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.LlvmIr.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.LlvmIr.targets
index 9b8870a8295..8de11e61c0c 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.LlvmIr.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.LlvmIr.targets
@@ -7,7 +7,6 @@
   <UsingTask TaskName="Xamarin.Android.Tasks.GetMonoPlatformJar" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
   <UsingTask TaskName="Xamarin.Android.Tasks.RemoveRegisterAttribute" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateProguardConfiguration" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
-  <UsingTask TaskName="Xamarin.Android.Tasks.PostTrimmingPipeline" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
 
   <PropertyGroup>
     <_RemoveRegisterFlag>$(MonoAndroidIntermediateAssemblyDir)shrunk\shrunk.flag</_RemoveRegisterFlag>
@@ -232,25 +231,6 @@
     <Touch Files="$(_AndroidLinkFlag)" AlwaysCreate="true" />
   </Target>
 
-  <!--
-    Post-trimming assembly modifications: strips embedded Android resources and
-    (optionally) injects GC.KeepAlive() calls, in a single pass over assemblies.
-    Runs in the inner build after ILLink but before ReadyToRun/crossgen2 compilation,
-    so R2R images are generated from the already-modified assemblies.
-  -->
-  <Target Name="_PostTrimmingPipeline"
-      AfterTargets="ILLink"
-      Condition=" '$(PublishTrimmed)' == 'true' ">
-    <ItemGroup>
-      <_PostTrimmingAssembly Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
-    </ItemGroup>
-    <PostTrimmingPipeline
-        Assemblies="@(_PostTrimmingAssembly)"
-        AddKeepAlives="$(AndroidAddKeepAlives)"
-        AndroidLinkResources="$(AndroidLinkResources)"
-        Deterministic="$(Deterministic)" />
-  </Target>
-
   <!-- Inject _TypeMapKind into the property cache -->
   <Target Name="_SetTypemapProperties"
       BeforeTargets="_CreatePropertiesCache">
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/AssemblyModifierPipeline.cs b/src/Xamarin.Android.Build.Tasks/Tasks/AssemblyModifierPipeline.cs
index 08a558de918..14fc35fce0d 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/AssemblyModifierPipeline.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/AssemblyModifierPipeline.cs
@@ -18,14 +18,24 @@
 namespace Xamarin.Android.Tasks;
 
 /// <summary>
-/// This task runs additional "linker steps" that are not part of ILLink. These steps
-/// are run *after* the linker has run. Additionally, this task is run by
-/// LinkAssembliesNoShrink to modify assemblies when ILLink is not used.
+/// This task runs assembly modification steps that are not part of ILLink.
+///
+/// For trimmed builds, this runs after ILLink and includes post-trimming steps
+/// (CheckForObsoletePreserveAttribute, StripEmbeddedLibraries, AddKeepAlives,
+/// RemoveResourceDesigner) followed by common steps (FindJavaObjects,
+/// SaveChangedAssembly, FindTypeMapObjects).
+///
+/// For non-trimmed builds, LinkAssembliesNoShrink extends this task and overrides
+/// BuildAssemblyModificationSteps to add non-trimmed-specific steps instead.
 /// </summary>
 public class AssemblyModifierPipeline : AndroidTask
 {
 	public override string TaskPrefix => "AMP";
 
+	public bool AddKeepAlives { get; set; }
+
+	public bool AndroidLinkResources { get; set; }
+
 	public string ApplicationJavaClass { get; set; } = "";
 
 	public string CodeGenerationTarget { get; set; } = "";
@@ -111,7 +121,6 @@ public override bool RunTask ()
 					}
 				}
 
-				// Set up the FixAbstractMethodsStep and AddKeepAlivesStep
 				var context = new MSBuildLinkContext (resolver, Log);
 				pipeline = new AssemblyPipeline (resolver);
 
@@ -130,6 +139,8 @@ public override bool RunTask ()
 
 	protected virtual void BuildPipeline (AssemblyPipeline pipeline, MSBuildLinkContext context)
 	{
+		BuildAssemblyModificationSteps (pipeline, context);
+
 		// FindJavaObjectsStep
 		var findJavaObjectsStep = new FindJavaObjectsStep (Log) {
 			ApplicationJavaClass = ApplicationJavaClass,
@@ -158,6 +169,53 @@ protected virtual void BuildPipeline (AssemblyPipeline pipeline, MSBuildLinkCont
 		pipeline.Steps.Add (findTypeMapObjectsStep);
 	}
 
+	/// <summary>
+	/// Builds the assembly modification steps that run before FindJavaObjects/Save/FindTypeMapObjects.
+	/// For trimmed builds (default), this adds post-trimming steps.
+	/// LinkAssembliesNoShrink overrides this for non-trimmed builds.
+	/// </summary>
+	protected virtual void BuildAssemblyModificationSteps (AssemblyPipeline pipeline, MSBuildLinkContext context)
+	{
+		// CheckForObsoletePreserveAttributeStep
+		pipeline.Steps.Add (new CheckForObsoletePreserveAttributeStep (Log));
+
+		// StripEmbeddedLibrariesStep
+		pipeline.Steps.Add (new StripEmbeddedLibrariesStep (Log));
+
+		// PostTrimmingAddKeepAlivesStep
+		if (AddKeepAlives) {
+			var cache = new TypeDefinitionCache ();
+
+			// Memoize the corlib resolution so the attempt (and any error logging) happens at most once,
+			// regardless of how many assemblies/methods need KeepAlive injection.
+			AssemblyDefinition? corlibAssembly = null;
+			bool corlibResolutionAttempted = false;
+
+			pipeline.Steps.Add (new PostTrimmingAddKeepAlivesStep (cache,
+				() => {
+					if (!corlibResolutionAttempted) {
+						corlibResolutionAttempted = true;
+						try {
+							corlibAssembly = pipeline.Resolver.Resolve (AssemblyNameReference.Parse ("System.Private.CoreLib"));
+						} catch (AssemblyResolutionException ex) {
+							Log.LogErrorFromException (ex, showStackTrace: false);
+						}
+					}
+					return corlibAssembly;
+				},
+				(msg) => Log.LogDebugMessage (msg)));
+		}
+
+		// RemoveResourceDesignerStep
+		if (AndroidLinkResources) {
+			var allAssemblies = new List<AssemblyDefinition> (SourceFiles.Length);
+			foreach (var item in SourceFiles) {
+				allAssemblies.Add (pipeline.Resolver.GetAssembly (item.ItemSpec));
+			}
+			pipeline.Steps.Add (new RemoveResourceDesignerStep (allAssemblies, (msg) => Log.LogDebugMessage (msg)));
+		}
+	}
+
 	void RunPipeline (AssemblyPipeline pipeline, ITaskItem source, ITaskItem destination)
 	{
 		var assembly = pipeline.Resolver.GetAssembly (source.ItemSpec);
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/LinkAssembliesNoShrink.cs b/src/Xamarin.Android.Build.Tasks/Tasks/LinkAssembliesNoShrink.cs
index 9dc7e99e635..70deda9c8a5 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/LinkAssembliesNoShrink.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/LinkAssembliesNoShrink.cs
@@ -14,11 +14,9 @@ public class LinkAssembliesNoShrink : AssemblyModifierPipeline
 	{
 		public override string TaskPrefix => "LNS";
 
-		public bool AddKeepAlives { get; set; }
-
 		public bool UseDesignerAssembly { get; set; }
 
-		protected override void BuildPipeline (AssemblyPipeline pipeline, MSBuildLinkContext context)
+		protected override void BuildAssemblyModificationSteps (AssemblyPipeline pipeline, MSBuildLinkContext context)
 		{
 			// FixAbstractMethodsStep
 			var fixAbstractMethodsStep = new FixAbstractMethodsStep ();
@@ -38,9 +36,6 @@ protected override void BuildPipeline (AssemblyPipeline pipeline, MSBuildLinkCon
 				addKeepAliveStep.Initialize (context);
 				pipeline.Steps.Add (addKeepAliveStep);
 			}
-
-			// Ensure the <AssemblyModifierPipeline> task's steps are added
-			base.BuildPipeline (pipeline, context);
 		}
 	}
 }
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/PostTrimmingPipeline.cs b/src/Xamarin.Android.Build.Tasks/Tasks/PostTrimmingPipeline.cs
deleted file mode 100644
index 56fb01b6485..00000000000
--- a/src/Xamarin.Android.Build.Tasks/Tasks/PostTrimmingPipeline.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-#nullable enable
-
-using System.Collections.Generic;
-using System.IO;
-using Java.Interop.Tools.Cecil;
-using Microsoft.Android.Build.Tasks;
-using Microsoft.Build.Framework;
-using Mono.Cecil;
-using MonoDroid.Tuner;
-
-namespace Xamarin.Android.Tasks;
-
-/// <summary>
-/// An MSBuild task that runs post-trimming assembly modifications in a single pass.
-///
-/// This opens each assembly once (via DirectoryAssemblyResolver with ReadWrite) and
-/// runs all registered steps on it, then writes modified assemblies in-place. Currently
-/// runs CheckForObsoletePreserveAttributeStep, StripEmbeddedLibrariesStep and
-/// (optionally) AddKeepAlivesStep.
-///
-/// Runs in the inner build after ILLink but before ReadyToRun/crossgen2 compilation,
-/// so that R2R images are generated from the already-modified assemblies.
-/// </summary>
-public class PostTrimmingPipeline : AndroidTask
-{
-	public override string TaskPrefix => "PTP";
-
-	[Required]
-	public ITaskItem [] Assemblies { get; set; } = [];
-
-	public bool AddKeepAlives { get; set; }
-
-	public bool AndroidLinkResources { get; set; }
-
-	public bool Deterministic { get; set; }
-
-	public override bool RunTask ()
-	{
-		using var resolver = new DirectoryAssemblyResolver (
-			this.CreateTaskLogger (), loadDebugSymbols: true,
-			loadReaderParameters: new ReaderParameters { ReadWrite = true });
-		var cache = new TypeDefinitionCache ();
-
-		foreach (var assembly in Assemblies) {
-			var dir = Path.GetFullPath (Path.GetDirectoryName (assembly.ItemSpec) ?? "");
-			if (!resolver.SearchDirectories.Contains (dir)) {
-				resolver.SearchDirectories.Add (dir);
-			}
-		}
-
-		var steps = new List<IAssemblyModifierPipelineStep> ();
-		steps.Add (new CheckForObsoletePreserveAttributeStep (Log));
-		steps.Add (new StripEmbeddedLibrariesStep (Log));
-		if (AddKeepAlives) {
-			// Memoize the corlib resolution so the attempt (and any error logging) happens at most once,
-			// regardless of how many assemblies/methods need KeepAlive injection.
-			AssemblyDefinition? corlibAssembly = null;
-			bool corlibResolutionAttempted = false;
-			steps.Add (new PostTrimmingAddKeepAlivesStep (cache,
-				() => {
-					if (!corlibResolutionAttempted) {
-						corlibResolutionAttempted = true;
-						try {
-							corlibAssembly = resolver.Resolve (AssemblyNameReference.Parse ("System.Private.CoreLib"));
-						} catch (AssemblyResolutionException ex) {
-							Log.LogErrorFromException (ex, showStackTrace: false);
-						}
-					}
-					return corlibAssembly;
-				},
-				(msg) => Log.LogDebugMessage (msg)));
-		}
-		if (AndroidLinkResources) {
-			var allAssemblies = new List<AssemblyDefinition> (Assemblies.Length);
-			foreach (var item in Assemblies) {
-				allAssemblies.Add (resolver.GetAssembly (item.ItemSpec));
-			}
-			steps.Add (new RemoveResourceDesignerStep (allAssemblies, (msg) => Log.LogDebugMessage (msg)));
-		}
-
-		foreach (var item in Assemblies) {
-			var assembly = resolver.GetAssembly (item.ItemSpec);
-			var context = new StepContext (item, item);
-			foreach (var step in steps) {
-				step.ProcessAssembly (assembly, context);
-			}
-			if (context.IsAssemblyModified) {
-				Log.LogDebugMessage ($"  Writing modified assembly: {item.ItemSpec}");
-				assembly.Write (new WriterParameters {
-					WriteSymbols = assembly.MainModule.HasSymbols,
-					DeterministicMvid = Deterministic,
-				});
-			}
-		}
-
-		return !Log.HasLoggedErrors;
-	}
-}
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
index b0dcc115436..dc7591d44e9 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
@@ -560,11 +560,9 @@ public void CheckSignApk ([Values] bool useApkSigner, [Values] bool perAbiApk, [
 				item.TextContent = () => proj.StringsXml.Replace ("${PROJECT_NAME}", "Foo");
 				item.Timestamp = null;
 				Assert.IsTrue (b.Build (proj), "Second build failed");
-				if (runtime != AndroidRuntime.NativeAOT) {
-					b.AssertHasNoWarnings ();
-				} else {
-					StringAssertEx.Contains ("2 Warning(s)", b.LastBuildOutput, "NativeAOT should produce two IL3053 warnings");
-				}
+				// Only Strings.xml changed, so assemblies are unchanged and ILLink
+				// correctly skips — no IL3053 warnings are expected for any runtime.
+				b.AssertHasNoWarnings ();
 
 				//Make sure the APKs are signed
 				foreach (var apk in Directory.GetFiles (bin, "*-Signed.apk")) {
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
index a0ed0a47ead..d63b6bfdc4c 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
@@ -44,8 +44,8 @@
     <None Remove="Tests\**" />
     <Compile Include="..\..\bin\Build$(Configuration)\XABuildConfig.cs" />
 
-    <!-- Include only the linker sources required for the build tasks (LinkAssembliesNoShrink and PostTrimmingPipeline) -->
-    <!-- These include: AddKeepAlivesStep, AddKeepAlivesHelper, CheckForObsoletePreserveAttributeStep, StripEmbeddedLibrariesStep, PostTrimmingAddKeepAlivesStep, FixAbstractMethodsStep, FixLegacyResourceDesignerStep -->
+    <!-- Include only the linker sources required for the build tasks (LinkAssembliesNoShrink and AssemblyModifierPipeline) -->
+    <!-- These include: AddKeepAlivesStep, AddKeepAlivesHelper, CheckForObsoletePreserveAttributeStep, StripEmbeddedLibrariesStep, PostTrimmingAddKeepAlivesStep, RemoveResourceDesignerStep, FixAbstractMethodsStep, FixLegacyResourceDesignerStep -->
     <Compile Remove="Linker\**" />
     <Compile Include="Linker\MonoDroid.Tuner\FindTypeMapObjectsStep.cs" />
     <Compile Include="Linker\MonoDroid.Tuner\FindJavaObjectsStep.cs" />
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
index c2527d1954e..6d187855e88 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
@@ -1454,33 +1454,261 @@ because xbuild doesn't support framework reference assemblies.
   </ItemGroup>
 </Target>
 
-<!-- Runs additional steps after ILLink runs (_LinkAssemblies) -->
+<!--
+  Run AssemblyModifierPipeline in the inner (per-RID) build, AFTER ILLink trims assemblies
+  but BEFORE CreateReadyToRunImages/IlcCompile compiles them to native code. This ensures that
+  assembly modifications operate on trimmed IL assemblies before they get R2R/AOT-compiled,
+  so we don't overwrite native code with pure IL.
+
+  This single pipeline handles both post-trimming steps (CheckForObsoletePreserveAttribute,
+  StripEmbeddedLibraries, AddKeepAlives, RemoveResourceDesigner) and common steps
+  (FindJavaObjects, SaveChangedAssembly, FindTypeMapObjects) in one pass.
+
+  Assemblies are located using @(ManagedAssemblyToLink) transformed to $(IntermediateLinkDir)
+  paths (with an existence check). This is the same mechanism _AndroidComputeIlcCompileInputs
+  uses to find trimmed assemblies for ILC, and works uniformly for all runtimes (CoreCLR,
+  MonoVM, NativeAOT). The transform preserves all metadata from the source items, including
+  NuGetPackageId which is used for framework/user assembly classification.
+
+  The condition '$(_ComputeFilesToPublishForRuntimeIdentifiers)' == 'true' ensures this only runs
+  in the inner build. In the outer build the target is a no-op (the condition is false), so existing
+  dependency chain references in _PrepareAssembliesDependsOnTargets and _PrepareBuildApkDependsOnTargets
+  are harmlessly satisfied.
+
+  For non-trimmed builds, _LinkAssembliesNoShrink handles assembly modifications instead.
+
+  Incrementality: Input is $(_LinkSemaphore) (touched by ILLink when it runs). When ILLink is
+  skipped on a no-change rebuild, the semaphore is unchanged, so this target is also skipped.
+  This is important because SaveChangedAssemblyStep always updates assembly timestamps (even
+  when unchanged), which would cascade through _GenerateJavaStubs -> _CompileJava ->
+  _CompileToDalvik -> _BuildApkEmbed -> _Sign, breaking incremental builds.
+
+  For all runtimes (MonoVM, CoreCLR, NativeAOT), the user assembly is in @(ManagedAssemblyToLink)
+  which is part of _RunILLink's Inputs, so $(_LinkSemaphore) correctly updates whenever the user
+  assembly changes. For NativeAOT specifically, the standard SDK targets strip the user assembly
+  from @(ManagedAssemblyToLink), but _AndroidFixManagedAssemblyToLinkForILLink in
+  Microsoft.Android.Sdk.NativeAOT.targets adds it back.
+-->
 <Target Name="_AfterILLinkAdditionalSteps"
-    DependsOnTargets="_LinkAssembliesNoShrinkInputs"
-    Condition="'$(PublishTrimmed)' == 'true'"
-    Inputs="$(_AndroidLinkFlag)"
+    AfterTargets="ILLink"
+    Condition=" '$(PublishTrimmed)' == 'true' and '$(_ComputeFilesToPublishForRuntimeIdentifiers)' == 'true' and Exists('$(_LinkSemaphore)') "
+    Inputs="$(_LinkSemaphore)"
     Outputs="$(_AdditionalPostLinkerStepsFlag)">
+
+  <!-- Convert $(RuntimeIdentifier) (e.g. 'android-arm64') to ABI (e.g. 'arm64-v8a') -->
+  <RuntimeIdentifierToAbi RuntimeIdentifier="$(RuntimeIdentifier)">
+    <Output TaskParameter="SupportedAbis" PropertyName="_AfterILLinkAbi" />
+  </RuntimeIdentifierToAbi>
+
+  <!-- Collect trimmed assemblies from $(IntermediateLinkDir) using the same transform that
+       _AndroidComputeIlcCompileInputs uses. RemoveDuplicates deduplicates by ItemSpec only,
+       which is needed because NativeAOT builds can have duplicate @(ManagedAssemblyToLink)
+       entries for the same assembly with different metadata. -->
+  <ItemGroup>
+    <_AfterILLinkAssembliesRaw
+        Include="@(ManagedAssemblyToLink->'$(IntermediateLinkDir)%(Filename)%(Extension)')"
+        Condition=" Exists('$(IntermediateLinkDir)%(Filename)%(Extension)') " />
+  </ItemGroup>
+  <RemoveDuplicates Inputs="@(_AfterILLinkAssembliesRaw)">
+    <Output TaskParameter="Filtered" ItemName="_AfterILLinkAssemblies" />
+  </RemoveDuplicates>
+
+  <!-- The project's own assembly ($(TargetName)$(TargetExt)) should be in
+       @(ManagedAssemblyToLink) for all runtimes (for NativeAOT, _AndroidFixManagedAssemblyToLinkForILLink
+       ensures this). This explicit Include is a safety net in case some code path doesn't include it.
+       Exclude="@(_AfterILLinkAssemblies)" prevents duplicates by ItemSpec (KeepDuplicates compares
+       including metadata, which would miss matches when metadata differs). -->
+  <ItemGroup>
+    <_AfterILLinkAssemblies
+        Include="$(IntermediateLinkDir)$(TargetName)$(TargetExt)"
+        Exclude="@(_AfterILLinkAssemblies)"
+        Condition=" Exists('$(IntermediateLinkDir)$(TargetName)$(TargetExt)') " />
+  </ItemGroup>
+
+  <!-- Set Abi on all items, and ensure the root assembly has HasMonoAndroidReference=true
+       so that IsAndroidAssembly() returns true for it (it may lack TargetFrameworkIdentifier/
+       TargetPlatformIdentifier metadata if it came from the explicit Include above rather
+       than from @(ManagedAssemblyToLink)). This Update is harmless if the root assembly was
+       already in @(ManagedAssemblyToLink) — it will already have this metadata or equivalent. -->
+  <ItemGroup>
+    <_AfterILLinkAssemblies Update="@(_AfterILLinkAssemblies)" Abi="$(_AfterILLinkAbi)" />
+    <_AfterILLinkAssemblies
+        Update="$(IntermediateLinkDir)$(TargetName)$(TargetExt)"
+        HasMonoAndroidReference="true" />
+  </ItemGroup>
+
+  <!-- Classify user vs framework assemblies for FindJavaObjectsStep.
+       FindJavaObjectsStep uses IsUserAssembly to decide whether to scan an assembly for
+       JCW (Java Callable Wrapper) types. Framework assemblies like Mono.Android.dll already
+       have their JCWs pre-built in mono.android.jar — if we mark them as user assemblies,
+       FindJavaObjectsStep generates duplicate JCWs that conflict at Java compilation time.
+
+       We filter by %(Filename) against the 4 known framework assembly names used by
+       MonoAndroidHelper.IsFrameworkAssembly(string): Mono.Android, Mono.Android.Export,
+       Mono.Android.Runtime, Java.Interop. No other framework assemblies matter here because
+       BCL assemblies (System.Runtime, etc.) fail the IsAndroidAssembly check in
+       FindJavaObjectsStep and are never scanned for Java types regardless.
+
+       We deliberately avoid %(NuGetPackageId) because it is not uniformly defined on all
+       @(ManagedAssemblyToLink) items (e.g. _Microsoft.Android.Resource.Designer.dll lacks
+       it, causing MSB4096 on any %(NuGetPackageId) reference). -->
+  <ItemGroup>
+    <_AfterILLinkUserAssemblies Include="@(_AfterILLinkAssemblies)"
+        Condition=" '%(Filename)' != 'Mono.Android' and '%(Filename)' != 'Mono.Android.Export' and '%(Filename)' != 'Mono.Android.Runtime' and '%(Filename)' != 'Java.Interop' " />
+  </ItemGroup>
+
   <AssemblyModifierPipeline
+      AddKeepAlives="$(AndroidAddKeepAlives)"
+      AndroidLinkResources="$(AndroidLinkResources)"
       ApplicationJavaClass="$(AndroidApplicationJavaClass)"
       CodeGenerationTarget="$(_AndroidJcwCodegenTarget)"
       Debug="$(AndroidIncludeDebugSymbols)"
-      DestinationFiles="@(ResolvedAssemblies)"
+      DestinationFiles="@(_AfterILLinkAssemblies)"
       Deterministic="$(Deterministic)"
       EnableMarshalMethods="$(_AndroidUseMarshalMethods)"
       ErrorOnCustomJavaObject="$(AndroidErrorOnCustomJavaObject)"
       PackageNamingPolicy="$(AndroidPackageNamingPolicy)"
       ReadSymbols="$(_AndroidLinkAssembliesReadSymbols)"
-      ResolvedAssemblies="@(_AllResolvedAssemblies)"
-      ResolvedUserAssemblies="@(ResolvedUserAssemblies)"
-      SourceFiles="@(ResolvedAssemblies)"
+      ResolvedAssemblies="@(_AfterILLinkAssemblies)"
+      ResolvedUserAssemblies="@(_AfterILLinkUserAssemblies)"
+      SourceFiles="@(_AfterILLinkAssemblies)"
       TargetName="$(TargetName)">
   </AssemblyModifierPipeline>
 
   <Touch Files="$(_AdditionalPostLinkerStepsFlag)" AlwaysCreate="true" />
+
+  <ItemGroup>
+    <FileWrites Include="@(_AfterILLinkAssemblies->'%(RootDir)%(Directory)%(Filename).jlo.xml')" />
+    <FileWrites Include="@(_AfterILLinkAssemblies->'%(RootDir)%(Directory)%(Filename).typemap.xml')" />
+  </ItemGroup>
+
+  <!-- Clean up temporary item groups -->
+  <ItemGroup>
+    <_AfterILLinkAssembliesRaw Remove="@(_AfterILLinkAssembliesRaw)" />
+    <_AfterILLinkAssemblies Remove="@(_AfterILLinkAssemblies)" />
+    <_AfterILLinkUserAssemblies Remove="@(_AfterILLinkUserAssemblies)" />
+  </ItemGroup>
 </Target>
 
 <!-- _PrepareAssemblies lives in Microsoft.Android.Sdk.AssemblyResolution.targets -->
 
+<!--
+  _CopySidecarXmlToAssemblyPaths
+  ===============================
+  When _AfterILLinkAdditionalSteps runs in the inner build (AfterTargets="ILLink"), it generates
+  sidecar XML files next to the trimmed assemblies in $(IntermediateLinkDir):
+    - .jlo.xml (Java-like objects found by FindJavaObjectsStep)
+    - .typemap.xml (type mappings found by FindTypeMapObjectsStep)
+
+  After ILLink, subsequent inner-build steps (CreateReadyToRunImages, IlcCompile, AOT) may move
+  assemblies to different directories (e.g. R2R/, publish/). The sidecar XML files stay in linked/.
+
+  The outer build's _GenerateJavaStubs and GenerateTypeMappings expect these files next to the
+  assembly paths in @(_ResolvedAssemblies) (which may point to R2R/, publish/, etc.).
+  This target copies sidecar XML files from linked/ to those locations.
+
+  Only runs in the outer build (_ComputeFilesToPublishForRuntimeIdentifiers != 'true') for trimmed builds.
+-->
+<Target Name="_CopySidecarXmlToAssemblyPaths"
+    AfterTargets="_PrepareAssemblies"
+    Condition=" '$(PublishTrimmed)' == 'true' and '$(_ComputeFilesToPublishForRuntimeIdentifiers)' != 'true' ">
+
+  <!-- Separate R2R composite assemblies (e.g. UnnamedProject.r2r.dll) from regular assemblies.
+       R2R composites are produced by CreateReadyToRunImages AFTER ILLink by merging individual
+       assemblies into a single native image. They have no sidecar files in linked/ because
+       AssemblyModifierPipeline runs in the inner build before R2R creates them.
+       We create empty sidecar files for them (zero-length = "not scanned, no JLOs/type mappings"). -->
+  <ItemGroup>
+    <_R2RCompositeAssemblies Include="@(_ResolvedAssemblies)" Condition=" $([System.String]::Copy('%(Filename)').EndsWith('.r2r')) " />
+    <_NonCompositeAssemblies Include="@(_ResolvedAssemblies)" Condition=" !$([System.String]::Copy('%(Filename)').EndsWith('.r2r')) " />
+  </ItemGroup>
+
+  <!-- Compute sidecar file paths for R2R composite assemblies -->
+  <ItemGroup Condition=" '@(_R2RCompositeAssemblies)' != '' ">
+    <_R2RCompositeSidecarFiles Include="@(_R2RCompositeAssemblies->'%(RootDir)%(Directory)%(Filename).jlo.xml')" />
+    <_R2RCompositeSidecarFiles Include="@(_R2RCompositeAssemblies->'%(RootDir)%(Directory)%(Filename).typemap.xml')" />
+  </ItemGroup>
+
+  <!-- Filter to sidecar files that do not yet exist -->
+  <ItemGroup Condition=" '@(_R2RCompositeSidecarFiles)' != '' ">
+    <_MissingR2RCompositeSidecarFiles Include="@(_R2RCompositeSidecarFiles)" Condition=" !Exists('%(Identity)') " />
+  </ItemGroup>
+
+  <!-- Create empty sidecar files only for missing R2R composite assemblies (zero-length = WasScanned=false) -->
+  <Touch
+      Condition=" '@(_MissingR2RCompositeSidecarFiles)' != '' "
+      Files="@(_MissingR2RCompositeSidecarFiles)"
+      AlwaysCreate="true" />
+
+  <!-- Compute the path to the inner build's linked/ directory where sidecar XML files reside.
+       The inner build is dispatched by _ResolveAssemblies with AppendRuntimeIdentifierToOutputPath=true,
+       so its IntermediateOutputPath is always $(OuterIntermediateOutputPath)$(RuntimeIdentifier)/.
+       In the outer build:
+         - Multi-RID (RuntimeIdentifier == ''): use $(IntermediateOutputPath)%(RuntimeIdentifier)/linked/
+         - Single-RID (RuntimeIdentifier != ''): $(IntermediateOutputPath) may or may not already
+           contain the RID. If it does (normal SDK behavior), use $(IntermediateOutputPath)linked/.
+           If it doesn't (e.g. RuntimeIdentifier set after path evaluation), append the RID first. -->
+  <PropertyGroup Condition=" '$(RuntimeIdentifier)' != '' ">
+    <_SidecarLinkedDir Condition=" $(IntermediateOutputPath.Replace('\','/').TrimEnd('/').EndsWith('$(RuntimeIdentifier)')) ">$(IntermediateOutputPath)linked\</_SidecarLinkedDir>
+    <_SidecarLinkedDir Condition=" '$(_SidecarLinkedDir)' == '' ">$(IntermediateOutputPath)$(RuntimeIdentifier)\linked\</_SidecarLinkedDir>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(RuntimeIdentifier)' == '' ">
+    <_SidecarXmlCopySource Include="@(_NonCompositeAssemblies->'$(IntermediateOutputPath)%(RuntimeIdentifier)\linked\%(Filename).jlo.xml')" />
+    <_SidecarXmlCopySource Include="@(_NonCompositeAssemblies->'$(IntermediateOutputPath)%(RuntimeIdentifier)\linked\%(Filename).typemap.xml')" />
+  </ItemGroup>
+  <ItemGroup Condition=" '$(RuntimeIdentifier)' != '' ">
+    <_SidecarXmlCopySource Include="@(_NonCompositeAssemblies->'$(_SidecarLinkedDir)%(Filename).jlo.xml')" />
+    <_SidecarXmlCopySource Include="@(_NonCompositeAssemblies->'$(_SidecarLinkedDir)%(Filename).typemap.xml')" />
+  </ItemGroup>
+
+  <!-- Some assemblies (e.g. _Microsoft.Android.Resource.Designer.dll) end up in linked/ but were
+       NOT processed by AssemblyModifierPipeline (they weren't in @(ManagedAssemblyToLink) at ILLink
+       time). They have no sidecar files in linked/. Create empty (zero-length) sidecar files for
+       them so the Copy below doesn't fail. Zero-length = "not scanned" which is correct.
+
+       The linked/ directory may not exist if the RID changed between builds without a clean
+       (e.g. switching from android-arm64 to android-x64 via RuntimeIdentifier parameter while
+       RuntimeIdentifiers still points to the old RID). In that case the inner build ran for the
+       old RID and never created the new RID's linked/ directory. MakeDir ensures it exists.
+
+       Only touch files that don't already exist to preserve timestamps and avoid breaking
+       incremental builds (Copy SkipUnchangedFiles="true" compares timestamps). -->
+  <MakeDir
+      Directories="@(_SidecarXmlCopySource->'%(RootDir)%(Directory)')"
+      Condition=" '@(_SidecarXmlCopySource)' != '' " />
+  <ItemGroup Condition=" '@(_SidecarXmlCopySource)' != '' ">
+    <_MissingSidecarXmlCopySource Include="@(_SidecarXmlCopySource)" Condition=" !Exists('%(Identity)') " />
+  </ItemGroup>
+  <Touch
+      Files="@(_MissingSidecarXmlCopySource)"
+      AlwaysCreate="true"
+      Condition=" '@(_MissingSidecarXmlCopySource)' != '' " />
+
+  <ItemGroup>
+    <_SidecarXmlCopyDestination Include="@(_NonCompositeAssemblies->'%(RootDir)%(Directory)%(Filename).jlo.xml')" />
+    <_SidecarXmlCopyDestination Include="@(_NonCompositeAssemblies->'%(RootDir)%(Directory)%(Filename).typemap.xml')" />
+  </ItemGroup>
+
+  <Copy
+      SourceFiles="@(_SidecarXmlCopySource)"
+      DestinationFiles="@(_SidecarXmlCopyDestination)"
+      SkipUnchangedFiles="true" />
+
+  <ItemGroup>
+    <FileWrites Include="@(_SidecarXmlCopyDestination)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <_SidecarXmlCopySource Remove="@(_SidecarXmlCopySource)" />
+    <_MissingSidecarXmlCopySource Remove="@(_MissingSidecarXmlCopySource)" />
+    <_SidecarXmlCopyDestination Remove="@(_SidecarXmlCopyDestination)" />
+    <_NonCompositeAssemblies Remove="@(_NonCompositeAssemblies)" />
+    <_R2RCompositeAssemblies Remove="@(_R2RCompositeAssemblies)" />
+    <_R2RCompositeSidecarFiles Remove="@(_R2RCompositeSidecarFiles)" />
+    <_MissingR2RCompositeSidecarFiles Remove="@(_MissingR2RCompositeSidecarFiles)" />
+  </ItemGroup>
+</Target>
+
 <Target Name="_GetGenerateJavaStubsInputs" DependsOnTargets="_GenerateEnvironmentFiles">
   <ItemGroup>
     <_GenerateJavaStubsInputs Include="@(_AndroidMSBuildAllProjects)" />