From b74304429f0b5e07b51d480129acc906a0512133 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 12 Mar 2026 15:20:15 +0100
Subject: [PATCH 01/29] Make RAR as a service use TaskEnvironment. Make
 OutOfProcRarClient thread safe.

---
 .../Node/OutOfProcRarClient.cs                | 192 +++++++++++++-----
 .../Node/OutOfProcRarNodeEndpoint.cs          |  26 ++-
 .../Node/RarNodeExecuteRequest.cs             |  18 +-
 .../Node/RarTaskParameters.cs                 |   7 +-
 4 files changed, 174 insertions(+), 69 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/Node/OutOfProcRarClient.cs b/src/Tasks/AssemblyDependency/Node/OutOfProcRarClient.cs
index 45ce336909e..2780982fcaf 100644
--- a/src/Tasks/AssemblyDependency/Node/OutOfProcRarClient.cs
+++ b/src/Tasks/AssemblyDependency/Node/OutOfProcRarClient.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using Microsoft.Build.BackEnd;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Internal;
@@ -12,32 +13,56 @@ namespace Microsoft.Build.Tasks.AssemblyDependency
     /// <summary>
     /// Implements a client for sending the ResolveAssemblyReference task to an out-of-proc node.
     /// This is intended to be reused for all RAR tasks across a single build.
+    /// It manages a pool of pipe clients to the RAR node, allowing it to be used concurrently from multiple RAR tasks.
     /// </summary>
     internal sealed class OutOfProcRarClient : IDisposable
     {
         // Create a single cached instance for this build.
         internal const string TaskObjectCacheKey = "OutOfProcRarClient";
 
-        private readonly NodePipeClient _pipeClient;
+        private readonly Queue<NodePipeClient> _availablePipeClients = new();
+        private readonly LockType _poolLock = new();
+        private readonly ServerNodeHandshake _handshake;
+        private readonly string _pipeName;
+        private volatile bool _disposed = false;
 
         private OutOfProcRarClient()
         {
-            ServerNodeHandshake handshake = new(HandshakeOptions.None);
-            _pipeClient = new NodePipeClient(NamedPipeUtil.GetRarNodeEndpointPipeName(handshake), handshake);
-
-            NodePacketFactory packetFactory = new();
-            packetFactory.RegisterPacketHandler(NodePacketType.RarNodeBufferedLogEvents, static t => new RarNodeBufferedLogEvents(t), null);
-            packetFactory.RegisterPacketHandler(NodePacketType.RarNodeExecuteResponse, static t => new RarNodeExecuteResponse(t), null);
-            _pipeClient.RegisterPacketFactory(packetFactory);
+            _handshake = new(HandshakeOptions.None);
+            _pipeName = NamedPipeUtil.GetRarNodeEndpointPipeName(_handshake);
         }
 
-        public void Dispose() => _pipeClient.Dispose();
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+                
+            lock (_poolLock)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                _disposed = true;
+                
+                // Dispose all pipe clients in the pool
+                CommunicationsUtilities.Trace($"Disposing RAR client pool with {_availablePipeClients.Count} pipe clients.");
+                while (_availablePipeClients.Count > 0)
+                {
+                    NodePipeClient pipeClient = _availablePipeClients.Dequeue();
+                    pipeClient?.Dispose();
+                }
+            }
+        }
 
         internal static OutOfProcRarClient GetInstance(IBuildEngine10 buildEngine)
         {
-            // We want to reuse the pipe client across all RAR invocations within a build, but release the connection once
-            // the MSBuild node is idle. Using RegisteredTaskObjectLifetime.Build ensures that the RAR client is disposed between
-            // builds, freeing the server to run other requests.
+            // We want to reuse the pipe client pool across all RAR invocations within a build, but release 
+            // all pipe clients once build is complete. Using RegisteredTaskObjectLifetime.Build ensures 
+            // that the RAR client is disposed between builds, freeing all pipe clients.
             OutOfProcRarClient rarClient = (OutOfProcRarClient)buildEngine.GetRegisteredTaskObject(TaskObjectCacheKey, RegisteredTaskObjectLifetime.Build);
 
             if (rarClient == null)
@@ -50,59 +75,130 @@ internal static OutOfProcRarClient GetInstance(IBuildEngine10 buildEngine)
             return rarClient;
         }
 
-        internal bool Execute(ResolveAssemblyReference rarTask)
+        private NodePipeClient AcquireConnection()
+        {      
+            lock (_poolLock)
+            {
+                if (_disposed)
+                {
+                    throw new ObjectDisposedException(nameof(OutOfProcRarClient));
+                }
+                
+                // Try to get an existing pipe client from the pool
+                if (_availablePipeClients.Count > 0)
+                {
+                    return _availablePipeClients.Dequeue();
+                }
+            }
+            
+            // No available pipe client, create a new one outside the lock
+            NodePipeClient newPipeClient = CreateNewConnection();
+            CommunicationsUtilities.Trace("Created new pipe client for RAR pool.");
+            return newPipeClient;
+        }
+        
+        private void ReleaseConnection(NodePipeClient pipeClient)
         {
-            // This should only be true at the start of a build.
-            if (!_pipeClient.IsConnected)
+            lock (_poolLock)
             {
-                // Don't set a timeout since the build manager already blocks until the server is running.
-                if (!_pipeClient.ConnectToServer(0))
+                if (_disposed)
                 {
-                    return false;
+                    // If the client is already disposed, dispose the pipe client instead of returning it to the pool.
+                    CommunicationsUtilities.Trace("RAR client already disposed, disposing pipe client instead of returning to pool.");
+                    pipeClient?.Dispose();
+                    return;
                 }
+                
+                _availablePipeClients.Enqueue(pipeClient);
             }
+        }
+        
+        private NodePipeClient CreateNewConnection()
+        {
+            var pipeClient = new NodePipeClient(_pipeName, _handshake);
+            
+            NodePacketFactory packetFactory = new();
+            packetFactory.RegisterPacketHandler(NodePacketType.RarNodeBufferedLogEvents, static t => new RarNodeBufferedLogEvents(t), null);
+            packetFactory.RegisterPacketHandler(NodePacketType.RarNodeExecuteResponse, static t => new RarNodeExecuteResponse(t), null);
+            pipeClient.RegisterPacketFactory(packetFactory);
+            
+            return pipeClient;
+        }
+
+        internal bool Execute(ResolveAssemblyReference rarTask)
+        {
+            // Acquire a pipe client from the pool
+            NodePipeClient? pipeClient = null;
+            
+            try
+            {
+                // CA2000: Disposal is handled - ReleaseConnection() either returns 
+                // the pipe client to the pool for reuse or disposes it if this client was already disposed.
+                // At the end of the build the entire pool will be disposed, which will dispose all pipe clients.
+#pragma warning disable CA2000
+                pipeClient = AcquireConnection();
+#pragma warning restore CA2000
+                
+                // Connect if not already connected
+                if (!pipeClient.IsConnected)
+                {
+                    // Don't set a timeout since the build manager already blocks until the server is running.
+                    if (!pipeClient.ConnectToServer(0))
+                    {
+                        return false;
+                    }
+                }
 
-            _pipeClient.WritePacket(new RarNodeExecuteRequest(rarTask));
+                pipeClient.WritePacket(new RarNodeExecuteRequest(rarTask));
 
-            INodePacket packet = _pipeClient.ReadPacket();
+                INodePacket packet = pipeClient.ReadPacket();
 
-            while (packet.Type != NodePacketType.RarNodeExecuteResponse)
-            {
-                if (packet.Type == NodePacketType.RarNodeBufferedLogEvents)
+                while (packet.Type != NodePacketType.RarNodeExecuteResponse)
                 {
-                    RarNodeBufferedLogEvents logEvents = (RarNodeBufferedLogEvents)packet;
-                    foreach (LogMessagePacketBase logMessagePacket in logEvents.EventQueue)
+                    if (packet.Type == NodePacketType.RarNodeBufferedLogEvents)
                     {
-                        BuildEventArgs buildEvent = logMessagePacket.NodeBuildEvent?.Value!;
-                        switch (logMessagePacket.EventType)
+                        RarNodeBufferedLogEvents logEvents = (RarNodeBufferedLogEvents)packet;
+                        foreach (LogMessagePacketBase logMessagePacket in logEvents.EventQueue)
                         {
-                            case LoggingEventType.BuildErrorEvent:
-                                rarTask.BuildEngine.LogErrorEvent((BuildErrorEventArgs)buildEvent);
-                                break;
-                            case LoggingEventType.BuildWarningEvent:
-                                rarTask.BuildEngine.LogWarningEvent((BuildWarningEventArgs)buildEvent);
-                                break;
-                            case LoggingEventType.BuildMessageEvent:
-                                rarTask.BuildEngine.LogMessageEvent((BuildMessageEventArgs)buildEvent);
-                                break;
-                            default:
-                                ErrorUtilities.ThrowInternalError($"Received unexpected log event type {logMessagePacket.Type}");
-                                break;
+                            BuildEventArgs buildEvent = logMessagePacket.NodeBuildEvent?.Value!;
+                            switch (logMessagePacket.EventType)
+                            {
+                                case LoggingEventType.BuildErrorEvent:
+                                    rarTask.BuildEngine.LogErrorEvent((BuildErrorEventArgs)buildEvent);
+                                    break;
+                                case LoggingEventType.BuildWarningEvent:
+                                    rarTask.BuildEngine.LogWarningEvent((BuildWarningEventArgs)buildEvent);
+                                    break;
+                                case LoggingEventType.BuildMessageEvent:
+                                    rarTask.BuildEngine.LogMessageEvent((BuildMessageEventArgs)buildEvent);
+                                    break;
+                                default:
+                                    ErrorUtilities.ThrowInternalError($"Received unexpected log event type {logMessagePacket.Type}");
+                                    break;
+                            }
                         }
                     }
+                    else
+                    {
+                        ErrorUtilities.ThrowInternalError($"Received unexpected packet type {packet.Type}");
+                    }
+
+                    packet = pipeClient.ReadPacket();
                 }
-                else
+
+                RarNodeExecuteResponse response = (RarNodeExecuteResponse)packet;
+                response.SetTaskOutputs(rarTask);
+
+                return response.Success;
+            }
+            finally
+            {
+                // Return the pipe client to the pool
+                if (pipeClient != null)
                 {
-                    ErrorUtilities.ThrowInternalError($"Received unexpected packet type {packet.Type}");
+                    ReleaseConnection(pipeClient);
                 }
-
-                packet = _pipeClient.ReadPacket();
             }
-
-            RarNodeExecuteResponse response = (RarNodeExecuteResponse)packet;
-            response.SetTaskOutputs(rarTask);
-
-            return response.Success;
         }
     }
 }
diff --git a/src/Tasks/AssemblyDependency/Node/OutOfProcRarNodeEndpoint.cs b/src/Tasks/AssemblyDependency/Node/OutOfProcRarNodeEndpoint.cs
index e241e95fc29..b2134622e76 100644
--- a/src/Tasks/AssemblyDependency/Node/OutOfProcRarNodeEndpoint.cs
+++ b/src/Tasks/AssemblyDependency/Node/OutOfProcRarNodeEndpoint.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Build.BackEnd;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Internal;
 using Microsoft.Build.Shared;
 
@@ -96,15 +97,22 @@ private async Task RunInternalAsync(CancellationToken cancellationToken)
 
                             RarNodeExecuteRequest request = (RarNodeExecuteRequest)packet;
                             ResolveAssemblyReference rarTask = new();
-                            request.SetTaskInputs(rarTask, _buildEngine);
-
-                            bool success = rarTask.Execute();
-
-                            // Send any remaining log events before returning the final result packet.
-                            await _buildEngine.FlushEventsAsync(cancellationToken).ConfigureAwait(false);
-                            await _pipeServer.WritePacketAsync(new RarNodeExecuteResponse(rarTask, success), cancellationToken).ConfigureAwait(false);
-
-                            CommunicationsUtilities.Trace("({0}) Completed RAR request.", _endpointId);
+                            
+                            // TODO: This needs to be updated when configuration support is added to pass client-specific state
+                            // For now, using the environment variables from the RAR node process.
+                            using (var environmentDriver = new MultiThreadedTaskEnvironmentDriver(request.ProjectDirectory))
+                            {
+                                rarTask.TaskEnvironment = new TaskEnvironment(environmentDriver);
+                                request.SetTaskInputs(rarTask, _buildEngine);
+
+                                bool success = rarTask.Execute();
+
+                                // Send any remaining log events before returning the final result packet.
+                                await _buildEngine.FlushEventsAsync(cancellationToken).ConfigureAwait(false);
+                                await _pipeServer.WritePacketAsync(new RarNodeExecuteResponse(rarTask, success), cancellationToken).ConfigureAwait(false);
+
+                                CommunicationsUtilities.Trace("({0}) Completed RAR request.", _endpointId);
+                            }
                             break;
                         case NodePacketType.NodeShutdown:
                             // Although the client has already disconnected, it is still necessary to Disconnect() so the
diff --git a/src/Tasks/AssemblyDependency/Node/RarNodeExecuteRequest.cs b/src/Tasks/AssemblyDependency/Node/RarNodeExecuteRequest.cs
index f5527c509d4..8a0cb4706b7 100644
--- a/src/Tasks/AssemblyDependency/Node/RarNodeExecuteRequest.cs
+++ b/src/Tasks/AssemblyDependency/Node/RarNodeExecuteRequest.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using Microsoft.Build.BackEnd;
 using Microsoft.Build.Framework;
 using ParameterType = Microsoft.Build.Tasks.AssemblyDependency.RarTaskParameters.ParameterType;
@@ -19,24 +18,18 @@ internal sealed class RarNodeExecuteRequest : INodePacket
         private int _lineNumberOfTaskNode;
         private int _columnNumberOfTaskNode;
         private string? _projectFileOfTaskNode;
+        private string _projectDirectory = null!;
         private MessageImportance _minimumMessageImportance;
         private bool _isTaskInputLoggingEnabled;
 
         internal RarNodeExecuteRequest(ResolveAssemblyReference rar)
         {
-            // The RAR node may have a different working directory than the target, so convert potential relative paths to absolute.
-            if (rar.AppConfigFile != null)
-            {
-                rar.AppConfigFile = Path.GetFullPath(rar.AppConfigFile);
-            }
-
-            if (rar.StateFile != null)
-            {
-                rar.StateFile = Path.GetFullPath(rar.StateFile);
-            }
 
             _taskInputs = RarTaskParameters.Get(ParameterType.Input, rar);
 
+            // Capture the project directory from TaskEnvironment
+            _projectDirectory = rar.TaskEnvironment.ProjectDirectory.Value;
+
             // Ensure log messages are identical to those that would be produced on the client.
             _lineNumberOfTaskNode = rar.BuildEngine.LineNumberOfTaskNode;
             _columnNumberOfTaskNode = rar.BuildEngine.ColumnNumberOfTaskNode;
@@ -49,6 +42,8 @@ internal RarNodeExecuteRequest(ResolveAssemblyReference rar)
 
         internal RarNodeExecuteRequest(ITranslator translator) => Translate(translator);
 
+        public string ProjectDirectory => _projectDirectory;
+
         public NodePacketType Type => NodePacketType.RarNodeExecuteRequest;
 
         public void Translate(ITranslator translator)
@@ -60,6 +55,7 @@ public void Translate(ITranslator translator)
             translator.Translate(ref _lineNumberOfTaskNode);
             translator.Translate(ref _columnNumberOfTaskNode);
             translator.Translate(ref _projectFileOfTaskNode);
+            translator.Translate(ref _projectDirectory);
             translator.TranslateEnum(ref _minimumMessageImportance, (int)_minimumMessageImportance);
             translator.Translate(ref _isTaskInputLoggingEnabled);
         }
diff --git a/src/Tasks/AssemblyDependency/Node/RarTaskParameters.cs b/src/Tasks/AssemblyDependency/Node/RarTaskParameters.cs
index 54cf77a6430..b3f8b94e14c 100644
--- a/src/Tasks/AssemblyDependency/Node/RarTaskParameters.cs
+++ b/src/Tasks/AssemblyDependency/Node/RarTaskParameters.cs
@@ -162,7 +162,12 @@ internal ReflectedProperties()
                     }
                     else
                     {
-                        inputs.Add(reflectedProperty);
+                        // Exclude TaskEnvironment since it is not a serializable parameter type for cross-process communication. 
+                        // It should be set to each task instance after deserialization.
+                        if (!string.Equals(property.Name, nameof(ResolveAssemblyReference.TaskEnvironment), StringComparison.Ordinal))
+                        {
+                            inputs.Add(reflectedProperty);
+                        }
                     }
                 }
 

From f5caaff01e8811f66a3b1a5fd326f4146e222895 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 12 Mar 2026 15:25:28 +0100
Subject: [PATCH 02/29] Absolutize RAR task inputs. ReferenceTable should use
 the task environment.

---
 src/Framework/ChangeWaves.cs                  |   3 +-
 src/Tasks/AssemblyDependency/Reference.cs     |  28 +++
 .../AssemblyDependency/ReferenceTable.cs      |  23 ++-
 .../ResolveAssemblyReference.cs               | 175 ++++++++++++------
 src/Tasks/RedistList.cs                       |  31 +++-
 src/Tasks/StateFileBase.cs                    |  62 +++++++
 src/Tasks/SystemState.cs                      |  29 ++-
 7 files changed, 276 insertions(+), 75 deletions(-)

diff --git a/src/Framework/ChangeWaves.cs b/src/Framework/ChangeWaves.cs
index d40cd86c8f3..e759dcafbcd 100644
--- a/src/Framework/ChangeWaves.cs
+++ b/src/Framework/ChangeWaves.cs
@@ -33,7 +33,8 @@ internal static class ChangeWaves
         internal static readonly Version Wave18_3 = new Version(18, 3);
         internal static readonly Version Wave18_4 = new Version(18, 4);
         internal static readonly Version Wave18_5 = new Version(18, 5);
-        internal static readonly Version[] AllWaves = [Wave17_10, Wave17_12, Wave17_14, Wave18_3, Wave18_4, Wave18_5];
+        internal static readonly Version Wave18_6 = new Version(18, 6);
+        internal static readonly Version[] AllWaves = [Wave17_10, Wave17_12, Wave17_14, Wave18_3, Wave18_4, Wave18_5, Wave18_6];
 
         /// <summary>
         /// Special value indicating that all features behind all Change Waves should be enabled.
diff --git a/src/Tasks/AssemblyDependency/Reference.cs b/src/Tasks/AssemblyDependency/Reference.cs
index 8322b4e1897..20aa8c4c8c5 100644
--- a/src/Tasks/AssemblyDependency/Reference.cs
+++ b/src/Tasks/AssemblyDependency/Reference.cs
@@ -937,6 +937,34 @@ internal static bool IsFrameworkFile(string fullPath, string[] frameworkPaths)
             return false;
         }
 
+        /// <summary>
+        /// Determine whether the given assembly is an FX assembly.
+        /// </summary>
+        /// <param name="fullPath">The full path to the assembly.</param>
+        /// <param name="frameworkPaths">The path to the frameworks.</param>
+        /// <returns>True if this is a frameworks assembly.</returns>
+        internal static bool IsFrameworkFile(string fullPath, AbsolutePath[] frameworkPaths)
+        {
+            if (frameworkPaths != null)
+            {
+                foreach (var frameworkPath in frameworkPaths)
+                {
+                    if
+                    (
+                        frameworkPath.Value is not null &&
+                        String.Compare(
+                            frameworkPath.Value, 0,
+                            fullPath, 0,
+                            frameworkPath.Value.Length,
+                            StringComparison.OrdinalIgnoreCase) == 0)
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
         /// <summary>
         /// Figure out the what the CopyLocal state of given assembly should be.
         /// </summary>
diff --git a/src/Tasks/AssemblyDependency/ReferenceTable.cs b/src/Tasks/AssemblyDependency/ReferenceTable.cs
index 37de75c0dec..8f7b41c6385 100644
--- a/src/Tasks/AssemblyDependency/ReferenceTable.cs
+++ b/src/Tasks/AssemblyDependency/ReferenceTable.cs
@@ -111,6 +111,11 @@ internal sealed class ReferenceTable
         /// </summary>
         private readonly ReadMachineTypeFromPEHeader _readMachineTypeFromPEHeader;
 
+        /// <summary>
+        /// TaskEnvironment for thread-safe access to environment variables and path resolution.
+        /// </summary>
+        private readonly TaskEnvironment _taskEnvironment;
+
         /// <summary>
         /// Is the file a winMD file
         /// </summary>
@@ -225,6 +230,7 @@ internal sealed class ReferenceTable
         /// <param name="warnOrErrorOnTargetArchitectureMismatch"></param>
         /// <param name="ignoreFrameworkAttributeVersionMismatch"></param>
         /// <param name="nonCultureResourceDirectories"></param>
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access and path resolution.</param>
 #else
         /// <summary>
         /// Construct.
@@ -239,7 +245,7 @@ internal sealed class ReferenceTable
         /// <param name="relatedFileExtensions"></param>
         /// <param name="candidateAssemblyFiles">List of literal assembly file names to be considered when SearchPaths has {CandidateAssemblyFiles}.</param>
         /// <param name="resolvedSDKItems">Resolved sdk items</param>
-        /// <param name="frameworkPaths">Path to the FX.</param>
+        /// <param name="frameworkPaths">Full paths to the FX.</param>
         /// <param name="installedAssemblies">Installed assembly XML tables.</param>
         /// <param name="targetProcessorArchitecture">Like x86 or IA64\AMD64, the processor architecture being targeted.</param>
         /// <param name="fileExists">Delegate used for checking for the existence of a file.</param>
@@ -265,6 +271,7 @@ internal sealed class ReferenceTable
         /// <param name="warnOrErrorOnTargetArchitectureMismatch"></param>
         /// <param name="ignoreFrameworkAttributeVersionMismatch"></param>
         /// <param name="nonCultureResourceDirectories"></param>
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access and path resolution.</param>
 #endif
         internal ReferenceTable(
             IBuildEngine buildEngine,
@@ -307,7 +314,8 @@ internal ReferenceTable(
             bool ignoreFrameworkAttributeVersionMismatch,
             bool unresolveFrameworkAssembliesFromHigherFrameworks,
             ConcurrentDictionary<string, AssemblyMetadata> assemblyMetadataCache,
-            string[] nonCultureResourceDirectories)
+            string[] nonCultureResourceDirectories,
+            TaskEnvironment taskEnvironment)
         {
             _log = log;
             _findDependencies = findDependencies;
@@ -339,6 +347,7 @@ internal ReferenceTable(
             _assemblyMetadataCache = assemblyMetadataCache;
             _nonCultureResourceDirectories = nonCultureResourceDirectories;
             _enableCustomCulture = enableCustomCulture;
+            _taskEnvironment = taskEnvironment;
 
             // Set condition for when to check assembly version against the target framework version
             _checkAssemblyVersionAgainstTargetFrameworkVersion = unresolveFrameworkAssembliesFromHigherFrameworks || ((_projectTargetFramework ?? ReferenceTable.s_targetFrameworkVersion_40) <= ReferenceTable.s_targetFrameworkVersion_40);
@@ -468,7 +477,7 @@ private AssemblyNameExtension NameAssemblyFileReference(
 
             if (!Path.IsPathRooted(assemblyFileName))
             {
-                reference.FullPath = Path.GetFullPath(assemblyFileName);
+                reference.FullPath = _taskEnvironment.GetAbsolutePath(assemblyFileName).GetCanonicalForm();
             }
             else
             {
@@ -477,15 +486,15 @@ private AssemblyNameExtension NameAssemblyFileReference(
 
             try
             {
-                if (_fileExists(assemblyFileName))
+                if (_fileExists(reference.FullPath))
                 {
-                    assemblyName = _getAssemblyName(assemblyFileName);
+                    assemblyName = _getAssemblyName(reference.FullPath);
                     if (assemblyName != null)
                     {
                         reference.ResolvedSearchPath = assemblyFileName;
                     }
                 }
-                else if (_directoryExists(assemblyFileName))
+                else if (_directoryExists(reference.FullPath))
                 {
                     assemblyName = new AssemblyNameExtension("*directory*");
 
@@ -1355,7 +1364,7 @@ private void ResolveReference(
             // If the path was resolved, then specify the full path on the reference.
             if (resolvedPath != null)
             {
-                resolvedPath = FileUtilities.NormalizePath(resolvedPath);
+                resolvedPath = FileUtilities.FixFilePath(_taskEnvironment.GetAbsolutePath(resolvedPath).GetCanonicalForm()).Value;
                 if (isImmutableFrameworkReference)
                 {
                     _externallyResolvedImmutableFiles[resolvedPath] = GetAssemblyNameFromItemMetadata(reference.PrimarySourceItem);
diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 30d999a4ec4..7210aa47f37 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -33,7 +33,8 @@ namespace Microsoft.Build.Tasks
     /// Given a list of assemblyFiles, determine the closure of all assemblyFiles that
     /// depend on those assemblyFiles including second and nth-order dependencies too.
     /// </summary>
-    public class ResolveAssemblyReference : TaskExtension, IIncrementalTask
+    [MSBuildMultiThreadableTask]
+    public class ResolveAssemblyReference : TaskExtension, IIncrementalTask, IMultiThreadableTask
     {
         /// <summary>
         /// key assembly used to trigger inclusion of facade references.
@@ -179,13 +180,14 @@ internal static void Initialize(TaskLoggingHelper log)
         private bool _ignoreDefaultInstalledAssemblyTables = false;
         private bool _ignoreDefaultInstalledAssemblySubsetTables = false;
         private bool _enableCustomCulture = false;
-        private string[] _candidateAssemblyFiles = [];
-        private string[] _targetFrameworkDirectories = [];
+        private AbsolutePath[] _candidateAssemblyFiles = [];
+        private AbsolutePath[] _targetFrameworkDirectories = [];
         private string[] _nonCultureResourceDirectories = [];
         private string[] _searchPaths = [];
         private string[] _allowedAssemblyExtensions = [".winmd", ".dll", ".exe"];
         private string[] _relatedFileExtensions = [".pdb", ".xml", ".pri"];
-        private string _appConfigFile = null;
+        private AbsolutePath _appConfigFile = default;
+        private bool _appConfigValueIsEmptyString = false;
         private bool _supportsBindingRedirectGeneration;
         private bool _autoUnify = false;
         private bool _ignoreVersionForFrameworkReferences = false;
@@ -212,12 +214,13 @@ internal static void Initialize(TaskLoggingHelper log)
         private string _targetedRuntimeVersionRawValue = String.Empty;
         private Version _projectTargetFramework;
 
-        private string _stateFile = null;
+        private AbsolutePath _stateFile = default;
+        private AbsolutePath _assemblyInformationCacheOutputPath = default;
         private string _targetProcessorArchitecture = null;
 
         private string _profileName = String.Empty;
-        private string[] _fullFrameworkFolders = [];
-        private string[] _latestTargetFrameworkDirectories = [];
+        private AbsolutePath[] _fullFrameworkFolders = [];
+        private AbsolutePath[] _latestTargetFrameworkDirectories = [];
         private bool _copyLocalDependenciesWhenParentReferenceInGac = true;
         private Dictionary<string, MessageImportance> _showAssemblyFoldersExLocations = new Dictionary<string, MessageImportance>(StringComparer.OrdinalIgnoreCase);
         private bool _logVerboseSearchResults = false;
@@ -292,12 +295,13 @@ public string[] LatestTargetFrameworkDirectories
         {
             get
             {
-                return _latestTargetFrameworkDirectories;
+                return _latestTargetFrameworkDirectories?.Select(path => path.OriginalValue).ToArray();
             }
 
             set
             {
-                _latestTargetFrameworkDirectories = value;
+                _latestTargetFrameworkDirectories = value?.Select(
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
             }
         }
 
@@ -392,15 +396,22 @@ public ITaskItem[] Assemblies
 
         /// <summary>
         /// A list of assembly files that can be part of the search and resolution process.
-        /// These must be absolute filenames, or project-relative filenames.
+        /// These must be absolute file paths, or project-relative file paths.
         ///
         /// Assembly files in this list will be considered when SearchPaths contains
         /// {CandidateAssemblyFiles} as one of the paths to consider.
         /// </summary>
         public string[] CandidateAssemblyFiles
         {
-            get { return _candidateAssemblyFiles; }
-            set { _candidateAssemblyFiles = value; }
+            get
+            {
+                return _candidateAssemblyFiles.Select(path => path.OriginalValue).ToArray();
+            }
+            set
+            {
+                _candidateAssemblyFiles = value?.Select(
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
+            }
         }
 
         /// <summary>
@@ -421,8 +432,15 @@ public ITaskItem[] ResolvedSDKReferences
         /// </summary>
         public string[] TargetFrameworkDirectories
         {
-            get { return _targetFrameworkDirectories; }
-            set { _targetFrameworkDirectories = value; }
+            get
+            {
+                return _targetFrameworkDirectories?.Select(path => path.OriginalValue).ToArray();
+            }
+            set
+            {
+                _targetFrameworkDirectories = value?.Select(
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
+            }
         }
 
         /// <summary>
@@ -594,7 +612,17 @@ public string TargetedRuntimeVersion
         /// If not null, serializes information about <see cref="AssemblyFiles" /> inputs to the named file.
         /// This overrides the usual outputs, so do not use this unless you are building an SDK with many references.
         /// </summary>
-        public string AssemblyInformationCacheOutputPath { get; set; }
+        public string AssemblyInformationCacheOutputPath
+        {
+            get => _assemblyInformationCacheOutputPath.OriginalValue;
+            set
+            {
+                if (!string.IsNullOrEmpty(value))
+                {
+                    _assemblyInformationCacheOutputPath = TaskEnvironment.GetAbsolutePath(value);
+                }
+            }
+        }
 
         /// <summary>
         /// If not null, uses this set of caches as inputs if RAR cannot find the usual cache in the obj folder. Typically
@@ -676,8 +704,18 @@ public string[] AllowedRelatedFileExtensions
         /// <value></value>
         public string AppConfigFile
         {
-            get { return _appConfigFile; }
-            set { _appConfigFile = value; }
+            get => _appConfigFile.OriginalValue;
+            set 
+            { 
+                if (!string.IsNullOrEmpty(value))
+                {
+                    _appConfigFile = TaskEnvironment.GetAbsolutePath(value);
+                }
+                else if (value == string.Empty && !ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                {
+                    _appConfigValueIsEmptyString = true;
+                }
+            }
         }
 
         /// <summary>
@@ -764,8 +802,14 @@ public bool DoNotCopyLocalIfInGac
         /// <value></value>
         public string StateFile
         {
-            get { return _stateFile; }
-            set { _stateFile = value; }
+            get => _stateFile.OriginalValue;
+            set 
+            { 
+                if (!string.IsNullOrEmpty(value))
+                {
+                    _stateFile = TaskEnvironment.GetAbsolutePath(value).GetCanonicalForm();
+                }
+            }
         }
 
         /// <summary>
@@ -909,18 +953,22 @@ public string[] FullFrameworkFolders
         {
             get
             {
-                return _fullFrameworkFolders;
+                return _fullFrameworkFolders?.Select(path => path.OriginalValue).ToArray();
             }
 
             set
             {
                 ErrorUtilities.VerifyThrowArgumentNull(value, "FullFrameworkFolders");
-                _fullFrameworkFolders = value;
+                _fullFrameworkFolders = value?.Select(
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
             }
         }
 
         public bool FailIfNotIncremental { get; set; }
 
+        /// <inheritdoc />
+        public TaskEnvironment TaskEnvironment { get; set; }
+
         /// <summary>
         /// Allow the task to run on the out-of-proc node if enabled for this build.
         /// </summary>
@@ -1533,11 +1581,11 @@ private void LogInputs()
             }
 
             Log.LogMessage(importance, property, "CandidateAssemblyFiles");
-            foreach (string file in CandidateAssemblyFiles)
+            foreach (AbsolutePath file in _candidateAssemblyFiles)
             {
                 try
                 {
-                    if (FileUtilities.HasExtension(file, _allowedAssemblyExtensions))
+                    if (FileUtilities.HasExtension(file.OriginalValue, _allowedAssemblyExtensions))
                     {
                         Log.LogMessage(importance, indent + file);
                     }
@@ -1583,7 +1631,7 @@ private void LogInputs()
             }
 
             Log.LogMessage(importance, property, "AppConfigFile");
-            Log.LogMessage(importance, $"{indent}{AppConfigFile}");
+            Log.LogMessage(importance, $"{indent}{_appConfigFile.OriginalValue}");
 
             Log.LogMessage(importance, property, "AutoUnify");
             Log.LogMessage(importance, $"{indent}{AutoUnify}");
@@ -1632,15 +1680,15 @@ private void LogInputs()
             Log.LogMessage(importance, $"{indent}{ProfileName}");
 
             Log.LogMessage(importance, property, "FullFrameworkFolders");
-            foreach (string fullFolder in FullFrameworkFolders)
+            foreach (var fullFolder in _fullFrameworkFolders)
             {
-                Log.LogMessage(importance, $"{indent}{fullFolder}");
+                Log.LogMessage(importance, $"{indent}{fullFolder.OriginalValue}");
             }
 
             Log.LogMessage(importance, property, "LatestTargetFrameworkDirectories");
-            foreach (string latestFolder in _latestTargetFrameworkDirectories)
+            foreach (var latestFolder in _latestTargetFrameworkDirectories)
             {
-                Log.LogMessage(importance, $"{indent}{latestFolder}");
+                Log.LogMessage(importance, $"{indent}{latestFolder.OriginalValue}");
             }
 
             Log.LogMessage(importance, property, "ProfileTablesLocation");
@@ -1707,7 +1755,7 @@ private void LogPrimaryOrDependency(Reference reference, string fusionName, Mess
                         }
                         else
                         {
-                            Log.LogMessage(importance, Strings.UnificationByAppConfig, unificationVersion.version, _appConfigFile, unificationVersion.referenceFullPath);
+                            Log.LogMessage(importance, Strings.UnificationByAppConfig, unificationVersion.version, _appConfigFile.OriginalValue, unificationVersion.referenceFullPath);
                         }
                         break;
 
@@ -2107,7 +2155,7 @@ internal void ReadStateFile(FileExists fileExists)
             // Construct the cache only if we can't find any caches.
             if (_cache == null && AssemblyInformationCachePaths != null && AssemblyInformationCachePaths.Length > 0)
             {
-                _cache = SystemState.DeserializePrecomputedCaches(AssemblyInformationCachePaths, Log, fileExists);
+                _cache = SystemState.DeserializePrecomputedCaches(AssemblyInformationCachePaths, Log, fileExists, TaskEnvironment);
             }
 
             if (_cache == null)
@@ -2121,15 +2169,15 @@ internal void ReadStateFile(FileExists fileExists)
         /// </summary>
         internal void WriteStateFile()
         {
-            if (!string.IsNullOrEmpty(AssemblyInformationCacheOutputPath))
+            if (_assemblyInformationCacheOutputPath.Value is not null)
             {
-                _cache.SerializePrecomputedCache(AssemblyInformationCacheOutputPath, Log);
+                _cache.SerializePrecomputedCache(_assemblyInformationCacheOutputPath.Value, Log);
             }
-            else if (!string.IsNullOrEmpty(_stateFile) && (_cache.IsDirty || _cache.instanceLocalOutgoingFileStateCache.Count < _cache.instanceLocalFileStateCache.Count))
+            else if (_stateFile.Value is not null && (_cache.IsDirty || _cache.instanceLocalOutgoingFileStateCache.Count < _cache.instanceLocalFileStateCache.Count))
             {
                 // Either the cache is dirty (we added or updated an item) or the number of items actually used is less than what
                 // we got by reading the state file prior to execution. Serialize the cache into the state file.
-                _cache.SerializeCache(_stateFile, Log);
+                _cache.SerializeCache(_stateFile.Value, Log);
             }
         }
         #endregion
@@ -2140,10 +2188,10 @@ internal void WriteStateFile()
         /// </summary>
         private List<DependentAssembly> GetAssemblyRemappingsFromAppConfig()
         {
-            if (_appConfigFile != null)
+            if (_appConfigFile.Value is not null)
             {
                 AppConfig appConfig = new AppConfig();
-                appConfig.Load(_appConfigFile);
+                appConfig.Load(_appConfigFile.Value);
 
                 return appConfig.Runtime.DependentAssemblies;
             }
@@ -2237,7 +2285,7 @@ internal bool Execute(
                         return false;
                     }
 
-                    _logVerboseSearchResults = Environment.GetEnvironmentVariable("MSBUILDLOGVERBOSERARSEARCHRESULTS") != null;
+                    _logVerboseSearchResults = TaskEnvironment.GetEnvironmentVariable("MSBUILDLOGVERBOSERARSEARCHRESULTS") != null;
 
                     // Loop through all the target framework directories that were passed in,
                     // and ensure that they all have a trailing slash.  This is necessary
@@ -2268,7 +2316,7 @@ internal bool Execute(
                     string subsetOrProfileName = null;
 
                     // Are we targeting a profile
-                    bool targetingProfile = !String.IsNullOrEmpty(ProfileName) && ((FullFrameworkFolders.Length > 0) || (FullFrameworkAssemblyTables.Length > 0));
+                    bool targetingProfile = !String.IsNullOrEmpty(ProfileName) && ((_fullFrameworkFolders.Length > 0) || (FullFrameworkAssemblyTables.Length > 0));
                     bool targetingSubset = false;
                     List<Exception> inclusionListErrors = new List<Exception>();
                     List<string> inclusionListErrorFilesNames = new List<string>();
@@ -2411,10 +2459,22 @@ internal bool Execute(
                         try
                         {
                             appConfigRemappedAssemblies = GetAssemblyRemappingsFromAppConfig();
+
+                            if (!ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6) && _appConfigValueIsEmptyString)
+                            {
+                                // Preserve backward compatibility for empty AppConfigFile handling.
+                                // Prior to Wave18_6, empty strings would cause TaskEnvironment.GetAbsolutePath() to throw an exception,
+                                // which would be caught and logged as an error, stopping RAR execution.
+                                // With the new behavior, empty strings are silently ignored (treated like null).
+                                // When Wave 18.5 is disabled, we preserve the old failure behavior.
+                                // When cleaning up this change wave, also clean up the _appConfigValueIsEmptyString field.
+                                Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.InvalidAppConfig", string.Empty, "AppConfig file path cannot be empty.");
+                                return false;
+                            }
                         }
                         catch (AppConfigException e)
                         {
-                            Log.LogErrorWithCodeFromResources(null, e.FileName, e.Line, e.Column, 0, 0, "ResolveAssemblyReference.InvalidAppConfig", AppConfigFile, e.Message);
+                            Log.LogErrorWithCodeFromResources(null, e.FileName, e.Line, e.Column, 0, 0, "ResolveAssemblyReference.InvalidAppConfig", _appConfigFile.OriginalValue, e.Message);
                             return false;
                         }
                     }
@@ -2437,9 +2497,9 @@ internal bool Execute(
                         _searchPaths,
                         _allowedAssemblyExtensions,
                         _relatedFileExtensions,
-                        _candidateAssemblyFiles,
+                        _candidateAssemblyFiles?.Select(path => path.Value).ToArray(),
                         _resolvedSDKReferences,
-                        _targetFrameworkDirectories,
+                        _targetFrameworkDirectories?.Select(path => path.Value).ToArray(),
                         installedAssemblies,
                         processorArchitecture,
                         fileExists,
@@ -2457,7 +2517,7 @@ internal bool Execute(
                         _projectTargetFramework,
                         frameworkMoniker,
                         Log,
-                        _latestTargetFrameworkDirectories,
+                        _latestTargetFrameworkDirectories?.Select(path => path.Value).ToArray(),
                         _copyLocalDependenciesWhenParentReferenceInGac,
                         DoNotCopyLocalIfInGac,
                         getAssemblyPathInGac,
@@ -2468,7 +2528,8 @@ internal bool Execute(
                         _ignoreTargetFrameworkAttributeVersionMismatch,
                         _unresolveFrameworkAssembliesFromHigherFrameworks,
                         assemblyMetadataCache,
-                        _nonCultureResourceDirectories);
+                        _nonCultureResourceDirectories,
+                        TaskEnvironment);
 
                     dependencyTable.FindDependenciesOfExternallyResolvedReferences = FindDependenciesOfExternallyResolvedReferences;
 
@@ -2634,9 +2695,9 @@ internal bool Execute(
                     WriteStateFile();
 
                     // Save the new state out and put into the file exists if it is actually on disk.
-                    if (_stateFile != null && fileExists(_stateFile))
+                    if (_stateFile.Value is not null && fileExists(_stateFile.Value))
                     {
-                        _filesWritten.Add(new TaskItem(_stateFile));
+                        _filesWritten.Add(new TaskItem(_stateFile.OriginalValue));
                     }
 
                     // Log the results.
@@ -2822,7 +2883,7 @@ private void HandleProfile(AssemblyTableInfo[] installedAssemblyTableInfo, out A
                 }
             }
 
-            fullRedistAssemblyTableInfo = GetInstalledAssemblyTableInfo(false, FullFrameworkAssemblyTables, new GetListPath(RedistList.GetRedistListPathsFromDisk), FullFrameworkFolders);
+            fullRedistAssemblyTableInfo = GetInstalledAssemblyTableInfo(false, FullFrameworkAssemblyTables, new GetListPath(RedistList.GetRedistListPathsFromDisk), _fullFrameworkFolders?.Select(path => path.Value).ToArray());
             if (fullRedistAssemblyTableInfo.Length > 0)
             {
                 // Get the redist list which represents the Full framework, we need this so that we can generate the exclusion list
@@ -2911,7 +2972,7 @@ private bool VerifyInputConditions()
 
             // Make sure the inputs for profiles are correct
             bool profileNameIsSet = !String.IsNullOrEmpty(ProfileName);
-            bool fullFrameworkFoldersIsSet = FullFrameworkFolders.Length > 0;
+            bool fullFrameworkFoldersIsSet = _fullFrameworkFolders.Length > 0;
             bool fullFrameworkTableLocationsIsSet = FullFrameworkAssemblyTables.Length > 0;
             bool profileIsSet = profileNameIsSet && (fullFrameworkFoldersIsSet || fullFrameworkTableLocationsIsSet);
 
@@ -2942,7 +3003,7 @@ private void DumpTargetProfileLists(AssemblyTableInfo[] installedAssemblyTableIn
                 return;
             }
 
-            string dumpFrameworkSubsetList = Environment.GetEnvironmentVariable("MSBUILDDUMPFRAMEWORKSUBSETLIST");
+            string dumpFrameworkSubsetList = TaskEnvironment.GetEnvironmentVariable("MSBUILDDUMPFRAMEWORKSUBSETLIST");
             if (dumpFrameworkSubsetList == null)
             {
                 return;
@@ -2955,7 +3016,7 @@ private void DumpTargetProfileLists(AssemblyTableInfo[] installedAssemblyTableIn
             {
                 if (redistInfo != null)
                 {
-                    Log.LogMessage(MessageImportance.Low, Strings.FormattedAssemblyInfo, redistInfo.Path);
+                    Log.LogMessage(MessageImportance.Low, Strings.FormattedAssemblyInfo, redistInfo.Path.OriginalValue);
                 }
             }
 
@@ -2966,7 +3027,7 @@ private void DumpTargetProfileLists(AssemblyTableInfo[] installedAssemblyTableIn
                 {
                     if (inclusionListInfo != null)
                     {
-                        Log.LogMessage(MessageImportance.Low, Strings.FormattedAssemblyInfo, inclusionListInfo.Path);
+                        Log.LogMessage(MessageImportance.Low, Strings.FormattedAssemblyInfo, inclusionListInfo.Path.OriginalValue);
                     }
                 }
             }
@@ -3084,7 +3145,7 @@ private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAs
                     string[] listPaths = GetAssemblyListPaths(targetFrameworkDirectory);
                     foreach (string listPath in listPaths)
                     {
-                        tableMap[listPath] = new AssemblyTableInfo(listPath, targetFrameworkDirectory);
+                        tableMap[listPath] = new AssemblyTableInfo(listPath, targetFrameworkDirectory, TaskEnvironment);
                     }
                 }
             }
@@ -3108,7 +3169,7 @@ private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAs
                     }
                 }
 
-                tableMap[installedAssemblyTable.ItemSpec] = new AssemblyTableInfo(installedAssemblyTable.ItemSpec, frameworkDirectory);
+                tableMap[installedAssemblyTable.ItemSpec] = new AssemblyTableInfo(installedAssemblyTable.ItemSpec, frameworkDirectory, TaskEnvironment);
             }
 
             AssemblyTableInfo[] extensions = new AssemblyTableInfo[tableMap.Count];
@@ -3249,7 +3310,7 @@ internal static SystemProcessorArchitecture TargetProcessorArchitectureToEnumera
         private string GetAssemblyPathInGac(AssemblyNameExtension assemblyName, SystemProcessorArchitecture targetProcessorArchitecture, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVersion, FileExists fileExists, bool fullFusionName, bool specificVersion)
         {
 #if FEATURE_GAC
-            return GlobalAssemblyCache.GetLocation(BuildEngine as IBuildEngine4, assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fullFusionName, fileExists, null, null, specificVersion /* this value does not matter if we are passing a full fusion name*/);
+            return GlobalAssemblyCache.GetLocation(BuildEngine as IBuildEngine4, assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fullFusionName, fileExists, null, null, specificVersion /* this value does not matter if we are passing a full fusion name*/, TaskEnvironment);
 #else
             return string.Empty;
 #endif
@@ -3274,9 +3335,9 @@ public override bool Execute()
                     // FilesWritten already defines a public setter which no-ops. Changing its visiblity is a breaking
                     // change, so we can't set it outside of RAR when we check for properties with OutputAttribute.
                     // It only has two possible states, so we can just compute it here.
-                    if (_stateFile != null && FileUtilities.FileExistsNoThrow(_stateFile))
+                    if (_stateFile.Value is not null && FileUtilities.FileExistsNoThrow(_stateFile.Value))
                     {
-                        _filesWritten.Add(new TaskItem(_stateFile));
+                        _filesWritten.Add(new TaskItem(_stateFile.OriginalValue));
                     }
 
                     return success;
@@ -3290,6 +3351,10 @@ public override bool Execute()
                 }
             }
 
+            // In a multithreaded node, relative paths must be resolved relative to the project directory
+            // rather than the process working directory. AbsolutePath objects are created in property setters
+            // when TaskEnvironment is available, so no additional processing needed here.
+
             return Execute(
                 p => FileUtilities.FileExistsNoThrow(p),
                 p => FileUtilities.DirectoryExistsNoThrow(p),
diff --git a/src/Tasks/RedistList.cs b/src/Tasks/RedistList.cs
index 91fc81d0921..cf4531720aa 100644
--- a/src/Tasks/RedistList.cs
+++ b/src/Tasks/RedistList.cs
@@ -621,8 +621,8 @@ internal Dictionary<string, string> GenerateDenyList(AssemblyTableInfo[] allowLi
                         if (allowListErrors.Count == errorsBeforeReadCall)
                         {
                             // The allowList errors passes back problems reading the redist file through the use of an array containing exceptions
-                            allowListErrors.Add(new Exception(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("ResolveAssemblyReference.NoSubSetRedistListName", info.Path)));
-                            allowListErrorFileNames.Add(info.Path);
+                            allowListErrors.Add(new Exception(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("ResolveAssemblyReference.NoSubSetRedistListName", info.Path.OriginalValue)));
+                            allowListErrorFileNames.Add(info.Path.OriginalValue);
                         }
                     }
                 }
@@ -689,7 +689,7 @@ internal Dictionary<string, string> GenerateDenyList(AssemblyTableInfo[] allowLi
         /// <returns>Redist name of the redist list just read in</returns>
         internal static string ReadFile(AssemblyTableInfo assemblyTableInfo, List<AssemblyEntry> assembliesList, List<Exception> errorsList, List<string> errorFilenamesList, List<AssemblyRemapping> remapEntries)
         {
-            string path = assemblyTableInfo.Path;
+            string path = assemblyTableInfo.Path.Value;
             string redistName = null;
             XmlReader reader = null;
 
@@ -978,17 +978,34 @@ internal class AssemblyTableInfo : IComparable
     {
         private string _descriptor;
 
-        internal AssemblyTableInfo(string path, string frameworkDirectory)
+        /// <summary>
+        /// Constructor that converts relative paths to absolute paths using TaskEnvironment.
+        /// </summary>
+        /// <param name="path">Path to the assembly table file (can be relative)</param>
+        /// <param name="frameworkDirectory">Framework directory path</param>
+        /// <param name="taskEnvironment">TaskEnvironment for path conversion</param>
+        internal AssemblyTableInfo(string path, string frameworkDirectory, TaskEnvironment taskEnvironment)
+        {
+            Path = taskEnvironment.GetAbsolutePath(FileUtilities.NormalizeForPathComparison(path)).GetCanonicalForm();
+            FrameworkDirectory = FileUtilities.NormalizeForPathComparison(frameworkDirectory);
+        }
+
+        /// <summary>
+        /// Constructor that expects absolute paths. Use this when paths are already fully qualified.
+        /// </summary>
+        /// <param name="absolutePath">Absolute path to the assembly table file</param>
+        /// <param name="frameworkDirectory">Framework directory path</param>
+        internal AssemblyTableInfo(string absolutePath, string frameworkDirectory)
         {
-            Path = FileUtilities.NormalizeForPathComparison(path);
+            Path = new AbsolutePath(FileUtilities.NormalizeForPathComparison(absolutePath));
             FrameworkDirectory = FileUtilities.NormalizeForPathComparison(frameworkDirectory);
         }
 
-        internal string Path { get; }
+        internal AbsolutePath Path { get; }
 
         internal string FrameworkDirectory { get; }
 
-        internal string Descriptor => _descriptor ?? (_descriptor = Path + FrameworkDirectory);
+        internal string Descriptor => _descriptor ?? (_descriptor = Path.Value + FrameworkDirectory);
 
         public int CompareTo(object obj)
         {
diff --git a/src/Tasks/StateFileBase.cs b/src/Tasks/StateFileBase.cs
index 01e2a102f06..1d43a4cf7c2 100644
--- a/src/Tasks/StateFileBase.cs
+++ b/src/Tasks/StateFileBase.cs
@@ -72,7 +72,11 @@ internal virtual void SerializeCache(string stateFile, TaskLoggingHelper log, bo
 
         /// <summary>
         /// Reads the specified file from disk into a StateFileBase derived object.
+        /// stateFile should be absolute path to the file on disk.
         /// </summary>
+        /// <remarks>
+        /// Prioritize using the AbsolutePath overload of this method. This method is still used by unenlightened tasks, but new code should use the AbsolutePath overload.
+        /// </remarks>
         internal static T DeserializeCache<T>(string stateFile, TaskLoggingHelper log) where T : StateFileBase
         {
             T retVal = null;
@@ -126,6 +130,64 @@ internal static T DeserializeCache<T>(string stateFile, TaskLoggingHelper log) w
             return retVal;
         }
 
+
+        /// <summary>
+        /// Reads the specified file from disk into a StateFileBase derived object.
+        /// </summary>
+        internal static T DeserializeCache<T>(AbsolutePath stateFile, TaskLoggingHelper log) where T : StateFileBase
+        {
+            T retVal = null;
+
+            // First, we read the cache from disk if one exists, or if one does not exist, we create one.
+            try
+            {
+                if (!string.IsNullOrEmpty(stateFile) && FileSystems.Default.FileExists(stateFile))
+                {
+                    using (FileStream s = File.OpenRead(stateFile))
+                    {
+                        using var translator = BinaryTranslator.GetReadTranslator(s, InterningBinaryReader.PoolingBuffer);
+
+                        byte version = 0;
+                        translator.Translate(ref version);
+                        // If the version is wrong, log a message not a warning. This could be a valid cache with the wrong version preventing correct deserialization.
+                        // For the latter case, internals may be unexpectedly null.
+                        if (version != CurrentSerializationVersion)
+                        {
+                            log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile.OriginalValue, log.FormatResourceString("General.IncompatibleStateFileType"));
+                            return null;
+                        }
+
+                        var constructors = typeof(T).GetConstructors();
+                        foreach (var constructor in constructors)
+                        {
+                            var parameters = constructor.GetParameters();
+                            if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ITranslator))
+                            {
+                                retVal = constructor.Invoke([translator]) as T;
+                            }
+                        }
+
+                        if (retVal == null)
+                        {
+                            log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile.OriginalValue,
+                                log.FormatResourceString("General.IncompatibleStateFileType"));
+                        }
+                    }
+                }
+            }
+            catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
+            {
+                // The deserialization process seems like it can throw just about
+                // any exception imaginable.  Catch them all here.
+                // Not being able to deserialize the cache is not an error, but we let the user know anyway.
+                // Don't want to hold up processing just because we couldn't read the file.
+                log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile.OriginalValue, e.Message);
+            }
+
+            return retVal;
+        }
+
+
         /// <summary>
         /// Deletes the state file from disk
         /// </summary>
diff --git a/src/Tasks/SystemState.cs b/src/Tasks/SystemState.cs
index 37cf4cbf269..15b01d6496d 100644
--- a/src/Tasks/SystemState.cs
+++ b/src/Tasks/SystemState.cs
@@ -556,11 +556,12 @@ private void GetAssemblyMetadata(
         /// <summary>
         /// Reads in cached data from stateFiles to build an initial cache. Avoids logging warnings or errors.
         /// </summary>
-        /// <param name="stateFiles">List of locations of caches on disk.</param>
+        /// <param name="stateFiles">List of locations of caches on disk. </param>
         /// <param name="log">How to log</param>
         /// <param name="fileExists">Whether a file exists</param>
+        /// <param name="taskEnvironment">TaskEnvironment for path resolution</param>
         /// <returns>A cache representing key aspects of file states.</returns>
-        internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles, TaskLoggingHelper log, FileExists fileExists)
+        internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles, TaskLoggingHelper log, FileExists fileExists, TaskEnvironment taskEnvironment)
         {
             SystemState retVal = new SystemState();
             retVal.isDirty = stateFiles.Length > 0;
@@ -568,8 +569,25 @@ internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles,
 
             foreach (ITaskItem stateFile in stateFiles)
             {
-                // Verify that it's a real stateFile. Log message but do not error if not.
-                SystemState sysState = DeserializeCache<SystemState>(stateFile.ToString(), log);
+                SystemState sysState = null;
+                string stateFilePath = null;
+                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                {
+                    AbsolutePath stateFileAbsolutePath = taskEnvironment.GetAbsolutePath(stateFile.ItemSpec).GetCanonicalForm();
+                    stateFilePath = stateFileAbsolutePath.Value;
+
+                    // Verify that it's a real stateFile. Log message but do not error if not.
+                    sysState = DeserializeCache<SystemState>(stateFileAbsolutePath, log);
+                }
+                else
+                {
+                    // This should be equivalent to stateFile.ItemSpec, but in some cases (for example custom TaskItems) it might not be.
+                    stateFilePath = stateFile.ToString();
+
+                    // Verify that it's a real stateFile. Log message but do not error if not.
+                    sysState = DeserializeCache<SystemState>(stateFilePath, log);
+                }
+
                 if (sysState == null)
                 {
                     continue;
@@ -580,7 +598,8 @@ internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles,
                     if (!assembliesFound.Contains(relativePath))
                     {
                         FileState fileState = kvp.Value;
-                        string fullPath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(stateFile.ToString()), relativePath));
+                        string fullPath  = taskEnvironment.GetAbsolutePath(Path.Combine(Path.GetDirectoryName(stateFilePath), relativePath)).GetCanonicalForm().Value;
+                        
                         if (fileExists(fullPath))
                         {
                             // Correct file path

From f090cefed26992ce5c0932f6617ec3156291c551 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 12 Mar 2026 15:39:04 +0100
Subject: [PATCH 03/29] Make resolvers use task environemnt.

---
 .../AssemblyFoldersExResolver.cs              | 19 +++++++----
 .../AssemblyFoldersFromConfigCache.cs         |  4 +--
 .../AssemblyFoldersFromConfigResolver.cs      |  8 ++---
 .../AssemblyFoldersResolver.cs                |  8 +++--
 .../AssemblyDependency/AssemblyResolution.cs  | 30 +++++++++--------
 .../CandidateAssemblyFilesResolver.cs         |  7 ++--
 .../AssemblyDependency/DirectoryResolver.cs   | 15 ++++++---
 .../FrameworkPathResolver.cs                  |  5 +--
 src/Tasks/AssemblyDependency/GacResolver.cs   |  6 ++--
 .../AssemblyDependency/HintPathResolver.cs    |  9 +++---
 .../AssemblyDependency/RawFilenameResolver.cs | 12 ++++---
 .../AssemblyDependency/ReferenceTable.cs      |  7 ++--
 src/Tasks/AssemblyDependency/Resolver.cs      | 32 +++++++++++--------
 src/Tasks/InstalledSDKResolver.cs             | 19 ++++++++---
 14 files changed, 113 insertions(+), 68 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
index 49ba2302654..66728720404 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
@@ -91,6 +91,11 @@ internal class AssemblyFoldersExResolver : Resolver
         /// </summary>
         private readonly IBuildEngine4 _buildEngine;
 
+        /// <summary>
+        /// TaskEnvironment for thread-safe access to environment variables.
+        /// </summary>
+        private readonly TaskEnvironment _taskEnvironment;
+
         /// <summary>
         /// If it is not initialized then just return the null object, that would mean the resolver was not called.
         /// </summary>
@@ -99,13 +104,14 @@ internal class AssemblyFoldersExResolver : Resolver
         /// <summary>
         /// Construct.
         /// </summary>
-        public AssemblyFoldersExResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetRegistrySubKeyNames getRegistrySubKeyNames, GetRegistrySubKeyDefaultValue getRegistrySubKeyDefaultValue, GetAssemblyRuntimeVersion getRuntimeVersion, OpenBaseKey openBaseKey, Version targetedRuntimeVesion, ProcessorArchitecture targetProcessorArchitecture, bool compareProcessorArchitecture, IBuildEngine buildEngine)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, targetProcessorArchitecture, compareProcessorArchitecture)
+        public AssemblyFoldersExResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetRegistrySubKeyNames getRegistrySubKeyNames, GetRegistrySubKeyDefaultValue getRegistrySubKeyDefaultValue, GetAssemblyRuntimeVersion getRuntimeVersion, OpenBaseKey openBaseKey, Version targetedRuntimeVesion, ProcessorArchitecture targetProcessorArchitecture, bool compareProcessorArchitecture, IBuildEngine buildEngine, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, targetProcessorArchitecture, compareProcessorArchitecture, taskEnvironment)
         {
             _buildEngine = buildEngine as IBuildEngine4;
             _getRegistrySubKeyNames = getRegistrySubKeyNames;
             _getRegistrySubKeyDefaultValue = getRegistrySubKeyDefaultValue;
             _openBaseKey = openBaseKey;
+            _taskEnvironment = taskEnvironment;
         }
 
         /// <summary>
@@ -161,7 +167,7 @@ private void LazyInitialize()
                     }
                     _wasMatch = true;
 
-                    bool useCache = Environment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") == null;
+                    bool useCache = _taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") == null;
                     string key = "ca22615d-aa83-444b-80b9-b32f3d5db097" + this.searchPathElement;
                     if (useCache && _buildEngine != null)
                     {
@@ -171,7 +177,7 @@ private void LazyInitialize()
                     if (_assemblyFoldersCache == null)
                     {
                         AssemblyFoldersEx assemblyFolders = new AssemblyFoldersEx(_registryKeyRoot, _targetRuntimeVersion, _registryKeySuffix, _osVersion, _platform, _getRegistrySubKeyNames, _getRegistrySubKeyDefaultValue, this.targetProcessorArchitecture, _openBaseKey);
-                        _assemblyFoldersCache = new AssemblyFoldersExCache(assemblyFolders, fileExists);
+                        _assemblyFoldersCache = new AssemblyFoldersExCache(assemblyFolders, fileExists, _taskEnvironment);
                         if (useCache)
                         {
                             _buildEngine?.RegisterTaskObject(key, _assemblyFoldersCache, RegisteredTaskObjectLifetime.Build, true /* dispose early ok*/);
@@ -212,6 +218,7 @@ public override bool Resolve(
                     {
                         foreach (AssemblyFoldersExInfo assemblyFolder in _assemblyFoldersCache.AssemblyFoldersEx)
                         {
+                            // assemblyFolder.DirectoryPath is assumed to be absolute path as it was taken from registry.
                             string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, assemblyFolder.DirectoryPath, assembliesConsideredAndRejected);
 
                             // We have a full path returned
@@ -280,12 +287,12 @@ internal class AssemblyFoldersExCache
         /// <summary>
         /// Constructor
         /// </summary>
-        internal AssemblyFoldersExCache(AssemblyFoldersEx assemblyFoldersEx, FileExists fileExists)
+        internal AssemblyFoldersExCache(AssemblyFoldersEx assemblyFoldersEx, FileExists fileExists, TaskEnvironment taskEnvironment)
         {
             AssemblyFoldersEx = assemblyFoldersEx;
             _fileExists = fileExists;
 
-            if (Environment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") != null)
+            if (taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") != null)
             {
                 _useOriginalFileExists = true;
             }
diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
index 45f0d257c12..4346b773f66 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
@@ -35,12 +35,12 @@ internal class AssemblyFoldersFromConfigCache
         /// <summary>
         /// Constructor
         /// </summary>
-        internal AssemblyFoldersFromConfigCache(AssemblyFoldersFromConfig assemblyFoldersFromConfig, FileExists fileExists)
+        internal AssemblyFoldersFromConfigCache(AssemblyFoldersFromConfig assemblyFoldersFromConfig, FileExists fileExists, TaskEnvironment taskEnvironment)
         {
             AssemblyFoldersFromConfig = assemblyFoldersFromConfig;
             _fileExists = fileExists;
 
-            if (Environment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") != null)
+            if (taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") != null)
             {
                 _useOriginalFileExists = true;
             }
diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
index 4208cf4c72e..fe37317e078 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
@@ -75,10 +75,10 @@ internal class AssemblyFoldersFromConfigResolver : Resolver
         public AssemblyFoldersFromConfigResolver(string searchPathElement, GetAssemblyName getAssemblyName,
             FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion,
             ProcessorArchitecture targetProcessorArchitecture, bool compareProcessorArchitecture,
-            IBuildEngine buildEngine, TaskLoggingHelper log)
+            IBuildEngine buildEngine, TaskLoggingHelper log, TaskEnvironment taskEnvironment)
             : base(
                 searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion,
-                targetProcessorArchitecture, compareProcessorArchitecture)
+                targetProcessorArchitecture, compareProcessorArchitecture, taskEnvironment)
         {
             _buildEngine = buildEngine as IBuildEngine4;
             _taskLogger = log;
@@ -115,7 +115,7 @@ private void LazyInitialize()
 
                     _wasMatch = true;
 
-                    bool useCache = Environment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") == null;
+                    bool useCache = taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") == null;
                     string key = "6f7de854-47fe-4ae2-9cfe-9b33682abd91" + searchPathElement;
 
                     if (useCache && _buildEngine != null)
@@ -133,7 +133,7 @@ private void LazyInitialize()
                         try
                         {
                             AssemblyFoldersFromConfig assemblyFolders = new AssemblyFoldersFromConfig(_assemblyFolderConfigFile, _targetRuntimeVersion, targetProcessorArchitecture);
-                            _assemblyFoldersCache = new AssemblyFoldersFromConfigCache(assemblyFolders, fileExists);
+                            _assemblyFoldersCache = new AssemblyFoldersFromConfigCache(assemblyFolders, fileExists, taskEnvironment);
                             if (useCache)
                             {
                                 _buildEngine?.RegisterTaskObject(key, _assemblyFoldersCache, RegisteredTaskObjectLifetime.Build, true /* dispose early ok*/);
diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs
index 9d1d89e75ab..ad14e572e71 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
 
 #nullable disable
@@ -22,8 +23,9 @@ internal class AssemblyFoldersResolver : Resolver
         /// <param name="fileExists">Delegate that returns if the file exists.</param>
         /// <param name="getRuntimeVersion">Delegate that returns the clr runtime version for the file.</param>
         /// <param name="targetedRuntimeVesion">The targeted runtime version.</param>
-        public AssemblyFoldersResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false)
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access and path resolution.</param>
+        public AssemblyFoldersResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
         }
 
@@ -49,7 +51,7 @@ public override bool Resolve(
 #if FEATURE_WIN32_REGISTRY
             if (assemblyName != null)
             {
-                // {AssemblyFolders} was passed in.
+                // {AssemblyFolders} was passed in. They come from registry and are assumed to be absolute paths.
                 foreach (string assemblyFolder in AssemblyFolder.GetAssemblyFolders(assemblyFolderKey))
                 {
                     string resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, assemblyFolder, assembliesConsideredAndRejected);
diff --git a/src/Tasks/AssemblyDependency/AssemblyResolution.cs b/src/Tasks/AssemblyDependency/AssemblyResolution.cs
index a5bf72a3616..ce56a1419de 100644
--- a/src/Tasks/AssemblyDependency/AssemblyResolution.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyResolution.cs
@@ -120,6 +120,7 @@ internal static string ResolveReference(
         /// <param name="targetedRuntimeVersion"></param>
         /// <param name="getAssemblyPathInGac"></param>
         /// <param name="log"></param>
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access.</param>
         /// <returns></returns>
 #else
         /// <summary>
@@ -129,7 +130,7 @@ internal static string ResolveReference(
         /// <param name="searchPaths"></param>
         /// <param name="candidateAssemblyFiles">Paths to assembly files mentioned in the project.</param>
         /// <param name="targetProcessorArchitecture">Like x86 or IA64\AMD64, the processor architecture being targetted.</param>
-        /// <param name="frameworkPaths">Paths to FX folders.</param>
+        /// <param name="frameworkPaths">Full paths to FX folders.</param>
         /// <param name="fileExists"></param>
         /// <param name="getAssemblyName"></param>
         /// <param name="installedAssemblies"></param>
@@ -137,6 +138,7 @@ internal static string ResolveReference(
         /// <param name="targetedRuntimeVersion"></param>
         /// <param name="getAssemblyPathInGac"></param>
         /// <param name="log"></param>
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access.</param>
         /// <returns></returns>
 #endif
         public static Resolver[] CompileSearchPaths(
@@ -156,7 +158,8 @@ public static Resolver[] CompileSearchPaths(
             GetAssemblyRuntimeVersion getRuntimeVersion,
             Version targetedRuntimeVersion,
             GetAssemblyPathInGac getAssemblyPathInGac,
-            TaskLoggingHelper log)
+            TaskLoggingHelper log,
+            TaskEnvironment taskEnvironment)
         {
             var resolvers = new Resolver[searchPaths.Length];
 
@@ -168,44 +171,44 @@ public static Resolver[] CompileSearchPaths(
                 // HintPath property.
                 if (String.Equals(basePath, AssemblyResolutionConstants.hintPathSentinel, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new HintPathResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion);
+                    resolvers[p] = new HintPathResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, taskEnvironment);
                 }
                 else if (String.Equals(basePath, AssemblyResolutionConstants.frameworkPathSentinel, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new FrameworkPathResolver(frameworkPaths, installedAssemblies, searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion);
+                    resolvers[p] = new FrameworkPathResolver(frameworkPaths, installedAssemblies, searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, taskEnvironment);
                 }
                 else if (String.Equals(basePath, AssemblyResolutionConstants.rawFileNameSentinel, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new RawFilenameResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion);
+                    resolvers[p] = new RawFilenameResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, taskEnvironment);
                 }
                 else if (String.Equals(basePath, AssemblyResolutionConstants.candidateAssemblyFilesSentinel, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new CandidateAssemblyFilesResolver(candidateAssemblyFiles, searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion);
+                    resolvers[p] = new CandidateAssemblyFilesResolver(candidateAssemblyFiles, searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, taskEnvironment);
                 }
 #if FEATURE_GAC
                 else if (String.Equals(basePath, AssemblyResolutionConstants.gacSentinel, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new GacResolver(targetProcessorArchitecture, searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, getAssemblyPathInGac);
+                    resolvers[p] = new GacResolver(targetProcessorArchitecture, searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, getAssemblyPathInGac, taskEnvironment);
                 }
 #endif
                 else if (String.Equals(basePath, AssemblyResolutionConstants.assemblyFoldersSentinel, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new AssemblyFoldersResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion);
+                    resolvers[p] = new AssemblyFoldersResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, taskEnvironment);
                 }
 #if FEATURE_WIN32_REGISTRY
                 // Check for AssemblyFoldersEx sentinel.
                 else if (0 == String.Compare(basePath, 0, AssemblyResolutionConstants.assemblyFoldersExSentinel, 0, AssemblyResolutionConstants.assemblyFoldersExSentinel.Length, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new AssemblyFoldersExResolver(searchPaths[p], getAssemblyName, fileExists, getRegistrySubKeyNames, getRegistrySubKeyDefaultValue, getRuntimeVersion, openBaseKey, targetedRuntimeVersion, targetProcessorArchitecture, true, buildEngine);
+                    resolvers[p] = new AssemblyFoldersExResolver(searchPaths[p], getAssemblyName, fileExists, getRegistrySubKeyNames, getRegistrySubKeyDefaultValue, getRuntimeVersion, openBaseKey, targetedRuntimeVersion, targetProcessorArchitecture, true, buildEngine, taskEnvironment);
                 }
 #endif
                 else if (0 == String.Compare(basePath, 0, AssemblyResolutionConstants.assemblyFoldersFromConfigSentinel, 0, AssemblyResolutionConstants.assemblyFoldersFromConfigSentinel.Length, StringComparison.OrdinalIgnoreCase))
                 {
-                    resolvers[p] = new AssemblyFoldersFromConfigResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, targetProcessorArchitecture, true, buildEngine, log);
+                    resolvers[p] = new AssemblyFoldersFromConfigResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, targetProcessorArchitecture, true, buildEngine, log, taskEnvironment);
                 }
                 else
                 {
-                    resolvers[p] = new DirectoryResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, null);
+                    resolvers[p] = new DirectoryResolver(searchPaths[p], getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, null, taskEnvironment);
                 }
             }
             return resolvers;
@@ -219,12 +222,13 @@ internal static Resolver[] CompileDirectories(
             FileExists fileExists,
             GetAssemblyName getAssemblyName,
             GetAssemblyRuntimeVersion getRuntimeVersion,
-            Version targetedRuntimeVersion)
+            Version targetedRuntimeVersion,
+            TaskEnvironment taskEnvironment)
         {
             var resolvers = new Resolver[parentReferenceDirectories.Count];
             for (int i = 0; i < parentReferenceDirectories.Count; i++)
             {
-                resolvers[i] = new DirectoryResolver(parentReferenceDirectories[i].Directory, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, parentReferenceDirectories[i].ParentAssembly);
+                resolvers[i] = new DirectoryResolver(parentReferenceDirectories[i].Directory, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVersion, parentReferenceDirectories[i].ParentAssembly, taskEnvironment);
             }
 
             return resolvers;
diff --git a/src/Tasks/AssemblyDependency/CandidateAssemblyFilesResolver.cs b/src/Tasks/AssemblyDependency/CandidateAssemblyFilesResolver.cs
index 99bda929a54..f990741d79c 100644
--- a/src/Tasks/AssemblyDependency/CandidateAssemblyFilesResolver.cs
+++ b/src/Tasks/AssemblyDependency/CandidateAssemblyFilesResolver.cs
@@ -25,14 +25,15 @@ internal class CandidateAssemblyFilesResolver : Resolver
         /// <summary>
         /// Construct.
         /// </summary>
-        /// <param name="candidateAssemblyFiles">List of literal assembly file names to be considered when SearchPaths has {CandidateAssemblyFiles}.</param>
+        /// <param name="candidateAssemblyFiles">List of literal assembly file names (full paths) to be considered when SearchPaths has {CandidateAssemblyFiles}.</param>
         /// <param name="searchPathElement">The corresponding element from the search path.</param>
         /// <param name="getAssemblyName">Delegate that gets the assembly name.</param>
         /// <param name="fileExists">Delegate that returns if the file exists.</param>
         /// <param name="getRuntimeVersion">Delegate that returns the clr runtime version for the file.</param>
         /// <param name="targetedRuntimeVesion">The targeted runtime version.</param>
-        public CandidateAssemblyFilesResolver(string[] candidateAssemblyFiles, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, ProcessorArchitecture.None, false)
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access and path resolution.</param>
+        public CandidateAssemblyFilesResolver(string[] candidateAssemblyFiles, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, ProcessorArchitecture.None, false, taskEnvironment)
         {
             _candidateAssemblyFiles = candidateAssemblyFiles;
         }
diff --git a/src/Tasks/AssemblyDependency/DirectoryResolver.cs b/src/Tasks/AssemblyDependency/DirectoryResolver.cs
index f5b7947bf73..c737557a904 100644
--- a/src/Tasks/AssemblyDependency/DirectoryResolver.cs
+++ b/src/Tasks/AssemblyDependency/DirectoryResolver.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
 
 #nullable disable
@@ -19,13 +20,19 @@ internal class DirectoryResolver : Resolver
         /// </summary>
         public readonly string parentAssembly;
 
+        /// <summary>
+        /// Cached absolute path for the search path element
+        /// </summary>
+        private readonly string _fullSearchPath;
+
         /// <summary>
         /// Construct.
         /// </summary>
-        public DirectoryResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, string parentAssembly)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false)
+        public DirectoryResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, string parentAssembly, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
             this.parentAssembly = parentAssembly;
+            _fullSearchPath = string.IsNullOrEmpty(searchPathElement) ? searchPathElement : taskEnvironment.GetAbsolutePath(searchPathElement).GetCanonicalForm().Value;
         }
 
         /// <inheritdoc/>
@@ -53,7 +60,7 @@ public override bool Resolve(
                 var searchLocationsWithParentAssembly = new List<ResolutionSearchLocation>();
 
                 // Resolve to the given path.
-                resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, searchPathElement, searchLocationsWithParentAssembly);
+                resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, _fullSearchPath, searchLocationsWithParentAssembly);
 
                 foreach (var searchLocation in searchLocationsWithParentAssembly)
                 {
@@ -64,7 +71,7 @@ public override bool Resolve(
             }
             else
             {
-                resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, searchPathElement, assembliesConsideredAndRejected);
+                resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, _fullSearchPath, assembliesConsideredAndRejected);
             }
 
             if (resolvedPath != null)
diff --git a/src/Tasks/AssemblyDependency/FrameworkPathResolver.cs b/src/Tasks/AssemblyDependency/FrameworkPathResolver.cs
index cd57aa7d6b5..3d7db166ece 100644
--- a/src/Tasks/AssemblyDependency/FrameworkPathResolver.cs
+++ b/src/Tasks/AssemblyDependency/FrameworkPathResolver.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
 
 #nullable disable
@@ -23,8 +24,8 @@ internal class FrameworkPathResolver : Resolver
         /// <summary>
         /// Construct.
         /// </summary>
-        public FrameworkPathResolver(string[] frameworkPaths, InstalledAssemblies installedAssemblies, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false)
+        public FrameworkPathResolver(string[] frameworkPaths, InstalledAssemblies installedAssemblies, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
             _frameworkPaths = frameworkPaths;
             _installedAssemblies = installedAssemblies;
diff --git a/src/Tasks/AssemblyDependency/GacResolver.cs b/src/Tasks/AssemblyDependency/GacResolver.cs
index bf416cc56ed..c48062f7a98 100644
--- a/src/Tasks/AssemblyDependency/GacResolver.cs
+++ b/src/Tasks/AssemblyDependency/GacResolver.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
 
 #nullable disable
@@ -29,8 +30,9 @@ internal class GacResolver : Resolver
         /// <param name="getRuntimeVersion">Delegate to get the runtime version.</param>
         /// <param name="targetedRuntimeVesion">The targeted runtime version.</param>
         /// <param name="getAssemblyPathInGac">Delegate to get assembly path in the GAC.</param>
-        public GacResolver(System.Reflection.ProcessorArchitecture targetProcessorArchitecture, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, GetAssemblyPathInGac getAssemblyPathInGac)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, targetProcessorArchitecture, true)
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe environment variable access and path resolution.</param>
+        public GacResolver(System.Reflection.ProcessorArchitecture targetProcessorArchitecture, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, GetAssemblyPathInGac getAssemblyPathInGac, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, targetProcessorArchitecture, true, taskEnvironment)
         {
             _getAssemblyPathInGac = getAssemblyPathInGac;
         }
diff --git a/src/Tasks/AssemblyDependency/HintPathResolver.cs b/src/Tasks/AssemblyDependency/HintPathResolver.cs
index 08c6d97ef52..e57a0977f7a 100644
--- a/src/Tasks/AssemblyDependency/HintPathResolver.cs
+++ b/src/Tasks/AssemblyDependency/HintPathResolver.cs
@@ -19,8 +19,8 @@ internal class HintPathResolver : Resolver
         /// <summary>
         /// Construct.
         /// </summary>
-        public HintPathResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, ProcessorArchitecture.None, false)
+        public HintPathResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, ProcessorArchitecture.None, false, taskEnvironment)
         {
         }
 
@@ -45,10 +45,11 @@ public override bool Resolve(
             // However, we should consider Trim() the hintpath https://github.com/dotnet/msbuild/issues/4603
             if (!string.IsNullOrEmpty(hintPath) && !FileUtilities.PathIsInvalid(hintPath))
             {
-                if (ResolveAsFile(FileUtilities.NormalizePath(hintPath), assemblyName, isPrimaryProjectReference, wantSpecificVersion, true, assembliesConsideredAndRejected))
+                string fullHintPath = taskEnvironment.GetAbsolutePath(hintPath).GetCanonicalForm().Value;
+                if (ResolveAsFile(fullHintPath, assemblyName, isPrimaryProjectReference, wantSpecificVersion, true, assembliesConsideredAndRejected))
                 {
                     userRequestedSpecificFile = true;
-                    foundPath = hintPath;
+                    foundPath = fullHintPath;
                     return true;
                 }
             }
diff --git a/src/Tasks/AssemblyDependency/RawFilenameResolver.cs b/src/Tasks/AssemblyDependency/RawFilenameResolver.cs
index 72f1afb79a2..334addeb83d 100644
--- a/src/Tasks/AssemblyDependency/RawFilenameResolver.cs
+++ b/src/Tasks/AssemblyDependency/RawFilenameResolver.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
 
 #nullable disable
@@ -18,8 +19,8 @@ internal class RawFilenameResolver : Resolver
         /// <summary>
         /// Construct.
         /// </summary>
-        public RawFilenameResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, ProcessorArchitecture.None, false)
+        public RawFilenameResolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, ProcessorArchitecture.None, false, taskEnvironment)
         {
         }
 
@@ -44,10 +45,11 @@ public override bool Resolve(
             if (rawFileNameCandidate != null)
             {
                 // {RawFileName} was passed in.
-                if (isImmutableFrameworkReference || fileExists(rawFileNameCandidate))
+                string fullRawFileName = taskEnvironment.GetAbsolutePath(rawFileNameCandidate).GetCanonicalForm().Value;
+                if (isImmutableFrameworkReference || fileExists(fullRawFileName))
                 {
                     userRequestedSpecificFile = true;
-                    foundPath = rawFileNameCandidate;
+                    foundPath = fullRawFileName;
                     return true;
                 }
 
@@ -55,7 +57,7 @@ public override bool Resolve(
                 {
                     var considered = new ResolutionSearchLocation
                     {
-                        FileNameAttempted = rawFileNameCandidate,
+                        FileNameAttempted = fullRawFileName,
                         SearchPath = searchPathElement,
                         Reason = NoMatchReason.NotAFileNameOnDisk
                     };
diff --git a/src/Tasks/AssemblyDependency/ReferenceTable.cs b/src/Tasks/AssemblyDependency/ReferenceTable.cs
index 8f7b41c6385..aef5d224a70 100644
--- a/src/Tasks/AssemblyDependency/ReferenceTable.cs
+++ b/src/Tasks/AssemblyDependency/ReferenceTable.cs
@@ -387,7 +387,8 @@ internal ReferenceTable(
                     getRuntimeVersion,
                     targetedRuntimeVersion,
                     getAssemblyPathInGac,
-                    log);
+                    log,
+                    taskEnvironment);
         }
 
         /// <summary>
@@ -1322,14 +1323,14 @@ private void ResolveReference(
             // If a reference has the SDKName metadata on it then we will only search using a single resolver, that is the InstalledSDKResolver.
             if (reference.SDKName.Length > 0)
             {
-                jaggedResolvers.Add([new InstalledSDKResolver(_resolvedSDKReferences, "SDKResolver", _getAssemblyName, _fileExists, _getRuntimeVersion, _targetedRuntimeVersion)]);
+                jaggedResolvers.Add([new InstalledSDKResolver(_resolvedSDKReferences, "SDKResolver", _getAssemblyName, _fileExists, _getRuntimeVersion, _targetedRuntimeVersion, _taskEnvironment)]);
             }
             else
             {
                 // Do not probe near dependees if the reference is primary and resolved externally. If resolved externally, the search paths should have been specified in such a way to point to the assembly file.
                 if (parentReferenceFolders.Count > 0 && (assemblyName == null || !_externallyResolvedPrimaryReferences.Contains(assemblyName.Name)))
                 {
-                    jaggedResolvers.Add(AssemblyResolution.CompileDirectories(parentReferenceFolders, _fileExists, _getAssemblyName, _getRuntimeVersion, _targetedRuntimeVersion));
+                    jaggedResolvers.Add(AssemblyResolution.CompileDirectories(parentReferenceFolders, _fileExists, _getAssemblyName, _getRuntimeVersion, _targetedRuntimeVersion, _taskEnvironment));
                 }
 
                 jaggedResolvers.Add(Resolvers);
diff --git a/src/Tasks/AssemblyDependency/Resolver.cs b/src/Tasks/AssemblyDependency/Resolver.cs
index 62a455c983d..3656ddc262f 100644
--- a/src/Tasks/AssemblyDependency/Resolver.cs
+++ b/src/Tasks/AssemblyDependency/Resolver.cs
@@ -52,10 +52,15 @@ internal abstract class Resolver
         /// </summary>
         protected bool compareProcessorArchitecture;
 
+        /// <summary>
+        /// TaskEnvironment for thread-safe environment variable access and path resolution.
+        /// </summary>
+        protected TaskEnvironment taskEnvironment;
+
         /// <summary>
         /// Construct.
         /// </summary>
-        protected Resolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVersion, ProcessorArchitecture targetedProcessorArchitecture, bool compareProcessorArchitecture)
+        protected Resolver(string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVersion, ProcessorArchitecture targetedProcessorArchitecture, bool compareProcessorArchitecture, TaskEnvironment taskEnvironment)
         {
             this.searchPathElement = searchPathElement;
             this.getAssemblyName = getAssemblyName;
@@ -64,6 +69,7 @@ protected Resolver(string searchPathElement, GetAssemblyName getAssemblyName, Fi
             this.targetedRuntimeVersion = targetedRuntimeVersion;
             this.targetProcessorArchitecture = targetedProcessorArchitecture;
             this.compareProcessorArchitecture = compareProcessorArchitecture;
+            this.taskEnvironment = taskEnvironment;
         }
 
         /// <summary>
@@ -141,25 +147,25 @@ protected bool ResolveAsFile(
         /// <param name="isPrimaryProjectReference">True if this is a primary reference directly from the project file.</param>
         /// <param name="wantSpecificVersion">Whether the version needs to match exactly or loosely.</param>
         /// <param name="allowMismatchBetweenFusionNameAndFileName">Whether to allow naming mismatch.</param>
-        /// <param name="pathToCandidateAssembly">Path to a possible file.</param>
+        /// <param name="fullPathToCandidateAssembly">Full path to a possible file.</param>
         /// <param name="searchLocation">Information about why the candidate file didn't match</param>
         protected bool FileMatchesAssemblyName(
             AssemblyNameExtension assemblyName,
             bool isPrimaryProjectReference,
             bool wantSpecificVersion,
             bool allowMismatchBetweenFusionNameAndFileName,
-            string pathToCandidateAssembly,
+            string fullPathToCandidateAssembly,
             ResolutionSearchLocation searchLocation)
         {
             if (searchLocation != null)
             {
-                searchLocation.FileNameAttempted = pathToCandidateAssembly;
+                searchLocation.FileNameAttempted = fullPathToCandidateAssembly;
             }
 
             // Base name of the target file has to match the Name from the assemblyName
             if (!allowMismatchBetweenFusionNameAndFileName)
             {
-                string candidateBaseName = Path.GetFileNameWithoutExtension(pathToCandidateAssembly);
+                string candidateBaseName = Path.GetFileNameWithoutExtension(fullPathToCandidateAssembly);
                 if (!String.Equals(assemblyName?.Name, candidateBaseName, StringComparison.CurrentCultureIgnoreCase))
                 {
                     if (searchLocation != null)
@@ -180,7 +186,7 @@ protected bool FileMatchesAssemblyName(
 
             bool isSimpleAssemblyName = assemblyName?.IsSimpleName == true;
 
-            if (fileExists(pathToCandidateAssembly))
+            if (fileExists(fullPathToCandidateAssembly))
             {
                 // If the resolver we are using is targeting a given processor architecture then we must crack open the assembly and make sure the architecture is compatible
                 // We cannot do these simple name matches.
@@ -203,7 +209,7 @@ protected bool FileMatchesAssemblyName(
                 AssemblyNameExtension targetAssemblyName = null;
                 try
                 {
-                    targetAssemblyName = getAssemblyName(pathToCandidateAssembly);
+                    targetAssemblyName = getAssemblyName(fullPathToCandidateAssembly);
                 }
                 catch (FileLoadException)
                 {
@@ -293,7 +299,7 @@ protected bool FileMatchesAssemblyName(
         /// <param name="isPrimaryProjectReference">True if this is a primary reference directly from the project file.</param>
         /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param>
         /// <param name="executableExtensions">The possible filename extensions of the assembly. Must be one of these or its no match.</param>
-        /// <param name="directory">the directory to look in</param>
+        /// <param name="fullPathToDirectory">Fully qualified path to the directory to look in</param>
         /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param>
         /// <returns>'null' if the assembly wasn't found.</returns>
         protected string ResolveFromDirectory(
@@ -301,7 +307,7 @@ protected string ResolveFromDirectory(
             bool isPrimaryProjectReference,
             bool wantSpecificVersion,
             string[] executableExtensions,
-            string directory,
+            string fullPathToDirectory,
             List<ResolutionSearchLocation> assembliesConsideredAndRejected)
         {
             if (assemblyName == null)
@@ -313,7 +319,7 @@ protected string ResolveFromDirectory(
             // used for the case when we are targeting MSIL and need to return that if it exists. This is different from targeting other architectures where returning an MSIL or target architecture are ok.
             string candidateFullPath = null;
 
-            if (directory != null)
+            if (fullPathToDirectory != null)
             {
                 string weakNameBase = assemblyName.Name;
                 foreach (string executableExtension in executableExtensions)
@@ -323,12 +329,12 @@ protected string ResolveFromDirectory(
 
                     try
                     {
-                        fullPath = Path.Combine(directory, baseName);
+                        fullPath = Path.Combine(fullPathToDirectory, baseName);
                     }
                     catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
                     {
                         // Assuming it's the search path that's bad. But combine them both so the error is visible if it's the reference itself.
-                        throw new InvalidParameterValueException("SearchPaths", directory + (directory.EndsWith("\\", StringComparison.OrdinalIgnoreCase) ? String.Empty : "\\") + baseName, e.Message);
+                        throw new InvalidParameterValueException("SearchPaths", fullPathToDirectory + (fullPathToDirectory.EndsWith("\\", StringComparison.OrdinalIgnoreCase) ? String.Empty : "\\") + baseName, e.Message);
                     }
 
                     // We have a full path returned
@@ -379,7 +385,7 @@ protected string ResolveFromDirectory(
                         {
                             if (String.Equals(executableExtension, weakNameBaseExtension, StringComparison.CurrentCultureIgnoreCase))
                             {
-                                string fullPath = Path.Combine(directory, weakNameBase);
+                                string fullPath = Path.Combine(fullPathToDirectory, weakNameBase);
                                 var extensionlessAssemblyName = new AssemblyNameExtension(weakNameBaseFileName);
 
                                 if (ResolveAsFile(fullPath, extensionlessAssemblyName, isPrimaryProjectReference, wantSpecificVersion, false, assembliesConsideredAndRejected))
diff --git a/src/Tasks/InstalledSDKResolver.cs b/src/Tasks/InstalledSDKResolver.cs
index b8f7d6a0b12..8583911aa33 100644
--- a/src/Tasks/InstalledSDKResolver.cs
+++ b/src/Tasks/InstalledSDKResolver.cs
@@ -21,13 +21,25 @@ internal class InstalledSDKResolver : Resolver
         /// </summary>
         private readonly Dictionary<string, ITaskItem> _resolvedSDKs;
 
+        /// <summary>
+        /// Cached absolute paths for resolved SDKs
+        /// </summary>
+        private readonly Dictionary<string, string> _resolvedSDKPaths;
+
         /// <summary>
         /// Construct.
         /// </summary>
-        public InstalledSDKResolver(Dictionary<string, ITaskItem> resolvedSDKs, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion)
-            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false)
+        public InstalledSDKResolver(Dictionary<string, ITaskItem> resolvedSDKs, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion, TaskEnvironment taskEnvironment)
+            : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
             _resolvedSDKs = resolvedSDKs;
+            _resolvedSDKPaths = new Dictionary<string, string>(resolvedSDKs.Count);
+            
+            // Cache absolute paths to avoid repeated TaskEnvironment.GetAbsolutePath calls
+            foreach (var kvp in resolvedSDKs)
+            {
+                _resolvedSDKPaths[kvp.Key] = taskEnvironment.GetAbsolutePath(kvp.Value.ItemSpec).GetCanonicalForm();
+            }
         }
 
         /// <inheritdoc/>
@@ -51,9 +63,8 @@ public override bool Resolve(
             if (assemblyName != null)
             {
                 // We have found a resolved SDK item that matches the one on the reference items.
-                if (_resolvedSDKs.TryGetValue(sdkName, out ITaskItem resolvedSDK))
+                if (_resolvedSDKs.TryGetValue(sdkName, out ITaskItem resolvedSDK) && _resolvedSDKPaths.TryGetValue(sdkName, out string sdkDirectory))
                 {
-                    string sdkDirectory = resolvedSDK.ItemSpec;
                     string configuration = resolvedSDK.GetMetadata("TargetedSDKConfiguration");
                     string architecture = resolvedSDK.GetMetadata("TargetedSDKArchitecture");
 

From 84ed710f674eadd9601dfbcb33b2674b72c2c2b0 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 12 Mar 2026 15:43:37 +0100
Subject: [PATCH 04/29] Enlighten GetReferenceAssemblyPaths

---
 src/Tasks/AssemblyDependency/GlobalAssemblyCache.cs | 12 ++++++++----
 src/Tasks/GetReferenceAssemblyPaths.cs              |  9 +++++++--
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/GlobalAssemblyCache.cs b/src/Tasks/AssemblyDependency/GlobalAssemblyCache.cs
index 1a6656c607d..772709798f0 100644
--- a/src/Tasks/AssemblyDependency/GlobalAssemblyCache.cs
+++ b/src/Tasks/AssemblyDependency/GlobalAssemblyCache.cs
@@ -238,6 +238,7 @@ private static string CheckForFullFusionNameInGac(AssemblyNameExtension assembly
         /// <param name="getPathFromFusionName">Delegate to get path to a file based on the fusion name.</param>
         /// <param name="getGacEnumerator">Delegate to get the enumerator which will enumerate over the GAC.</param>
         /// <param name="specificVersion">Whether to check for a specific version.</param>
+        /// <param name="taskEnvironment">TaskEnvironment for thread-safe operations.</param>
         /// <returns>The path to the assembly. Empty if none exists.</returns>
         internal static string GetLocation(
             AssemblyNameExtension strongName,
@@ -248,9 +249,10 @@ internal static string GetLocation(
             FileExists fileExists,
             GetPathFromFusionName getPathFromFusionName,
             GetGacEnumerator getGacEnumerator,
-            bool specificVersion)
+            bool specificVersion,
+            TaskEnvironment taskEnvironment)
         {
-            return GetLocation(null, strongName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fullFusionName, fileExists, getPathFromFusionName, getGacEnumerator, specificVersion);
+            return GetLocation(null, strongName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fullFusionName, fileExists, getPathFromFusionName, getGacEnumerator, specificVersion, taskEnvironment);
         }
 
         /// <summary>
@@ -266,6 +268,7 @@ internal static string GetLocation(
         /// <param name="getPathFromFusionName">Delegate to get path to a file based on the fusion name.</param>
         /// <param name="getGacEnumerator">Delegate to get the enumerator which will enumerate over the GAC.</param>
         /// <param name="specificVersion">Whether to check for a specific version.</param>
+        /// <param name="taskEnvironment">Optional TaskEnvironment for thread-safe environment variable access.</param>
         /// <returns>The path to the assembly. Empty if none exists.</returns>
         internal static string GetLocation(
             IBuildEngine4 buildEngine,
@@ -277,10 +280,11 @@ internal static string GetLocation(
             FileExists fileExists,
             GetPathFromFusionName getPathFromFusionName,
             GetGacEnumerator getGacEnumerator,
-            bool specificVersion)
+            bool specificVersion,
+            TaskEnvironment taskEnvironment)
         {
             ConcurrentDictionary<AssemblyNameExtension, string> fusionNameToResolvedPath = null;
-            bool useGacRarCache = Environment.GetEnvironmentVariable("MSBUILDDISABLEGACRARCACHE") == null;
+            bool useGacRarCache = taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEGACRARCACHE") == null;
             if (buildEngine != null && useGacRarCache)
             {
                 string key = $"44d78b60-3bbe-48fe-9493-04119ebf515f|{targetProcessorArchitecture}|{targetedRuntimeVersion}|{fullFusionName}|{specificVersion}";
diff --git a/src/Tasks/GetReferenceAssemblyPaths.cs b/src/Tasks/GetReferenceAssemblyPaths.cs
index 81b02cdf5a0..ee57ded0376 100644
--- a/src/Tasks/GetReferenceAssemblyPaths.cs
+++ b/src/Tasks/GetReferenceAssemblyPaths.cs
@@ -19,8 +19,13 @@ namespace Microsoft.Build.Tasks
     /// <summary>
     /// Returns the reference assembly paths to the various frameworks
     /// </summary>
-    public class GetReferenceAssemblyPaths : TaskExtension
+    [MSBuildMultiThreadableTask]
+    public class GetReferenceAssemblyPaths : TaskExtension, IMultiThreadableTask
     {
+        /// <summary>
+        /// Task environment for thread-safe operations.
+        /// </summary>
+        public TaskEnvironment TaskEnvironment { get; set; }
         #region Data
 #if FEATURE_GAC
         /// <summary>
@@ -175,7 +180,7 @@ public override bool Execute()
                         // get an assemblyname from the string representation of the sentinel assembly name
                         var sentinelAssemblyName = new AssemblyNameExtension(NET35SP1SentinelAssemblyName);
 
-                        string path = GlobalAssemblyCache.GetLocation(sentinelAssemblyName, SystemProcessorArchitecture.MSIL, runtimeVersion => "v2.0.50727", new Version("2.0.57027"), false, new FileExists(p => FileUtilities.FileExistsNoThrow(p)), GlobalAssemblyCache.pathFromFusionName, GlobalAssemblyCache.gacEnumerator, false);
+                        string path = GlobalAssemblyCache.GetLocation(sentinelAssemblyName, SystemProcessorArchitecture.MSIL, runtimeVersion => "v2.0.50727", new Version("2.0.57027"), false, new FileExists(p => FileUtilities.FileExistsNoThrow(p)), GlobalAssemblyCache.pathFromFusionName, GlobalAssemblyCache.gacEnumerator, false, TaskEnvironment);
                         s_net35SP1SentinelAssemblyFound = !String.IsNullOrEmpty(path);
                     }
 

From fdd2f52cf00949f2b0a79cada5ba1183964be92d Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 12 Mar 2026 16:49:38 +0100
Subject: [PATCH 05/29] Fix tests.

---
 .../AssemblyFoldersFromConfig_Tests.cs        |   6 +
 .../AssemblyDependency/FilePrimary.cs         |   8 +
 .../GlobalAssemblyCacheTests.cs               |  35 ++--
 .../InstalledSDKResolverFixture.cs            |   2 +
 .../AssemblyDependency/Miscellaneous.cs       | 162 +++++++++++++++++-
 .../Node/OutOfProcRarNode_Tests.cs            |   3 +
 .../Node/RarNodeExecuteRequest_Tests.cs       |  26 +--
 .../NonSpecificVersionStrictPrimary.cs        |   5 +
 .../AssemblyDependency/Perf.cs                |   2 +
 .../ResolveAssemblyReferenceTestFixture.cs    |   2 +-
 .../SpecificVersionPrimary.cs                 |   5 +
 .../StronglyNamedDependency.cs                |   6 +
 .../StronglyNamedDependencyAppConfig.cs       |  12 ++
 .../StronglyNamedDependencyAutoUnify.cs       |   7 +
 .../AssemblyDependency/SuggestedRedirects.cs  |  10 ++
 ...erifyIgnoreVersionForFrameworkReference.cs |   6 +
 .../VerifyTargetFrameworkAttribute.cs         |  13 ++
 .../VerifyTargetFrameworkHigherThanRedist.cs  |  18 ++
 .../AssemblyDependency/WinMDTests.cs          |  16 ++
 .../GetReferencePaths_Tests.cs                |   1 +
 src/Tasks.UnitTests/HintPathResolver_Tests.cs |   3 +-
 .../RARPrecomputedCache_Tests.cs              |  13 +-
 22 files changed, 320 insertions(+), 41 deletions(-)

diff --git a/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs b/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs
index fdda7956108..2f817537269 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs
@@ -45,6 +45,7 @@ public void AssemblyFoldersFromConfigTest()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig2") },
                     SearchPaths = new[] { moniker }
                 };
@@ -74,6 +75,7 @@ public void AssemblyFoldersFromConfigPlatformSpecificAssemblyFirstTest()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig_common.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "x86"
@@ -104,6 +106,7 @@ public void AssemblyFoldersFromConfigNormalizeNetFrameworkVersion()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("v5assembly.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "x86"
@@ -119,6 +122,7 @@ public void AssemblyFoldersFromConfigNormalizeNetFrameworkVersion()
                 t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("v5assembly.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "AMD64"
@@ -148,6 +152,7 @@ public void AssemblyFoldersFromConfigFileNotFoundTest()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig_common.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "x86"
@@ -176,6 +181,7 @@ public void AssemblyFoldersFromConfigFileMalformed()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = engine,
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig2") },
                     SearchPaths = new[] { moniker }
                 };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs b/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs
index 5f0d4ad6f1a..8f19ba248bb 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs
@@ -63,6 +63,7 @@ public void Exists()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -110,6 +111,7 @@ public void BadAppconfigOldVersion()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -161,6 +163,7 @@ public void BadAppconfigNewVersion()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -237,6 +240,7 @@ public void ExistsPromotedDependencyInTheDenyList()
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblyNames;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -293,6 +297,7 @@ public void ExistsDifferentName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -344,6 +349,7 @@ public void ExistsOldVersionRange()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -395,6 +401,7 @@ public void HighVersionDoesntExist()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -444,6 +451,7 @@ public void LowVersionDoesntExist()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/GlobalAssemblyCacheTests.cs b/src/Tasks.UnitTests/AssemblyDependency/GlobalAssemblyCacheTests.cs
index f320ee47e70..5bc84ab68b0 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/GlobalAssemblyCacheTests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/GlobalAssemblyCacheTests.cs
@@ -57,7 +57,7 @@ public void VerifySimpleNamev2057020()
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System");
 
 
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("2.0.57027"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, false);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("2.0.57027"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, false, TaskEnvironmentHelper.CreateForTest());
             Assert.NotNull(path);
             Assert.Equal(system2Path, path);
         }
@@ -82,7 +82,7 @@ public void VerifySimpleNamev2057020SpecificVersion()
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System");
 
 
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("2.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("2.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true, TaskEnvironmentHelper.CreateForTest());
             Assert.NotNull(path);
             Assert.Equal(system4Path, path);
         }
@@ -105,7 +105,7 @@ public void VerifyFusionNamev2057020SpecificVersion()
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, Version=2.0.0.0");
 
 
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("2.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("2.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true, TaskEnvironmentHelper.CreateForTest());
             Assert.NotNull(path);
             Assert.Equal(system2Path, path);
         }
@@ -128,7 +128,7 @@ public void VerifySimpleNamev40()
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System");
 
 
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("4.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, false);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("4.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, false, TaskEnvironmentHelper.CreateForTest());
             Assert.NotNull(path);
             Assert.Equal(system4Path, path);
         }
@@ -152,7 +152,7 @@ public void VerifySimpleNamev40SpecificVersion()
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System");
 
 
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("4.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("4.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true, TaskEnvironmentHelper.CreateForTest());
             Assert.NotNull(path);
             Assert.Equal(system4Path, path);
         }
@@ -173,7 +173,7 @@ public void VerifyFusionNamev40SpecificVersion()
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, Version=4.0.0.0");
 
 
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("4.0.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, _runtimeVersion, new Version("4.0.0.0"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true, TaskEnvironmentHelper.CreateForTest());
             Assert.NotNull(path);
             Assert.Equal(system4Path, path);
         }
@@ -187,7 +187,7 @@ public void VerifyEmptyPublicKeyspecificVersion()
             Assert.Throws<FileLoadException>(() =>
             {
                 AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=");
-                string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true);
+                string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true, TaskEnvironmentHelper.CreateForTest());
             });
         }
 
@@ -198,7 +198,7 @@ public void VerifyEmptyPublicKeyspecificVersion()
         public void VerifyNullPublicKey()
         {
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=null");
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, false);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, false, TaskEnvironmentHelper.CreateForTest());
             Assert.Null(path);
         }
 
@@ -209,7 +209,7 @@ public void VerifyNullPublicKey()
         public void VerifyNullPublicKeyspecificVersion()
         {
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=null");
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.None, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, _gacEnumerator, true, TaskEnvironmentHelper.CreateForTest());
             Assert.Null(path);
         }
 
@@ -222,7 +222,7 @@ public void VerifyNullPublicKeyspecificVersion()
         public void VerifyProcessorArchitectureDoesNotCrash()
         {
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=b77a5c561934e089, ProcessorArchitecture=MSIL");
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, false);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, false, TaskEnvironmentHelper.CreateForTest());
             Assert.Null(path);
         }
 
@@ -234,7 +234,7 @@ public void VerifyProcessorArchitectureDoesNotCrash()
         public void VerifyProcessorArchitectureDoesNotCrashSpecificVersion()
         {
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=b77a5c561934e089, ProcessorArchitecture=MSIL");
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), false, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, true, TaskEnvironmentHelper.CreateForTest());
             Assert.Null(path);
         }
 
@@ -246,7 +246,7 @@ public void VerifyProcessorArchitectureDoesNotCrashSpecificVersion()
         public void VerifyProcessorArchitectureDoesNotCrashFullFusionName()
         {
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=b77a5c561934e089, ProcessorArchitecture=MSIL");
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), true, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, false);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), true, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, false, TaskEnvironmentHelper.CreateForTest());
             Assert.Null(path);
         }
 
@@ -258,7 +258,7 @@ public void VerifyProcessorArchitectureDoesNotCrashFullFusionName()
         public void VerifyProcessorArchitectureDoesNotCrashFullFusionNameSpecificVersion()
         {
             AssemblyNameExtension fusionName = new AssemblyNameExtension("System, PublicKeyToken=b77a5c561934e089, ProcessorArchitecture=MSIL");
-            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), true, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, true);
+            string path = GlobalAssemblyCache.GetLocation(fusionName, SystemProcessorArchitecture.MSIL, getRuntimeVersion, new Version("2.0.50727"), true, new FileExists(MockFileExists), _getPathFromFusionName, null /* use the real gac enumerator*/, true, TaskEnvironmentHelper.CreateForTest());
             Assert.Null(path);
         }
 
@@ -272,6 +272,7 @@ public void SystemRuntimeDepends_No_Build()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -341,6 +342,7 @@ public void SystemRuntimeDepends_Yes()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -408,6 +410,7 @@ public void SystemRuntimeDepends_Yes_Indirect()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -474,6 +477,7 @@ public void SystemRuntimeDepends_Yes_Indirect_ExternallyResolved()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -538,6 +542,7 @@ public void NETStandardDepends_Yes()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -602,6 +607,7 @@ public void NETStandardDepends_Yes_Indirect()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -667,6 +673,7 @@ public void NETStandardDepends_Yes_Indirect_ExternallyResolved()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -732,6 +739,7 @@ public void DependsOn_NETStandard_and_SystemRuntime()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -800,6 +808,7 @@ public void DependsOn_NETStandard_and_SystemRuntime_ExternallyResolved()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
diff --git a/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs b/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs
index cdacfae192e..9f6cd2d2086 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs
@@ -38,6 +38,7 @@ public void SDkNameNotInResolvedSDKListButOnSearchPath()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.SearchPaths = new String[] { @"C:\FakeSDK\References" };
             bool succeeded = Execute(t);
@@ -84,6 +85,7 @@ private static void ResolveSDKFromRefereneAssemblyLocation(string referenceName,
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.ResolvedSDKReferences = new ITaskItem[] { resolvedSDK };
             t.SearchPaths = new String[] { @"C:\SomeOtherPlace" };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
index 669d367e140..b54d67c2b05 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
@@ -107,6 +107,7 @@ public void VerifyPrimaryReferenceToBadImageDoesNotThrow()
             ITaskItem xpdb = new TaskItem(Path.Combine(s_myComponentsRootPath, "X.pdb"));
             ResolveAssemblyReference t = new()
             {
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 BuildEngine = new MockEngine(),
                 AllowedRelatedFileExtensions = new string[] { ".pdb" },
                 Assemblies = new ITaskItem[] { xpdb },
@@ -142,6 +143,7 @@ public void CopyLocalDependenciesWhenParentReferenceInGacFalseAllParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -180,6 +182,7 @@ public void ValidateFrameworkNameError()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = new string[] { s_myComponentsRootPath };
             t.TargetFrameworkMoniker = "I am a random frameworkName";
@@ -218,6 +221,7 @@ public void CopyLocalDependenciesWhenParentReferenceInGacFalseSomeParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -279,6 +283,7 @@ public void CopyLocalDependenciesWhenParentReferenceInGacTrueAllParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -328,6 +333,7 @@ public void CopyLocalDependenciesWhenParentReferenceInGacTrueSomeParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -370,6 +376,7 @@ public void CopyLocalDependenciesWhenParentReferenceNotInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = new string[] { "{gac}", @"c:\MyComponents" };
             bool succeeded = Execute(t);
@@ -407,6 +414,7 @@ public void CopyLocalLegacyBehavior()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.DoNotCopyLocalIfInGac = true;
             t.SearchPaths = new string[] { @"c:\MyComponents", "{gac}", };
@@ -467,6 +475,7 @@ public void Basic()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
@@ -755,6 +764,7 @@ public void EmbedInteropTypes()
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblies;
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
@@ -810,6 +820,7 @@ public void NOPForEmptyItemLists()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
 
@@ -843,6 +854,7 @@ public void DefaultAllowedRelatedFileExtensionsAreUsed()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -907,6 +919,7 @@ public void RelatedFilesAreNotFoundForExternallyResolvedReferences(bool findDepe
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -942,6 +955,7 @@ public void InputAllowedRelatedFileExtensionsAreUsed()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -988,6 +1002,7 @@ private void SimulateCreateProjectAgainstWhidbeyInternal(string fxfolder)
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("System"),
                 new TaskItem("System.Deployment"),
@@ -1040,6 +1055,7 @@ public void Regress286699_InvalidCandidateAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.CandidateAssemblyFiles = new string[] { "|" };
@@ -1060,6 +1076,7 @@ public void Regress286699_InvalidAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.AssemblyFiles = new ITaskItem[] { new TaskItem("|") };
@@ -1080,6 +1097,7 @@ public void Regress286699_InvalidAssembliesParameter()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("|!@#$%::") };
 
@@ -1105,6 +1123,7 @@ public void Regress286699_InvalidTargetFrameworkDirectory()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.TargetFrameworkDirectories = new string[] { "\nc:\\blah\\v2.0.1234" };
 
@@ -1124,6 +1143,7 @@ public void Regress286699_InvalidSearchPath()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.SearchPaths = new string[] { "|" };
@@ -1144,6 +1164,7 @@ public void Regress286699_InvalidAppConfig()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.AppConfigFile = "|";
@@ -1164,6 +1185,7 @@ public void NonExistentReference()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("System.Xml"), new TaskItem("System.Nonexistent")
             };
@@ -1194,6 +1216,7 @@ public void StrongWeakMismatchInDependency()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("DependsOnSimpleA")
@@ -1218,6 +1241,7 @@ public void DependenciesOfExternallyResolvedReferencesAreNotSearched()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("DependsOnSimpleA")
@@ -1245,6 +1269,7 @@ public void UseSuppliedHintPath()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem i = new TaskItem("My.Assembly");
 
@@ -1273,6 +1298,7 @@ public void Regress200872()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.SearchPaths = new string[]
@@ -1296,6 +1322,7 @@ public void AssemblyFoldersExBasic()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyGrid") };
             t.SearchPaths = DefaultPaths;
@@ -1316,6 +1343,7 @@ public void AssemblyFoldersExVerifyComponentFolderSorting()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("CustomComponent") };
             t.SearchPaths = DefaultPaths;
@@ -1337,6 +1365,7 @@ public void AssemblyFoldersExTargetFrameworkVersionDoesNotBeginWithV()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyGrid") };
             t.SearchPaths = new string[] { @"{Registry:Software\Microsoft\.NetFramework,2.0,AssemblyFoldersEx}" };
@@ -1361,6 +1390,7 @@ public void AssemblyFoldersExProcessorArchDoesNotMatch()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1386,6 +1416,7 @@ public void AssemblyFoldersExProcessorArchMSILX86()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1408,6 +1439,7 @@ public void VerifyProcessArchitectureMismatchWarning()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A"), new TaskItem("B") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1432,6 +1464,7 @@ public void VerifyProcessArchitectureMismatchWarningDefault()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A"), new TaskItem("B") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1455,6 +1488,7 @@ public void VerifyProcessArchitectureMismatchError()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A"), new TaskItem("B") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1482,6 +1516,7 @@ public void AssemblyFoldersExProcessorArchNoneX86()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1502,6 +1537,7 @@ public void AssemblyFoldersExProcessorArchNoneMix()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MIX}" };
@@ -1530,6 +1566,7 @@ public void AssemblyFoldersExProcessorArchMSILLastFolder()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,AssemblyFoldersEx}" };
@@ -1555,6 +1592,7 @@ public void AssemblyFoldersExProcessorArchNoneLastFolder()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,AssemblyFoldersEx}" };
@@ -1579,6 +1617,7 @@ public void AssemblyFoldersExProcessorArchX86FirstFolder()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,AssemblyFoldersEx}" };
@@ -1602,6 +1641,7 @@ public void AssemblyFoldersExProcessorArchX86MSIL()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MSIL}" };
@@ -1624,6 +1664,7 @@ public void AssemblyFoldersExProcessorArchX86None()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,None}" };
@@ -1646,6 +1687,7 @@ public void AssemblyFoldersExProcessorArchNoneNone()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,None}" };
@@ -1667,6 +1709,7 @@ public void AssemblyFoldersExProcessorArcMSILNone()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,None}" };
@@ -1688,6 +1731,7 @@ public void AssemblyFoldersExProcessorArchNoneMSIL()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MSIL}" };
@@ -1710,6 +1754,7 @@ public void AssemblyFoldersExProcessorArchMSILMSIL()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MSIL}" };
@@ -1732,6 +1777,7 @@ public void AssemblyFoldersExProcessorArchMatches()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1756,6 +1802,7 @@ public void AssemblyFoldersExTargetFrameworkVersionBogusValue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem assemblyToResolve = new TaskItem("MyGrid");
             assemblyToResolve.SetMetadata("HintPath", @"C:\MyComponents\MyGrid.dll");
@@ -1777,6 +1824,7 @@ public void Regress357227_AssemblyFoldersExAgainstRawDrop()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyRawDropControl") };
             t.SearchPaths = DefaultPaths;
@@ -1797,6 +1845,7 @@ public void AssemblyFoldersExHKLM()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyHKLMControl") };
             t.SearchPaths = DefaultPaths;
@@ -1821,6 +1870,7 @@ public void AssemblyFoldersExHKCUTrumpsHKLM()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyHKLMandHKCUControl") };
             t.SearchPaths = DefaultPaths;
@@ -1840,6 +1890,7 @@ public void AssemblyFoldersExFutureTargetNDPVersionsDontMatch()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyControlWithFutureTargetNDPVersion") };
             t.SearchPaths = DefaultPaths;
@@ -1859,6 +1910,7 @@ public void AssemblyFoldersExMatchBackVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyNDP1Control") };
             t.SearchPaths = DefaultPaths;
@@ -1878,6 +1930,7 @@ public void AssemblyFoldersExCurrentTargetVersionTrumpsPastTargetVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyControlWithPastTargetNDPVersion") };
             t.SearchPaths = DefaultPaths;
@@ -1897,6 +1950,7 @@ public void AssemblyFoldersExServicePackTrumpsBaseVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyControlWithServicePack") };
             t.SearchPaths = DefaultPaths;
@@ -1922,6 +1976,7 @@ public void AssemblyFoldersExConditionFilterMaxOS()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyDeviceControlAssembly") };
             t.SearchPaths = new string[]
@@ -1960,6 +2015,7 @@ public void AssemblyFoldersExConditionFilterMinOS()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyDeviceControlAssembly") };
             t.SearchPaths = new string[]
@@ -2273,6 +2329,7 @@ public void AssemblyFoldersExConditionFilterPlatform()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyDeviceControlAssembly") };
             t.SearchPaths = new string[]
@@ -2348,6 +2405,7 @@ public void CandidateAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("System.XML") };
             t.SearchPaths = new string[] { "{CandidateAssemblyFiles}" };
@@ -2368,6 +2426,7 @@ public void ThreePartVersionNumberRequiredFrameworkHigherThanTargetFramework()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             TaskItem item = new TaskItem("System.XML");
             item.SetMetadata("RequiredTargetFramework", "v4.0.255");
             t.Assemblies = new ITaskItem[] { item };
@@ -2388,6 +2447,7 @@ public void ThreePartVersionNumberRequiredFrameworkLowerThanTargetFramework()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             TaskItem item = new TaskItem("System.XML");
             item.SetMetadata("RequiredTargetFramework", "v4.0.255");
             t.Assemblies = new ITaskItem[] { item };
@@ -2410,6 +2470,7 @@ public void Regress242970()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("System.XML") };
             t.SearchPaths = new string[] { "{CandidateAssemblyFiles}" };
@@ -2452,6 +2513,7 @@ public void RawFileName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(Path.Combine(s_myVersion20Path, "System.Xml.dll")) };
             t.SearchPaths = new string[]
@@ -2944,6 +3006,7 @@ public void RawFileNameRelative()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             string testPath = Path.Combine(Path.GetTempPath(), @"RawFileNameRelative");
             string previousCurrentDirectory = Directory.GetCurrentDirectory();
@@ -2980,6 +3043,7 @@ public void RelativeDirectoryResolver()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             string testPath = Path.Combine(Path.GetTempPath(), @"RawFileNameRelative");
             string previousCurrentDirectory = Directory.GetCurrentDirectory();
@@ -3015,6 +3079,7 @@ public void HintPathRelative()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             string testPath = Path.Combine(Path.GetTempPath(), @"RawFileNameRelative");
             string previousCurrentDirectory = Directory.GetCurrentDirectory();
@@ -3052,6 +3117,7 @@ public void RawFileNameWithSpecificVersionFalse()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem taskItem = new TaskItem(Path.Combine(s_myVersion20Path, "System.Xml.dll"));
             taskItem.SetMetadata("SpecificVersion", "false");
@@ -3077,6 +3143,7 @@ public void RawFileNameWithSpecificVersionTrue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem taskItem = new TaskItem(Path.Combine(s_myVersion20Path, "System.Xml.dll"));
             taskItem.SetMetadata("SpecificVersion", "true");
@@ -3102,6 +3169,7 @@ public void Regress363340_RawFileNameMissing()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3132,6 +3200,7 @@ public void Regress444793()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             TaskItem item = new TaskItem(@"c:\DoesntExist\System.Xml.dll");
             item.SetMetadata("HintPath", Path.Combine(s_myVersion20Path, "System.Data.dll"));
@@ -3161,6 +3230,7 @@ public void RawFileNameDoesntExist()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(@"c:\DoesntExist\System.Xml.dll") };
             t.SearchPaths = new string[] { "{RawFileName}" };
@@ -3180,6 +3250,7 @@ public void CandidateAssemblyFilesDifferentBaseName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("VendorAssembly") };
             t.SearchPaths = new string[] { "{CandidateAssemblyFiles}" };
@@ -3199,6 +3270,7 @@ public void ResolveToGAC()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("System") };
             t.TargetedRuntimeVersion = typeof(Object).Assembly.ImageRuntimeVersion;
@@ -3217,6 +3289,7 @@ public void ResolveToGACSpecificVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             TaskItem item = new TaskItem("System");
             item.SetMetadata("SpecificVersion", "true");
@@ -3279,6 +3352,7 @@ public void ResolveBadImageInPrimary()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("BadImage")
@@ -3320,6 +3394,7 @@ public void ResolveBadImageInSecondary()
 
             MockEngine engine = new MockEngine(true);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3358,6 +3433,7 @@ public void ResolveReferenceThatHasWrongPKTInEarlierAssembly()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(AssemblyRef.SystemData) };
             t.SearchPaths = new string[]
@@ -3381,6 +3457,7 @@ public void PrimaryFXAssemblyRefIsNotCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(AssemblyRef.SystemData) };
             t.SearchPaths = new string[]
@@ -3424,6 +3501,7 @@ public void PrivateItemInFrameworksGetsCopyLocalTrue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -3450,6 +3528,7 @@ public void NoFrameworkDirectoriesStillCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = Array.Empty<string>();
             t.SearchPaths = new string[] { "{RawFileName}" };
@@ -3478,6 +3557,7 @@ public void Regress284485_PrivateItemWithBogusValue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -3512,6 +3592,7 @@ public void ConflictBetweenCopyLocalDependenciesRegress444809()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("A, Version=2.0.0.0, Culture=Neutral, PublicKeyToken=null"), new TaskItem("C, Version=1.0.0.0, Culture=Neutral, PublicKeyToken=null")
@@ -3557,6 +3638,7 @@ public void ConflictBetweenCopyLocalDependenciesRegress444809UnResolvedPrimaryRe
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("A, Version=20.0.0.0, Culture=Neutral, PublicKeyToken=null"),
@@ -3598,6 +3680,7 @@ public void ConflictGeneratesMessageReferencingAssemblyName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3630,6 +3713,7 @@ public void ConflictOutputsExtraInformationOnDemand()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3673,6 +3757,7 @@ public void ConflictGeneratesMessageReferencingEachConflictingAssemblyName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3724,6 +3809,7 @@ public void ConflictWithForeVersionPrimary()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3766,6 +3852,7 @@ public void ConflictBetweenBackAndForeVersionsCopyLocal()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3804,6 +3891,7 @@ public void ConflictBetweenBackAndForeVersionsNotCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3840,6 +3928,7 @@ public void ConflictingDependenciesWithNonMatchingNames()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3875,6 +3964,7 @@ public void ConflictingDependenciesWithNonMatchingNamesAndHardReferenceInProject
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3904,6 +3994,7 @@ public void SpecificVersionFalse()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3929,6 +4020,7 @@ public void SpecificVersionTrue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem(@"System.XML, Version=9.9.9999.9, Culture=neutral, PublicKeyToken=abababababababab")
@@ -3952,6 +4044,7 @@ public void SpecificVersionAbsent()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem(@"System.XML, Version=9.9.9999.9, Culture=neutral, PublicKeyToken=abababababababab")
@@ -3973,6 +4066,7 @@ public void Regress199998()
 
             MockEngine m = new MockEngine(_output);
             t.BuildEngine = m;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4006,6 +4100,7 @@ public void ExecutableExtensionEXE()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4045,6 +4140,7 @@ public void ExecutableExtensionDLL()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4085,6 +4181,7 @@ public void ExecutableExtensionDefaultDLLFirst()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4123,6 +4220,7 @@ public void ExecutableExtensionDefaultEXEFirst()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4164,6 +4262,7 @@ public void SimpleNameWithSpecificVersionTrue()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4202,6 +4301,7 @@ public void SimpleNameWithSpecificVersionFalse()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4239,6 +4339,7 @@ public void IrrelevantAssemblyNameElement()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4289,6 +4390,7 @@ public void RegressQFE626()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4349,6 +4451,7 @@ public void Regress265054()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4412,6 +4515,7 @@ public void Regress312873_UnresolvedPrimaryWithResolveDependency()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4454,6 +4558,7 @@ public void Regress275161_ScatterAssemblies()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4506,6 +4611,7 @@ public void Regress317975_LeftoverLowerVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4558,6 +4664,7 @@ public void Regress313086_Part1_MscorlibAsRawFilename()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4599,6 +4706,7 @@ public void Regress313086_Part2_MscorlibAsRawFilename()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4636,6 +4744,7 @@ public void Regress284466_DirectoryIntoAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
 
@@ -4674,6 +4783,7 @@ public void RelativeAssemblyFiles()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
 
@@ -4704,6 +4814,7 @@ public void Regress316906_UnauthorizedAccessViolation_PrimaryReferenceIsInaccess
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4735,6 +4846,7 @@ public void Regress316906_UnauthorizedAccessViolation_PrimaryFileIsInaccessible(
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.AssemblyFiles = new ITaskItem[]
             {
@@ -4758,6 +4870,7 @@ public void Regress316906_UnauthorizedAccessViolation_PrimaryAsRawFileIsInaccess
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4782,6 +4895,7 @@ public void Regress269704_MissingRegistryElements()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4825,6 +4939,7 @@ public void Regress276548_AssemblyNameDifferentThanFusionName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4859,6 +4974,7 @@ public void Regress314573_VeryLongPaths()
 
             MockEngine e = new (_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = [new TaskItem("A")]; // Resolved by HintPath
             t.Assemblies[0].SetMetadata(
@@ -4886,6 +5002,7 @@ public void Regress265003_EscapedCharactersInFusionName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4922,6 +5039,7 @@ public void Regress284081_UnescapedCharactersInFusionNameWithHintPath()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4958,6 +5076,7 @@ public void Regress366322_ReferencesWithFileExtensions()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4987,6 +5106,7 @@ public void Regress366814_MultipleFrameworksFolders()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5033,6 +5153,7 @@ public void Regress271273_BogusAppConfig()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -5056,6 +5177,7 @@ public void Regress354669_HintPathWithTrailingSlash()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5096,6 +5218,7 @@ public void Regress339786_CrossVersionsWithAppConfig()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5140,6 +5263,7 @@ public void Regress_DogfoodCLRThrowsFileLoadException()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5165,6 +5289,7 @@ public void Regress407623_RedistListDoesNotImplyPresenceInFrameworks()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5214,6 +5339,7 @@ public void InvalidCharsInInstalledAssemblyTable()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5247,6 +5373,7 @@ public void Regress435487_FxFileResolvedByHintPathShouldByCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5348,6 +5475,7 @@ public void Regress46599_BogusInGACValueForAssemblyInRedistList()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5399,6 +5527,7 @@ public void VerifyFrameworkFileMetadataFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5825,6 +5954,7 @@ public void RedistListNoAssembliesinRedistList()
             string microsoftBuildEnginePath = Path.Combine(ObjectModelHelpers.TempProjectDir, "v3.5\\Microsoft.Build.Engine.dll");
             string systemXmlPath = Path.Combine(ObjectModelHelpers.TempProjectDir, "v3.5\\System.Xml.dll");
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -6192,6 +6322,7 @@ public void IgnoreDefaultInstalledAssemblyTables()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -6327,6 +6458,7 @@ public void ReferenceTablePrimaryItemInDenyList()
             MockEngine mockEngine = new MockEngine(_output);
             ResolveAssemblyReference rar = new ResolveAssemblyReference();
             rar.BuildEngine = mockEngine;
+            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ReferenceTable referenceTable = MakeEmptyReferenceTable(rar.Log);
             Dictionary<AssemblyNameExtension, Reference> table = referenceTable.References;
@@ -6366,6 +6498,7 @@ public void ReferenceTablePrimaryItemInDenyListSpecificVersionTrue()
             MockEngine mockEngine = new MockEngine(_output);
             ResolveAssemblyReference rar = new ResolveAssemblyReference();
             rar.BuildEngine = mockEngine;
+            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ReferenceTable referenceTable = MakeEmptyReferenceTable(rar.Log);
             Dictionary<AssemblyNameExtension, Reference> table = referenceTable.References;
@@ -6443,6 +6576,7 @@ public void ReferenceTablePrimaryItemInDenyListRemoveOnlyNoWarn()
             MockEngine mockEngine = new MockEngine(_output);
             ResolveAssemblyReference rar = new ResolveAssemblyReference();
             rar.BuildEngine = mockEngine;
+            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ReferenceTable referenceTable = MakeEmptyReferenceTable(rar.Log);
             Dictionary<AssemblyNameExtension, Reference> table = referenceTable.References;
@@ -6703,7 +6837,7 @@ public void ReferenceTableDependentItemsInDenyList4()
 #if FEATURE_WIN32_REGISTRY
                 null, null, null,
 #endif
-                null, null, null, new Version("4.0"), null, null, null, true, false, null, null, false, null, WarnOrErrorOnTargetArchitectureMismatchBehavior.None, false, false, null, Array.Empty<string>());
+                null, null, null, new Version("4.0"), null, null, null, true, false, null, null, false, null, WarnOrErrorOnTargetArchitectureMismatchBehavior.None, false, false, null, Array.Empty<string>(), TaskEnvironmentHelper.CreateForTest());
             MockEngine mockEngine;
             ResolveAssemblyReference rar;
             Dictionary<string, string> denyList;
@@ -6881,7 +7015,7 @@ private static ReferenceTable MakeEmptyReferenceTable(TaskLoggingHelper log)
 #if FEATURE_WIN32_REGISTRY
                 null, null, null,
 #endif
-                null, null, new Version("4.0"), null, log, null, true, false, null, null, false, null, WarnOrErrorOnTargetArchitectureMismatchBehavior.None, false, false, null, Array.Empty<string>());
+                null, null, new Version("4.0"), null, log, null, true, false, null, null, false, null, WarnOrErrorOnTargetArchitectureMismatchBehavior.None, false, false, null, Array.Empty<string>(), TaskEnvironmentHelper.CreateForTest());
             return referenceTable;
         }
 
@@ -7013,6 +7147,7 @@ private static void InitializeRARwithMockEngine(ITestOutputHelper output, out Mo
         {
             mockEngine = new MockEngine(output);
             rar = new ResolveAssemblyReference();
+            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             rar.BuildEngine = mockEngine;
         }
 
@@ -7050,6 +7185,7 @@ private void InitializeMockEngine(out ReferenceTable referenceTable, out MockEng
         {
             mockEngine = new MockEngine(_output);
             rar = new ResolveAssemblyReference();
+            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             rar.BuildEngine = mockEngine;
 
             referenceTable = MakeEmptyReferenceTable(rar.Log);
@@ -7104,6 +7240,7 @@ public void IgnoreDefaultInstalledSubsetTables()
                 string explicitSubsetListPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("v3.5\\SubsetList\\ExplicitList.xml", _xmlOnlySubset);
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}" };
 
@@ -7188,6 +7325,7 @@ public void NoClientSubsetButInstalledSubTables()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}" };
@@ -7269,6 +7407,7 @@ public void FakeSubsetListPathsNoAdditionalSubsets()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}" };
@@ -7309,6 +7448,7 @@ public void ResolveAssemblyReferenceVerifyFullClientName()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("System.Xml") };
@@ -7342,6 +7482,7 @@ public void ResolveAssemblyReferenceVerifyFullClientNameWithSubsetTables()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("System.Xml") };
 
@@ -7377,6 +7518,7 @@ public void ResolveAssemblyReferenceVerifyFullClientNameNoTablesPassedIn()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("System.Xml") };
 
@@ -7408,6 +7550,7 @@ public void DoNotAssumeFilesDescribedByRedistListExistOnDisk()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = new MockEngine(_output);
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 t.Assemblies = new ITaskItem[]
             {
@@ -7492,6 +7635,7 @@ public void Regress397129_HandleInvalidDirectoriesAndFiles_Case1()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7524,6 +7668,7 @@ public void Regress397129_HandleInvalidDirectoriesAndFiles_Case2()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7565,6 +7710,7 @@ public void ByDesignRelatedTo454863_PrimaryReferencesDontResolveToParentFolders(
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7591,6 +7737,7 @@ public void Regress393931_AllowAlternateAssemblyExtensions_Case1()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7622,6 +7769,7 @@ public void Regress393931_AllowAlternateAssemblyExtensions()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7650,6 +7798,7 @@ public void SGenDependeicies()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new TaskItem[]
             {
@@ -7693,6 +7842,7 @@ public void Regress315619_TwoWeaklyNamedPrimariesIsInsoluble()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.AssemblyFiles = new ITaskItem[]
             {
@@ -7732,6 +7882,7 @@ public void ForwardRedistRoot()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7783,6 +7934,7 @@ private int RunTargetFrameworkFilteringTest(string projectTargetFramework)
         {
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("A"),
@@ -8147,6 +8299,7 @@ public void Verifyp2pAndProfile()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = new ITaskItem[] { new TaskItem(Path.Combine(s_myComponentsMiscPath, "DependsOn9Also.dll")) };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}", fullFrameworkDirectory };
                 t.TargetFrameworkDirectories = new string[] { targetFrameworkDirectory };
@@ -8195,6 +8348,7 @@ public void Verifyp2pAndProfile2()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 TaskItem item = new TaskItem(Path.Combine(s_myComponentsMiscPath, "DependsOn9Also.dll"));
                 item.SetMetadata("SpecificVersion", "true");
                 t.AssemblyFiles = new ITaskItem[] { item };
@@ -8237,6 +8391,7 @@ public void VerifyClientProfileRedistListAndProfileList()
                 GenerateRedistAndProfileXmlLocations(_fullRedistListContents, _engineOnlySubset, out profileRedistList, out fullRedistList, fullFrameworkDirectory, targetFrameworkDirectory);
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
@@ -8284,6 +8439,7 @@ public void VerifyClientProfileRedistListAndProfileList2()
                 GenerateRedistAndProfileXmlLocations(_fullRedistListContents, _engineOnlySubset, out profileRedistList, out fullRedistList, fullFrameworkDirectory, targetFrameworkDirectory);
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
@@ -8340,6 +8496,7 @@ public void VerifyAssemblyInGacButNotInProfileIsNotResolved()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 TaskItem item = new TaskItem(@"DependsOnOnlyv4Assemblies, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089");
                 t.Assemblies = new ITaskItem[] { item };
                 t.SearchPaths = new string[] { s_myComponents40ComponentPath, "{GAC}" };
@@ -8392,6 +8549,7 @@ public void VerifyProfileErrorsAreLogged()
                 GenerateRedistAndProfileXmlLocations(fullRedistListContentsErrors, _engineOnlySubset, out profileRedistList, out fullRedistList, fullFrameworkDirectory, targetFrameworkDirectory);
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs b/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs
index d3427ddeb7f..80d7f9b51ae 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs
@@ -35,6 +35,7 @@ public void RunsOutOfProcIfAllFlagsAreEnabled()
             {
                 AllowOutOfProcNode = true,
                 BuildEngine = engine,
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System")],
                 SearchPaths = [Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)],
             };
@@ -74,6 +75,7 @@ public void SkipsOutOfProcNodeIfAnyFlagIsDisabled(bool buildEngineFlag, bool tas
             {
                 AllowOutOfProcNode = taskInputFlag,
                 BuildEngine = engine,
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System")],
                 SearchPaths = [Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)],
             };
@@ -100,6 +102,7 @@ public void FallsBackToInProcTaskIfClientFailsToConnect()
             {
                 AllowOutOfProcNode = true,
                 BuildEngine = engine,
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System")],
                 SearchPaths = [Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)],
             };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs b/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs
index c2e2a2a55d2..5dbfd1dbc1e 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs
@@ -21,6 +21,7 @@ public void TaskInputsArePropagated()
             ResolveAssemblyReference clientRar = new()
             {
                 BuildEngine = new MockEngine(),
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System"), new TaskItem("System.IO")],
                 AssemblyFiles = [],
                 AllowedAssemblyExtensions = [".dll", ".exe"],
@@ -57,26 +58,6 @@ public void TaskInputsArePropagated()
             Assert.Equal(clientRar.StateFile, nodeRar.StateFile);
         }
 
-        [Fact]
-        public void KnownRelativePathsAreResolvedToFullPaths()
-        {
-            const string AppConfigFileName = "App.config";
-            const string StateFileName = "AssemblyReference.cache";
-            ResolveAssemblyReference clientRar = new()
-            {
-                BuildEngine = new MockEngine(),
-                AppConfigFile = AppConfigFileName,
-                StateFile = StateFileName,
-            };
-            RarNodeExecuteRequest request = new(clientRar);
-
-            ResolveAssemblyReference nodeRar = new();
-            request.SetTaskInputs(nodeRar, CreateBuildEngine());
-
-            Assert.Equal(Path.GetFullPath(AppConfigFileName), nodeRar.AppConfigFile);
-            Assert.Equal(Path.GetFullPath(StateFileName), nodeRar.StateFile);
-        }
-
         [Fact]
         public void BuildEngineSettingsArePropagated()
         {
@@ -85,10 +66,10 @@ public void BuildEngineSettingsArePropagated()
                 MinimumMessageImportance = MessageImportance.Normal,
                 SetIsTaskInputLoggingEnabled = false,
             };
-            ResolveAssemblyReference clientRar = new() { BuildEngine = mockEngine };
+            ResolveAssemblyReference clientRar = new() { BuildEngine = mockEngine, TaskEnvironment = TaskEnvironmentHelper.CreateForTest() };
             RarNodeExecuteRequest request = new(clientRar);
 
-            ResolveAssemblyReference nodeRar = new();
+            ResolveAssemblyReference nodeRar = new() { TaskEnvironment = TaskEnvironmentHelper.CreateForTest() };
             request.SetTaskInputs(nodeRar, CreateBuildEngine());
 
             Assert.Equal(mockEngine.LineNumberOfTaskNode, nodeRar.BuildEngine.LineNumberOfTaskNode);
@@ -112,6 +93,7 @@ public void OutOfProcExecutionFlagsAreDisabledOnHydrate()
             ResolveAssemblyReference clientRar = new()
             {
                 BuildEngine = mockEngine,
+                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 AllowOutOfProcNode = true,
             };
             RarNodeExecuteRequest request = new(clientRar);
diff --git a/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs b/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs
index 230080b2f31..7cce7c55f21 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs
@@ -66,6 +66,7 @@ public void Exists()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -118,6 +119,7 @@ public void ExistsDifferentName()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -171,6 +173,7 @@ public void ExistsOldVersionRange()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -223,6 +226,7 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -275,6 +279,7 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Perf.cs b/src/Tasks.UnitTests/AssemblyDependency/Perf.cs
index 57cea08b129..12fd350e03d 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Perf.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Perf.cs
@@ -71,6 +71,7 @@ public void DependeeDirectoryIsProbedForDependency()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblyNames;
                 t.SearchPaths = new[] { "{RawFileName}" };
                 t.AutoUnify = true;
@@ -116,6 +117,7 @@ public void DependeeDirectoryShouldNotBeProbedForDependencyWhenDependencyResolve
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblyNames;
                 t.SearchPaths = new[] { "{RawFileName}" };
                 t.AutoUnify = true;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs b/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs
index e6b39fd0e94..55c9fda8ee7 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs
@@ -810,7 +810,7 @@ private static string GetPathForAssemblyInGac(AssemblyNameExtension assemblyName
 #if FEATURE_GAC
                 if (assemblyName.Version != null)
                 {
-                    gacLocation = GlobalAssemblyCache.GetLocation(assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fullFusionName, fileExists, null, null, specificVersion /* this value does not matter if we are passing a full fusion name*/);
+                    gacLocation = GlobalAssemblyCache.GetLocation(assemblyName, targetProcessorArchitecture, getRuntimeVersion, targetedRuntimeVersion, fullFusionName, fileExists, null, null, specificVersion /* this value does not matter if we are passing a full fusion name*/, TaskEnvironmentHelper.CreateForTest());
                 }
 #endif
                 return gacLocation;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs b/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs
index c11fc53cfcc..b8b31c2c75b 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs
@@ -63,6 +63,7 @@ public void Exists()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -127,6 +128,7 @@ public void ExistsDifferentName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -177,6 +179,7 @@ public void ExistsOldVersionRange()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -229,6 +232,7 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -281,6 +285,7 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs
index 1ef6412f355..48429ecc1c0 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs
@@ -61,6 +61,7 @@ public void Exists()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -111,6 +112,7 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -140,6 +142,7 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t1 = new ResolveAssemblyReference();
+            t1.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t1.TargetFrameworkVersion = "v4.5";
             t1.TargetFrameworkDirectories = new string[] { actualFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t1, e, items, redistString1, true, new List<string>() { "{RawFileName}" });
@@ -152,6 +155,7 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t2 = new ResolveAssemblyReference();
+            t2.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t2.TargetFrameworkVersion = "v4.5";
             t2.TargetFrameworkDirectories = new string[] { actualFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t2, e, items, redistString2, true, new List<string>() { "{RawFileName}" });
@@ -164,6 +168,7 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t3 = new ResolveAssemblyReference();
+            t3.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t3.TargetFrameworkVersion = "v4.5";
             t3.TargetFrameworkDirectories = new string[] { alternativeFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t3, e, items, redistString3, true, new List<string>() { "{RawFileName}" });
@@ -176,6 +181,7 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t4 = new ResolveAssemblyReference();
+            t4.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t4.TargetFrameworkVersion = "v4.5";
             t4.TargetFrameworkDirectories = new string[] { alternativeFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t4, e, items, redistString4, true, new List<string>() { "{RawFileName}" });
diff --git a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs
index c4f0bd34510..fc0d5824fa9 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs
@@ -67,6 +67,7 @@ public void Exists(string appConfigNameSuffix)
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -138,6 +139,7 @@ public void ExistsPromotedDependencyInTheDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
@@ -197,6 +199,7 @@ public void ExistsDifferentName()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -247,6 +250,7 @@ public void ExistsOldVersionRange()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -299,6 +303,7 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -365,6 +370,7 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -411,6 +417,7 @@ public void GarbageVersionInAppConfigFile()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -453,6 +460,7 @@ public void GarbageAppConfigMissingOldVersion()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -497,6 +505,7 @@ public void GarbageAppConfigMissingNewVersion()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -542,6 +551,7 @@ public void GarbageAppConfigAssemblyNameMissingPKTAndCulture()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -586,6 +596,7 @@ public void AppConfigSpecifiedWhenAutoUnifyEqualsTrue()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -624,6 +635,7 @@ public void AppConfigDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs
index eff546bcd3d..3cf04e07eb6 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs
@@ -70,6 +70,7 @@ internal void ExistsImpl(RARSimulationMode rarSimulationMode = RARSimulationMode
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -139,6 +140,7 @@ public void ExistsWithPrimaryReferenceOnDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
@@ -225,6 +227,7 @@ public void ExistsPromotedDependencyInTheDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
@@ -296,6 +299,7 @@ public void ExistsWithBothDependentReferenceOnDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
@@ -370,6 +374,7 @@ public void MultipleUnifiedFromNamesMiddlePrimaryOnDenyList()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
             t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
@@ -429,6 +434,7 @@ public void MultipleUnifiedFromNames()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -481,6 +487,7 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs b/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs
index 2dc93f2fe56..2d03c766667 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs
@@ -46,6 +46,7 @@ public void ConflictBetweenNonCopyLocalDependencies()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -91,6 +92,7 @@ public void ConflictBetweenCopyLocalDependencies()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("A"), new TaskItem("B")
@@ -140,6 +142,7 @@ public void ConflictBetweenCopyLocalDependenciesWithAutoUnify()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AutoUnify = true;
 
             t.Assemblies = new ITaskItem[] {
@@ -180,6 +183,7 @@ public void ConflictWithBackVersionPrimary()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -223,6 +227,7 @@ public void ConflictWithBackVersionPrimaryWithAutoUnify()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -276,6 +281,7 @@ public void Regress313747_FalseSuggestedRedirectsWhenAssembliesDifferOnlyByPkt()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -315,6 +321,7 @@ public void Regress442570_MissingBackVersionShouldWarn()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -350,6 +357,7 @@ public void RedirectsAreSuggestedInExternallyResolvedGraph()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             // NB: These are what common targets would set when AutoGenerateBindingRedirects is enabled.
             t.AutoUnify = true;
@@ -394,6 +402,7 @@ public void Regress387218_UnificationRequiresStrongName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -437,6 +446,7 @@ public void Regress390219_UnificationRequiresSameCulture()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
diff --git a/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs b/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs
index 52277dbbd1f..378f88c9317 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs
@@ -41,6 +41,7 @@ public void IgnoreVersionBasic()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.IgnoreVersionForFrameworkReferences = true;
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
@@ -66,6 +67,7 @@ public void IgnoreVersionBasic()
                            "</FileList >";
 
             t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
@@ -97,6 +99,7 @@ public void IgnoreVersionBasicTestMetadata()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -119,6 +122,7 @@ public void IgnoreVersionBasicTestMetadata()
                            "</FileList >";
 
             t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
@@ -150,6 +154,7 @@ public void IgnoreVersionDisableIfSpecificVersionTrue()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -180,6 +185,7 @@ public void IgnoreVersionDisableIfHintPath()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
diff --git a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs
index 7d92fe9e630..8437e611980 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs
@@ -34,7 +34,9 @@ public void FrameworksDoNotMatch()
                 new TaskItem("DependsOnFoo4Framework"),
             };
 
+    
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "BAR, Version=4.0";
@@ -62,6 +64,7 @@ public void LowerVersionSameFrameworkDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=v4.0";
@@ -89,6 +92,7 @@ public void SameVersionSameFrameworkDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -119,6 +123,7 @@ public void HigherVersionButSpecificVersionDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -146,6 +151,7 @@ public void LowerVersionSameFrameworkInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=v4.0";
@@ -175,6 +181,7 @@ public void SameVersionSameFrameworkInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -207,6 +214,7 @@ public void HigherVersionButSpecificVersionInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -238,6 +246,7 @@ public void HigherVersionInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -268,6 +277,7 @@ public void HigherVersionInDirectIgnoreMismatch()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest(); 
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -300,6 +310,7 @@ public void HigherVersionDirectIgnoreMismatch()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -332,6 +343,7 @@ public void HigherVersionDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -364,6 +376,7 @@ public void HigherVersionDirectDependenciesFalse()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.FindDependencies = false;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs
index 6435b8cddaa..e68281a9ffe 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs
@@ -41,6 +41,7 @@ public void TargetCurrentTargetFramework()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -82,6 +83,7 @@ public void RemapAssemblyBasic()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(0, e.Warnings); // "Expected NO warning in this scenario."
@@ -114,6 +116,7 @@ public void HigherThanHighestInRedistList()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
@@ -142,6 +145,7 @@ public void HigherThanHighestInRedistListForMSBuildAssembly()
                                   "</FileList >";
 
             ResolveAssemblyReference t1 = new ResolveAssemblyReference();
+            t1.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t1.TargetFrameworkVersion = "v4.5";
 
             ExecuteRAROnItemsAndRedist(t1, e, items, redistString, false);
@@ -151,6 +155,7 @@ public void HigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Single(t1.ResolvedFiles);
 
             ResolveAssemblyReference t2 = new ResolveAssemblyReference();
+            t2.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t2.TargetFrameworkVersion = "v4.0";
 
             ExecuteRAROnItemsAndRedist(t2, e, items, redistString, false);
@@ -162,6 +167,7 @@ public void HigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Empty(t2.ResolvedFiles);
 
             ResolveAssemblyReference t3 = new ResolveAssemblyReference();
+            t3.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t3.TargetFrameworkVersion = "v4.5";
             t3.UnresolveFrameworkAssembliesFromHigherFrameworks = true;
 
@@ -192,6 +198,7 @@ public void HigherThanHighestInRedistList3rdPartyRedist()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(0, e.Warnings); // "Expected one warning in this scenario."
@@ -220,6 +227,7 @@ public void HigherThanHighestInRedistListWithSpecificVersionMetadata()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -250,6 +258,7 @@ public void DependenciesHigherThanHighestInRedistList()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(2, e.Warnings); // "Expected one warning in this scenario."
@@ -278,6 +287,7 @@ public void DependenciesHigherThanHighestInRedistListForMSBuildAssembly()
                                   "</FileList >";
 
             ResolveAssemblyReference t1 = new ResolveAssemblyReference();
+            t1.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t1.TargetFrameworkVersion = "v5.0";
 
             ExecuteRAROnItemsAndRedist(t1, e, items, redistString, false);
@@ -288,6 +298,7 @@ public void DependenciesHigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Single(t1.ResolvedFiles);
 
             ResolveAssemblyReference t2 = new ResolveAssemblyReference();
+            t2.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t2.TargetFrameworkVersion = "v4.0";
 
             ExecuteRAROnItemsAndRedist(t2, e, items, redistString, false);
@@ -300,6 +311,7 @@ public void DependenciesHigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Empty(t2.ResolvedFiles);
 
             ResolveAssemblyReference t3 = new ResolveAssemblyReference();
+            t3.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             // t2.TargetFrameworkVersion is null
 
             ExecuteRAROnItemsAndRedist(t3, e, items, redistString, false);
@@ -333,6 +345,7 @@ public void DependenciesHigherThanHighestInRedistListSpecificVersionMetadata()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -366,6 +379,7 @@ public void TwoDependenciesHigherThanHighestInRedistListIgnoreOnOne()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
@@ -401,6 +415,7 @@ public void TwoDependenciesHigherThanHighestInRedistListIgnoreOnBoth()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -431,6 +446,7 @@ public void TwoDependenciesSameNameDependOnHigherVersion()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
@@ -471,6 +487,7 @@ public void MixedDependenciesSpecificVersionOnHigherVersionMetadataSet()
 
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false, additionalPaths);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -511,6 +528,7 @@ public void MixedDependenciesSpecificVersionOnLowerVersionMetadataSet()
             additionalPaths.Add(s_myVersion90Path + Path.DirectorySeparatorChar);
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false, additionalPaths);
 
diff --git a/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs b/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs
index 285438b8181..8a500e8ecd4 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs
@@ -149,6 +149,7 @@ public void VerifyP2PHaveCorrectMetadataWinMD(bool setImplementationMetadata)
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -208,6 +209,7 @@ public void VerifyP2PHaveCorrectMetadataWinMDStaticLib()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -253,6 +255,7 @@ public void VerifyP2PHaveCorrectMetadataWinMDManaged()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
@@ -290,6 +293,7 @@ public void VerifyP2PHaveCorrectMetadataNonWinMD()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             bool succeeded = Execute(t);
 
@@ -321,6 +325,7 @@ public void IgnoreReferenceToMscorlib()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -352,6 +357,7 @@ public void MixedWinMDGoodReferenceToMscorlib()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
@@ -383,6 +389,7 @@ public void WinMdFileDependsOnAnotherWinMDFile()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -424,6 +431,7 @@ public void ResolveWinmdBesideDll()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { "{RAWFILENAME}" };
             bool succeeded = Execute(t);
@@ -456,6 +464,7 @@ public void ResolveWinmdBesideDll2()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"{RAWFILENAME}" };
             bool succeeded = Execute(t);
@@ -487,6 +496,7 @@ public void WinMdFileDependsOnAnotherWinMDFileWithFrameworkDependencies()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"{TargetFrameworkDirectory}", @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             t.TargetFrameworkDirectories = new string[] { @"c:\WINNT\Microsoft.NET\Framework\v4.0.MyVersion" };
@@ -529,6 +539,7 @@ public void DotNetAssemblyDependsOnAWinMDFile()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             t.TargetProcessorArchitecture = "X86";
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
@@ -565,6 +576,7 @@ public void ResolveWinmdWithInvalidPENativeDependency()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             bool succeeded = Execute(t);
@@ -597,6 +609,7 @@ public void ResolveWinmdWithArchitectureDependencyMatchingArchitecturesX86()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             t.TargetProcessorArchitecture = "X86";
@@ -631,6 +644,7 @@ public void ResolveWinmdWithArchitectureDependencyAnyCPUNative()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             t.TargetProcessorArchitecture = "X86";
@@ -692,6 +706,7 @@ private void VerifyImplementationArchitecture(string winmdName, string targetPro
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             t.TargetProcessorArchitecture = targetProcessorArchitecture;
@@ -766,6 +781,7 @@ public void DotNetAssemblyDependsOnAWinMDFileWithVersion255()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
diff --git a/src/Tasks.UnitTests/GetReferencePaths_Tests.cs b/src/Tasks.UnitTests/GetReferencePaths_Tests.cs
index f4352c0322a..75ff03ae985 100644
--- a/src/Tasks.UnitTests/GetReferencePaths_Tests.cs
+++ b/src/Tasks.UnitTests/GetReferencePaths_Tests.cs
@@ -29,6 +29,7 @@ public void TestGeneralFrameworkMonikerGood()
             string targetFrameworkMoniker = ".NetFramework, Version=v4.8";
             MockEngine engine = new();
             GetReferenceAssemblyPaths getReferencePaths = new();
+            getReferencePaths.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             getReferencePaths.BuildEngine = engine;
             getReferencePaths.TargetFrameworkMoniker = targetFrameworkMoniker;
             getReferencePaths.Execute();
diff --git a/src/Tasks.UnitTests/HintPathResolver_Tests.cs b/src/Tasks.UnitTests/HintPathResolver_Tests.cs
index 7849b653fdb..4c9bc62f1c1 100644
--- a/src/Tasks.UnitTests/HintPathResolver_Tests.cs
+++ b/src/Tasks.UnitTests/HintPathResolver_Tests.cs
@@ -72,7 +72,8 @@ private bool ResolveHintPath(string hintPath)
                 getAssemblyName: (path) => throw new NotImplementedException(), // not called in this code path
                 fileExists: p => FileUtilities.FileExistsNoThrow(p),
                 getRuntimeVersion: (path) => throw new NotImplementedException(), // not called in this code path
-                targetedRuntimeVesion: Version.Parse("4.0.30319"));
+                targetedRuntimeVesion: Version.Parse("4.0.30319"),
+                taskEnvironment: TaskEnvironmentHelper.CreateForTest());
 
             var result = hintPathResolver.Resolve(new AssemblyNameExtension("FakeSystem.Net.Http"),
                 sdkName: "",
diff --git a/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs b/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs
index d3c94688e18..018a8191931 100644
--- a/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs
+++ b/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs
@@ -25,6 +25,7 @@ public void TestPrecomputedCacheOutput()
                 TransientTestFile standardCache = env.CreateFile(".cache");
                 ResolveAssemblyReference t = new ResolveAssemblyReference()
                 {
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     _cache = new SystemState()
                 };
                 t._cache.instanceLocalFileStateCache = new Dictionary<string, SystemState.FileState>() {
@@ -60,6 +61,7 @@ public void StandardCacheTakesPrecedence()
                 TransientTestFile standardCache = env.CreateFile(".cache");
                 ResolveAssemblyReference rarWriterTask = new ResolveAssemblyReference()
                 {
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     _cache = new SystemState()
                 };
                 rarWriterTask._cache.instanceLocalFileStateCache = new() {
@@ -87,7 +89,10 @@ public void StandardCacheTakesPrecedence()
                 // Write precomputed cache
                 rarWriterTask.WriteStateFile();
 
-                ResolveAssemblyReference rarReaderTask = new ResolveAssemblyReference();
+                ResolveAssemblyReference rarReaderTask = new ResolveAssemblyReference()
+                {
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest()
+                };
                 rarReaderTask.StateFile = standardCache.Path;
                 rarReaderTask.AssemblyInformationCachePaths = new ITaskItem[]
                 {
@@ -111,6 +116,7 @@ public void TestPreComputedCacheInputMatchesOutput()
                 TransientTestFile precomputedCache = env.CreateFile(".cache");
                 ResolveAssemblyReference rarWriterTask = new ResolveAssemblyReference()
                 {
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     _cache = new SystemState()
                 };
                 string dllName = Path.Combine(Path.GetDirectoryName(precomputedCache.Path), "randomFolder", "dll.dll");
@@ -131,7 +137,10 @@ public void TestPreComputedCacheInputMatchesOutput()
                 File.Delete(precomputedCache.Path);
                 rarWriterTask.WriteStateFile();
 
-                ResolveAssemblyReference rarReaderTask = new ResolveAssemblyReference();
+                ResolveAssemblyReference rarReaderTask = new ResolveAssemblyReference()
+                {
+                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest()
+                };
                 rarReaderTask.StateFile = precomputedCache.Path.Substring(0, precomputedCache.Path.Length - 6); // Not a real path; should not be used.
                 rarReaderTask.AssemblyInformationCachePaths = new ITaskItem[]
                 {

From b669d97b22ad34a914eeb65661bf507fcaa5a4f5 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Fri, 13 Mar 2026 14:28:16 +0100
Subject: [PATCH 06/29] Set default driver to enlightened tasks.

---
 src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs | 2 +-
 src/Tasks/GetReferenceAssemblyPaths.cs                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 7210aa47f37..c56cccfc9a6 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -967,7 +967,7 @@ public string[] FullFrameworkFolders
         public bool FailIfNotIncremental { get; set; }
 
         /// <inheritdoc />
-        public TaskEnvironment TaskEnvironment { get; set; }
+        public TaskEnvironment TaskEnvironment { get; set; } = new TaskEnvironment(MultiProcessTaskEnvironmentDriver.Instance);
 
         /// <summary>
         /// Allow the task to run on the out-of-proc node if enabled for this build.
diff --git a/src/Tasks/GetReferenceAssemblyPaths.cs b/src/Tasks/GetReferenceAssemblyPaths.cs
index ee57ded0376..cb773247dce 100644
--- a/src/Tasks/GetReferenceAssemblyPaths.cs
+++ b/src/Tasks/GetReferenceAssemblyPaths.cs
@@ -25,7 +25,7 @@ public class GetReferenceAssemblyPaths : TaskExtension, IMultiThreadableTask
         /// <summary>
         /// Task environment for thread-safe operations.
         /// </summary>
-        public TaskEnvironment TaskEnvironment { get; set; }
+        public TaskEnvironment TaskEnvironment { get; set; } = new TaskEnvironment(MultiProcessTaskEnvironmentDriver.Instance);
         #region Data
 #if FEATURE_GAC
         /// <summary>

From 6e770db691cabb9fe9c9c328987b2faba22faebd Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Wed, 15 Apr 2026 12:22:06 +0200
Subject: [PATCH 07/29] Fix bug with sdk paths comparer.

---
 src/Tasks/InstalledSDKResolver.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Tasks/InstalledSDKResolver.cs b/src/Tasks/InstalledSDKResolver.cs
index 8583911aa33..6c9feb32df5 100644
--- a/src/Tasks/InstalledSDKResolver.cs
+++ b/src/Tasks/InstalledSDKResolver.cs
@@ -33,7 +33,7 @@ public InstalledSDKResolver(Dictionary<string, ITaskItem> resolvedSDKs, string s
             : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
             _resolvedSDKs = resolvedSDKs;
-            _resolvedSDKPaths = new Dictionary<string, string>(resolvedSDKs.Count);
+            _resolvedSDKPaths = new Dictionary<string, string>(resolvedSDKs.Count, resolvedSDKs.Comparer);
             
             // Cache absolute paths to avoid repeated TaskEnvironment.GetAbsolutePath calls
             foreach (var kvp in resolvedSDKs)

From 161d875b6b9659d60fa903a63697b9665f956a53 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Wed, 15 Apr 2026 12:41:34 +0200
Subject: [PATCH 08/29] Added AbsolutePath overload for SerializeCache.

---
 .../ResolveAssemblyReference.cs               |  2 +-
 src/Tasks/StateFileBase.cs                    | 39 +++++++++++++++++++
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index c56cccfc9a6..e8e34357c14 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -2177,7 +2177,7 @@ internal void WriteStateFile()
             {
                 // Either the cache is dirty (we added or updated an item) or the number of items actually used is less than what
                 // we got by reading the state file prior to execution. Serialize the cache into the state file.
-                _cache.SerializeCache(_stateFile.Value, Log);
+                _cache.SerializeCache(_stateFile, Log);
             }
         }
         #endregion
diff --git a/src/Tasks/StateFileBase.cs b/src/Tasks/StateFileBase.cs
index 1d43a4cf7c2..e60b607d5e8 100644
--- a/src/Tasks/StateFileBase.cs
+++ b/src/Tasks/StateFileBase.cs
@@ -36,6 +36,10 @@ internal abstract class StateFileBase
         /// <summary>
         /// Writes the contents of this object out to the specified file.
         /// </summary>
+        /// <remarks>
+        /// Prioritize using the AbsolutePath overload of this method. This method is still used by unenlightened tasks, but new code should use the AbsolutePath overload.
+        /// Delete this method once all tasks have been migrated to the AbsolutePath overload.
+        /// </remarks>
         internal virtual void SerializeCache(string stateFile, TaskLoggingHelper log, bool serializeEmptyState = false)
         {
             try
@@ -68,6 +72,41 @@ internal virtual void SerializeCache(string stateFile, TaskLoggingHelper log, bo
             }
         }
 
+        /// <summary>
+        /// Writes the contents of this object out to the specified file.
+        /// </summary>
+        internal virtual void SerializeCache(AbsolutePath stateFile, TaskLoggingHelper log, bool serializeEmptyState = false)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(stateFile))
+                {
+                    if (FileSystems.Default.FileExists(stateFile))
+                    {
+                        File.Delete(stateFile);
+                    }
+
+                    if (serializeEmptyState || HasStateToSave)
+                    {
+                        using (var s = new FileStream(stateFile, FileMode.CreateNew))
+                        {
+                            var translator = BinaryTranslator.GetWriteTranslator(s);
+                            translator.Translate(ref _serializedVersion);
+                            Translate(translator);
+                        }
+                    }
+                }
+            }
+            // If there was a problem writing the file (like it's read-only or locked on disk, for
+            // example), then eat the exception and log a warning.  Otherwise, rethrow.
+            catch (Exception e) when (!ExceptionHandling.NotExpectedSerializationException(e))
+            {
+                // Not being able to serialize the cache is not an error, but we let the user know anyway.
+                // Don't want to hold up processing just because we couldn't read the file.
+                log.LogWarningWithCodeFromResources("General.CouldNotWriteStateFile", stateFile.OriginalValue, e.Message);
+            }
+        }
+
         public abstract void Translate(ITranslator translator);
 
         /// <summary>

From a7da484ebdd8c77b10937cf5e175cec394d32972 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Wed, 15 Apr 2026 14:24:22 +0200
Subject: [PATCH 09/29] Ensure that resolvers absolutize the inputs. Do not do
 canonicalization as it is expensive and would be done in ReferenceTable
 centrally.

---
 src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs | 5 +++--
 src/Tasks/AssemblyDependency/DirectoryResolver.cs       | 4 ++--
 src/Tasks/AssemblyDependency/HintPathResolver.cs        | 2 +-
 src/Tasks/AssemblyDependency/RawFilenameResolver.cs     | 2 +-
 4 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs
index ad14e572e71..c90b5c905ac 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersResolver.cs
@@ -51,10 +51,11 @@ public override bool Resolve(
 #if FEATURE_WIN32_REGISTRY
             if (assemblyName != null)
             {
-                // {AssemblyFolders} was passed in. They come from registry and are assumed to be absolute paths.
+                // {AssemblyFolders} was passed in.
                 foreach (string assemblyFolder in AssemblyFolder.GetAssemblyFolders(assemblyFolderKey))
                 {
-                    string resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, assemblyFolder, assembliesConsideredAndRejected);
+                    string fullAssemblyFolder = taskEnvironment.GetAbsolutePath(assemblyFolder).Value;
+                    string resolvedPath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, fullAssemblyFolder, assembliesConsideredAndRejected);
                     if (resolvedPath != null)
                     {
                         foundPath = resolvedPath;
diff --git a/src/Tasks/AssemblyDependency/DirectoryResolver.cs b/src/Tasks/AssemblyDependency/DirectoryResolver.cs
index c737557a904..28c31af46cf 100644
--- a/src/Tasks/AssemblyDependency/DirectoryResolver.cs
+++ b/src/Tasks/AssemblyDependency/DirectoryResolver.cs
@@ -21,7 +21,7 @@ internal class DirectoryResolver : Resolver
         public readonly string parentAssembly;
 
         /// <summary>
-        /// Cached absolute path for the search path element
+        /// Cached absolute path for the search path element. Not necessarily in canonical form.
         /// </summary>
         private readonly string _fullSearchPath;
 
@@ -32,7 +32,7 @@ public DirectoryResolver(string searchPathElement, GetAssemblyName getAssemblyNa
             : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
             this.parentAssembly = parentAssembly;
-            _fullSearchPath = string.IsNullOrEmpty(searchPathElement) ? searchPathElement : taskEnvironment.GetAbsolutePath(searchPathElement).GetCanonicalForm().Value;
+            _fullSearchPath = string.IsNullOrEmpty(searchPathElement) ? searchPathElement : taskEnvironment.GetAbsolutePath(searchPathElement).Value;
         }
 
         /// <inheritdoc/>
diff --git a/src/Tasks/AssemblyDependency/HintPathResolver.cs b/src/Tasks/AssemblyDependency/HintPathResolver.cs
index e57a0977f7a..05ceb6e2dcd 100644
--- a/src/Tasks/AssemblyDependency/HintPathResolver.cs
+++ b/src/Tasks/AssemblyDependency/HintPathResolver.cs
@@ -45,7 +45,7 @@ public override bool Resolve(
             // However, we should consider Trim() the hintpath https://github.com/dotnet/msbuild/issues/4603
             if (!string.IsNullOrEmpty(hintPath) && !FileUtilities.PathIsInvalid(hintPath))
             {
-                string fullHintPath = taskEnvironment.GetAbsolutePath(hintPath).GetCanonicalForm().Value;
+                string fullHintPath = taskEnvironment.GetAbsolutePath(hintPath).Value;
                 if (ResolveAsFile(fullHintPath, assemblyName, isPrimaryProjectReference, wantSpecificVersion, true, assembliesConsideredAndRejected))
                 {
                     userRequestedSpecificFile = true;
diff --git a/src/Tasks/AssemblyDependency/RawFilenameResolver.cs b/src/Tasks/AssemblyDependency/RawFilenameResolver.cs
index 334addeb83d..1a18e5d8ee6 100644
--- a/src/Tasks/AssemblyDependency/RawFilenameResolver.cs
+++ b/src/Tasks/AssemblyDependency/RawFilenameResolver.cs
@@ -45,7 +45,7 @@ public override bool Resolve(
             if (rawFileNameCandidate != null)
             {
                 // {RawFileName} was passed in.
-                string fullRawFileName = taskEnvironment.GetAbsolutePath(rawFileNameCandidate).GetCanonicalForm().Value;
+                string fullRawFileName = taskEnvironment.GetAbsolutePath(rawFileNameCandidate).Value;
                 if (isImmutableFrameworkReference || fileExists(fullRawFileName))
                 {
                     userRequestedSpecificFile = true;

From f6f529226e07cdb9637a8dd951e05acf0f7d214f Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Wed, 15 Apr 2026 14:43:09 +0200
Subject: [PATCH 10/29] Disambiguated the cref to SerializeCache(string,
 TaskLoggingHelper, bool)

---
 src/Tasks/StateFileBase.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Tasks/StateFileBase.cs b/src/Tasks/StateFileBase.cs
index e60b607d5e8..0e97cb2a78d 100644
--- a/src/Tasks/StateFileBase.cs
+++ b/src/Tasks/StateFileBase.cs
@@ -29,7 +29,7 @@ internal abstract class StateFileBase
         private byte _serializedVersion = CurrentSerializationVersion;
 
         /// <summary>
-        /// True if <see cref="SerializeCache"/> should create the state file and serialize ourselves, false otherwise.
+        /// True if <see cref="SerializeCache(string, TaskLoggingHelper, bool)"/> should create the state file and serialize ourselves, false otherwise.
         /// </summary>
         internal virtual bool HasStateToSave => true;
 

From 92f997c2e46eee6f16a4de98f752b0f92c64010f Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Wed, 15 Apr 2026 15:56:41 +0200
Subject: [PATCH 11/29] Be defensive and absolutize in
 AssemblyFoldersFromConfig cache and resolver.

---
 .../AssemblyFoldersFromConfigCache.cs                     | 8 +++++---
 .../AssemblyFoldersFromConfigResolver.cs                  | 5 ++++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
index 4346b773f66..9709fcf02f5 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
@@ -46,11 +46,13 @@ internal AssemblyFoldersFromConfigCache(AssemblyFoldersFromConfig assemblyFolder
             }
             else
             {
+                // Absolutize directory paths defensively — config paths theoretically should but may not be absolute.
                 _filesInDirectories = new(assemblyFoldersFromConfig.AsParallel()
-                    .Where(assemblyFolder => FileUtilities.DirectoryExistsNoThrow(assemblyFolder.DirectoryPath))
+                    .Select(assemblyFolder => taskEnvironment.GetAbsolutePath(assemblyFolder.DirectoryPath).Value)
+                    .Where(absolutePath => FileUtilities.DirectoryExistsNoThrow(absolutePath))
                     .SelectMany(
-                        assemblyFolder =>
-                            Directory.GetFiles(assemblyFolder.DirectoryPath, "*.*", SearchOption.TopDirectoryOnly)),
+                        absolutePath =>
+                            Directory.GetFiles(absolutePath, "*.*", SearchOption.TopDirectoryOnly)),
                     StringComparer.OrdinalIgnoreCase);
             }
         }
diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
index fe37317e078..82db6a9c357 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
@@ -180,7 +180,10 @@ public override bool Resolve(
                     {
                         foreach (AssemblyFoldersFromConfigInfo assemblyFolder in _assemblyFoldersCache.AssemblyFoldersFromConfig)
                         {
-                            string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, assemblyFolder.DirectoryPath, assembliesConsideredAndRejected);
+                            // Absolutize defensively — config paths may not be absolute.
+                            // Not canonicalized here; canonicalization is done in ReferenceTable.
+                            string absoluteDirectoryPath = taskEnvironment.GetAbsolutePath(assemblyFolder.DirectoryPath).Value;
+                            string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, absoluteDirectoryPath, assembliesConsideredAndRejected);
 
                             // We have a full path returned
                             if (candidatePath != null)

From c4653dd1aa61071019c4712e31c7c78d9782a954 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Wed, 15 Apr 2026 18:03:18 +0200
Subject: [PATCH 12/29] Add comment.

---
 src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index e8e34357c14..323fac0ab90 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -2468,6 +2468,9 @@ internal bool Execute(
                                 // With the new behavior, empty strings are silently ignored (treated like null).
                                 // When Wave 18.5 is disabled, we preserve the old failure behavior.
                                 // When cleaning up this change wave, also clean up the _appConfigValueIsEmptyString field.
+                                
+                                // Note, second part of the sentence is not localized: this is a temporary fallback behind a change wave that is off by default
+                                // and will be removed when the wave is cleaned up. Not worth adding a new resource string.
                                 Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.InvalidAppConfig", string.Empty, "AppConfig file path cannot be empty.");
                                 return false;
                             }

From 77ea94b942d14315a63ec391faa85530ba2c40cb Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 14:19:46 +0200
Subject: [PATCH 13/29] defensively assign empty arrays as values if null value
 is passed.

---
 .../AssemblyDependency/ResolveAssemblyReference.cs     | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 323fac0ab90..49d032a32a0 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -301,7 +301,7 @@ public string[] LatestTargetFrameworkDirectories
             set
             {
                 _latestTargetFrameworkDirectories = value?.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray() ?? [];
             }
         }
 
@@ -410,7 +410,7 @@ public string[] CandidateAssemblyFiles
             set
             {
                 _candidateAssemblyFiles = value?.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray() ?? [];
             }
         }
 
@@ -439,7 +439,7 @@ public string[] TargetFrameworkDirectories
             set
             {
                 _targetFrameworkDirectories = value?.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
+                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray() ?? [];
             }
         }
 
@@ -959,7 +959,7 @@ public string[] FullFrameworkFolders
             set
             {
                 ErrorUtilities.VerifyThrowArgumentNull(value, "FullFrameworkFolders");
-                _fullFrameworkFolders = value?.Select(
+                _fullFrameworkFolders = value.Select(
                     path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
             }
         }
@@ -2466,7 +2466,7 @@ internal bool Execute(
                                 // Prior to Wave18_6, empty strings would cause TaskEnvironment.GetAbsolutePath() to throw an exception,
                                 // which would be caught and logged as an error, stopping RAR execution.
                                 // With the new behavior, empty strings are silently ignored (treated like null).
-                                // When Wave 18.5 is disabled, we preserve the old failure behavior.
+                                // When Wave 18.6 is disabled, we preserve the old failure behavior.
                                 // When cleaning up this change wave, also clean up the _appConfigValueIsEmptyString field.
                                 
                                 // Note, second part of the sentence is not localized: this is a temporary fallback behind a change wave that is off by default

From 0688f80fa136b8520a6538222b1829fe6b806c61 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 14:26:52 +0200
Subject: [PATCH 14/29] Removed the redundant _taskEnvironment field

---
 .../AssemblyDependency/AssemblyFoldersExResolver.cs    | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
index 66728720404..b5a16cfdce2 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
@@ -91,11 +91,6 @@ internal class AssemblyFoldersExResolver : Resolver
         /// </summary>
         private readonly IBuildEngine4 _buildEngine;
 
-        /// <summary>
-        /// TaskEnvironment for thread-safe access to environment variables.
-        /// </summary>
-        private readonly TaskEnvironment _taskEnvironment;
-
         /// <summary>
         /// If it is not initialized then just return the null object, that would mean the resolver was not called.
         /// </summary>
@@ -111,7 +106,6 @@ public AssemblyFoldersExResolver(string searchPathElement, GetAssemblyName getAs
             _getRegistrySubKeyNames = getRegistrySubKeyNames;
             _getRegistrySubKeyDefaultValue = getRegistrySubKeyDefaultValue;
             _openBaseKey = openBaseKey;
-            _taskEnvironment = taskEnvironment;
         }
 
         /// <summary>
@@ -167,7 +161,7 @@ private void LazyInitialize()
                     }
                     _wasMatch = true;
 
-                    bool useCache = _taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") == null;
+                    bool useCache = taskEnvironment.GetEnvironmentVariable("MSBUILDDISABLEASSEMBLYFOLDERSEXCACHE") == null;
                     string key = "ca22615d-aa83-444b-80b9-b32f3d5db097" + this.searchPathElement;
                     if (useCache && _buildEngine != null)
                     {
@@ -177,7 +171,7 @@ private void LazyInitialize()
                     if (_assemblyFoldersCache == null)
                     {
                         AssemblyFoldersEx assemblyFolders = new AssemblyFoldersEx(_registryKeyRoot, _targetRuntimeVersion, _registryKeySuffix, _osVersion, _platform, _getRegistrySubKeyNames, _getRegistrySubKeyDefaultValue, this.targetProcessorArchitecture, _openBaseKey);
-                        _assemblyFoldersCache = new AssemblyFoldersExCache(assemblyFolders, fileExists, _taskEnvironment);
+                        _assemblyFoldersCache = new AssemblyFoldersExCache(assemblyFolders, fileExists, taskEnvironment);
                         if (useCache)
                         {
                             _buildEngine?.RegisterTaskObject(key, _assemblyFoldersCache, RegisteredTaskObjectLifetime.Build, true /* dispose early ok*/);

From 5186ee4faedf4ecd398c6045c7a9097e1bc0dd02 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 15:11:42 +0200
Subject: [PATCH 15/29] Add tests for the AppConfigFile in RAR

---
 .../AssemblyDependency/Miscellaneous.cs       | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
index 919d2d1ea1b..40195fb99b7 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
@@ -1175,6 +1175,54 @@ public void Regress286699_InvalidAppConfig()
             // Should not crash.
         }
 
+        /// <summary>
+        /// When Wave18_6 is enabled (default), empty AppConfigFile is silently ignored.
+        /// The task should succeed as if no app.config was specified.
+        /// </summary>
+        [Fact]
+        public void EmptyAppConfigFile_Wave18_6_Enabled_Succeeds()
+        {
+            ResolveAssemblyReference t = new ResolveAssemblyReference();
+
+            t.BuildEngine = new MockEngine(_output);
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
+            t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
+            t.AppConfigFile = string.Empty;
+
+            bool retval = Execute(t);
+
+            retval.ShouldBeTrue();
+        }
+
+        /// <summary>
+        /// When Wave18_6 is disabled, empty AppConfigFile should cause the task to fail
+        /// with an error, preserving backward-compatible behavior.
+        /// </summary>
+        [Fact]
+        public void EmptyAppConfigFile_Wave18_6_Disabled_Fails()
+        {
+            using TestEnvironment env = TestEnvironment.Create(_output);
+
+            ChangeWaves.ResetStateForTests();
+            env.SetEnvironmentVariable("MSBUILDDISABLEFEATURESFROMVERSION", ChangeWaves.Wave18_6.ToString());
+            BuildEnvironmentHelper.ResetInstance_ForUnitTestsOnly();
+
+            ResolveAssemblyReference t = new ResolveAssemblyReference();
+
+            MockEngine engine = new MockEngine(_output);
+            t.BuildEngine = engine;
+            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
+            t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
+            t.AppConfigFile = string.Empty;
+
+            bool retval = Execute(t);
+
+            retval.ShouldBeFalse();
+            engine.Errors.ShouldBe(1);
+
+            ChangeWaves.ResetStateForTests();
+        }
+
         /// <summary>
         /// Make sure that nonexistent references are just eliminated.
         /// </summary>

From 347d260cd1563d6758db217d2c24d3071292a3c9 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 16:23:27 +0200
Subject: [PATCH 16/29] Fix RAR test fixture FileExists.

---
 .../AssemblyDependency/Miscellaneous.cs       | 36 +++++--------------
 .../ResolveAssemblyReferenceTestFixture.cs    | 12 +++----
 2 files changed, 13 insertions(+), 35 deletions(-)

diff --git a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
index 40195fb99b7..c534edee8bd 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
@@ -1155,43 +1155,25 @@ public void Regress286699_InvalidSearchPath()
         }
 
         /// <summary>
-        /// Invalid app.config path should not crash.
+        /// Invalid or empty app.config paths should not crash.
+        /// Invalid path "|" causes a logged error and task failure.
+        /// Empty string is silently ignored (Wave18_6 behavior) and task succeeds.
         /// </summary>
-        [Fact]
-        public void Regress286699_InvalidAppConfig()
-        {
-            ResolveAssemblyReference t = new ResolveAssemblyReference();
-
-            t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
-
-            t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
-            t.AppConfigFile = "|";
-
-            bool retval = Execute(t);
-
-            Assert.False(retval);
-
-            // Should not crash.
-        }
-
-        /// <summary>
-        /// When Wave18_6 is enabled (default), empty AppConfigFile is silently ignored.
-        /// The task should succeed as if no app.config was specified.
-        /// </summary>
-        [Fact]
-        public void EmptyAppConfigFile_Wave18_6_Enabled_Succeeds()
+        [Theory]
+        [InlineData("|", false)]
+        [InlineData("", true)]
+        public void InvalidOrEmptyAppConfig_DoesNotCrash(string appConfigFile, bool expectedSuccess)
         {
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
             t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
-            t.AppConfigFile = string.Empty;
+            t.AppConfigFile = appConfigFile;
 
             bool retval = Execute(t);
 
-            retval.ShouldBeTrue();
+            retval.ShouldBe(expectedSuccess);
         }
 
         /// <summary>
diff --git a/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs b/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs
index 579bfdd1556..e8bac774e59 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/ResolveAssemblyReferenceTestFixture.cs
@@ -854,10 +854,8 @@ internal static bool FileExists(string path)
                 return false;
             }
 
-            if (!Path.IsPathRooted(path))
-            {
-                path = Path.GetFullPath(path);
-            }
+            // Canonicalize the path (resolve ".." segments etc.) so it matches s_existentFiles entries.
+            path = Path.GetFullPath(path);
 
             foreach (string file in s_existentFiles)
             {
@@ -1048,10 +1046,8 @@ internal static AssemblyNameExtension GetAssemblyName(string path)
                 throw new FileNotFoundException(path);
             }
 
-            if (!Path.IsPathRooted(path))
-            {
-                path = Path.GetFullPath(path);
-            }
+            // Canonicalize the path (resolve ".." segments etc.) so it matches expected entries.
+            path = Path.GetFullPath(path);
 
             if
             (

From 1046cbc5daf630bdba555acd22c1b889b19a874d Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 17:05:54 +0200
Subject: [PATCH 17/29] Address null-safety concern.

---
 .../AssemblyFoldersFromConfigCache.cs         |  1 +
 .../AssemblyFoldersFromConfigResolver.cs      | 22 +++++++++++++++----
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
index 9709fcf02f5..957f69b06c5 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigCache.cs
@@ -48,6 +48,7 @@ internal AssemblyFoldersFromConfigCache(AssemblyFoldersFromConfig assemblyFolder
             {
                 // Absolutize directory paths defensively — config paths theoretically should but may not be absolute.
                 _filesInDirectories = new(assemblyFoldersFromConfig.AsParallel()
+                    .Where(assemblyFolder => !string.IsNullOrEmpty(assemblyFolder.DirectoryPath))
                     .Select(assemblyFolder => taskEnvironment.GetAbsolutePath(assemblyFolder.DirectoryPath).Value)
                     .Where(absolutePath => FileUtilities.DirectoryExistsNoThrow(absolutePath))
                     .SelectMany(
diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
index 82db6a9c357..e550c519a60 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
@@ -180,10 +180,24 @@ public override bool Resolve(
                     {
                         foreach (AssemblyFoldersFromConfigInfo assemblyFolder in _assemblyFoldersCache.AssemblyFoldersFromConfig)
                         {
-                            // Absolutize defensively — config paths may not be absolute.
-                            // Not canonicalized here; canonicalization is done in ReferenceTable.
-                            string absoluteDirectoryPath = taskEnvironment.GetAbsolutePath(assemblyFolder.DirectoryPath).Value;
-                            string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, absoluteDirectoryPath, assembliesConsideredAndRejected);
+                            string directoryPath;
+                            if (string.IsNullOrEmpty(assemblyFolder.DirectoryPath))
+                            {
+                                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                                {
+                                    continue;
+                                }
+
+                                // Pre-Wave18_6: empty DirectoryPath was passed through and resolved from CWD (project directory).
+                                directoryPath = taskEnvironment.ProjectDirectory.Value;
+                            }
+                            else
+                            {
+                                // Absolutize defensively — config paths may not be absolute.
+                                directoryPath = taskEnvironment.GetAbsolutePath(assemblyFolder.DirectoryPath).Value;
+                            }
+
+                            string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, directoryPath, assembliesConsideredAndRejected);
 
                             // We have a full path returned
                             if (candidatePath != null)

From 26636a116fe3c0f35fbbadacbb36ffba582f3ee2 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 17:12:38 +0200
Subject: [PATCH 18/29] Deduplicate code in StateFileBase.

---
 src/Tasks/StateFileBase.cs | 80 ++++----------------------------------
 1 file changed, 7 insertions(+), 73 deletions(-)

diff --git a/src/Tasks/StateFileBase.cs b/src/Tasks/StateFileBase.cs
index 0e97cb2a78d..5ec192f9964 100644
--- a/src/Tasks/StateFileBase.cs
+++ b/src/Tasks/StateFileBase.cs
@@ -42,34 +42,12 @@ internal abstract class StateFileBase
         /// </remarks>
         internal virtual void SerializeCache(string stateFile, TaskLoggingHelper log, bool serializeEmptyState = false)
         {
-            try
+            if (string.IsNullOrEmpty(stateFile))
             {
-                if (!string.IsNullOrEmpty(stateFile))
-                {
-                    if (FileSystems.Default.FileExists(stateFile))
-                    {
-                        File.Delete(stateFile);
-                    }
-
-                    if (serializeEmptyState || HasStateToSave)
-                    {
-                        using (var s = new FileStream(stateFile, FileMode.CreateNew))
-                        {
-                            var translator = BinaryTranslator.GetWriteTranslator(s);
-                            translator.Translate(ref _serializedVersion);
-                            Translate(translator);
-                        }
-                    }
-                }
-            }
-            // If there was a problem writing the file (like it's read-only or locked on disk, for
-            // example), then eat the exception and log a warning.  Otherwise, rethrow.
-            catch (Exception e) when (!ExceptionHandling.NotExpectedSerializationException(e))
-            {
-                // Not being able to serialize the cache is not an error, but we let the user know anyway.
-                // Don't want to hold up processing just because we couldn't read the file.
-                log.LogWarningWithCodeFromResources("General.CouldNotWriteStateFile", stateFile, e.Message);
+                return;
             }
+
+            SerializeCache(new AbsolutePath(stateFile, ignoreRootedCheck: true), log, serializeEmptyState);
         }
 
         /// <summary>
@@ -118,58 +96,14 @@ internal virtual void SerializeCache(AbsolutePath stateFile, TaskLoggingHelper l
         /// </remarks>
         internal static T DeserializeCache<T>(string stateFile, TaskLoggingHelper log) where T : StateFileBase
         {
-            T retVal = null;
-
-            // First, we read the cache from disk if one exists, or if one does not exist, we create one.
-            try
-            {
-                if (!string.IsNullOrEmpty(stateFile) && FileSystems.Default.FileExists(stateFile))
-                {
-                    using (FileStream s = File.OpenRead(stateFile))
-                    {
-                        using var translator = BinaryTranslator.GetReadTranslator(s, InterningBinaryReader.PoolingBuffer);
-
-                        byte version = 0;
-                        translator.Translate(ref version);
-                        // If the version is wrong, log a message not a warning. This could be a valid cache with the wrong version preventing correct deserialization.
-                        // For the latter case, internals may be unexpectedly null.
-                        if (version != CurrentSerializationVersion)
-                        {
-                            log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, log.FormatResourceString("General.IncompatibleStateFileType"));
-                            return null;
-                        }
-
-                        var constructors = typeof(T).GetConstructors();
-                        foreach (var constructor in constructors)
-                        {
-                            var parameters = constructor.GetParameters();
-                            if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ITranslator))
-                            {
-                                retVal = constructor.Invoke([translator]) as T;
-                            }
-                        }
-
-                        if (retVal == null)
-                        {
-                            log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile,
-                                log.FormatResourceString("General.IncompatibleStateFileType"));
-                        }
-                    }
-                }
-            }
-            catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
+            if (string.IsNullOrEmpty(stateFile))
             {
-                // The deserialization process seems like it can throw just about
-                // any exception imaginable.  Catch them all here.
-                // Not being able to deserialize the cache is not an error, but we let the user know anyway.
-                // Don't want to hold up processing just because we couldn't read the file.
-                log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, e.Message);
+                return null;
             }
 
-            return retVal;
+            return DeserializeCache<T>(new AbsolutePath(stateFile, ignoreRootedCheck: true), log);
         }
 
-
         /// <summary>
         /// Reads the specified file from disk into a StateFileBase derived object.
         /// </summary>

From 04583ae33431ea27733a7b5dbd988b171a145a81 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 16 Apr 2026 17:19:34 +0200
Subject: [PATCH 19/29] Address review feedback for tests.

---
 .../AssemblyDependency/Miscellaneous.cs       | 40 ++++++++++---------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
index c534edee8bd..5c0bb09e666 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
@@ -1168,7 +1168,7 @@ public void InvalidOrEmptyAppConfig_DoesNotCrash(string appConfigFile, bool expe
 
             t.BuildEngine = new MockEngine(_output);
             t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
-            t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
+            t.Assemblies = [new TaskItem("mscorlib")];
             t.AppConfigFile = appConfigFile;
 
             bool retval = Execute(t);
@@ -1182,27 +1182,31 @@ public void InvalidOrEmptyAppConfig_DoesNotCrash(string appConfigFile, bool expe
         /// </summary>
         [Fact]
         public void EmptyAppConfigFile_Wave18_6_Disabled_Fails()
-        {
-            using TestEnvironment env = TestEnvironment.Create(_output);
-
-            ChangeWaves.ResetStateForTests();
-            env.SetEnvironmentVariable("MSBUILDDISABLEFEATURESFROMVERSION", ChangeWaves.Wave18_6.ToString());
-            BuildEnvironmentHelper.ResetInstance_ForUnitTestsOnly();
-
-            ResolveAssemblyReference t = new ResolveAssemblyReference();
+        {            
+            try
+            {
+                using TestEnvironment env = TestEnvironment.Create(_output);
 
-            MockEngine engine = new MockEngine(_output);
-            t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
-            t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
-            t.AppConfigFile = string.Empty;
+                ChangeWaves.ResetStateForTests();
+                env.SetEnvironmentVariable("MSBUILDDISABLEFEATURESFROMVERSION", ChangeWaves.Wave18_6.ToString());
+                BuildEnvironmentHelper.ResetInstance_ForUnitTestsOnly();
 
-            bool retval = Execute(t);
+                ResolveAssemblyReference t = new ResolveAssemblyReference();
 
-            retval.ShouldBeFalse();
-            engine.Errors.ShouldBe(1);
+                MockEngine engine = new MockEngine(_output);
+                t.BuildEngine = engine;
+                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
+                t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
+                t.AppConfigFile = string.Empty;
 
-            ChangeWaves.ResetStateForTests();
+                bool retval = Execute(t);
+                retval.ShouldBeFalse();
+                engine.Errors.ShouldBe(1);
+            }
+            finally
+            {
+                ChangeWaves.ResetStateForTests();
+            }
         }
 
         /// <summary>

From 289e6daffe0552a4b728d14f48f06c584e5b6ee5 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 14:21:08 +0200
Subject: [PATCH 20/29] Place inputs absolutization under a changewave.
 Canonicalize the paths with a try-cacth fallback. Those paths should be
 already absolute and in a canoniocal form.

---
 src/Tasks/AssemblyDependency/Reference.cs     |  1 +
 .../AssemblyDependency/ReferenceTable.cs      |  9 ++-
 .../ResolveAssemblyReference.cs               | 66 +++++++++++++++----
 src/Tasks/Microsoft.Build.Tasks.csproj        |  1 +
 src/Tasks/Resources/Strings.resx              |  3 +
 src/Tasks/Resources/xlf/Strings.cs.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.de.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.es.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.fr.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.it.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.ja.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.ko.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.pl.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.pt-BR.xlf     |  5 ++
 src/Tasks/Resources/xlf/Strings.ru.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.tr.xlf        |  5 ++
 src/Tasks/Resources/xlf/Strings.zh-Hans.xlf   |  5 ++
 src/Tasks/Resources/xlf/Strings.zh-Hant.xlf   |  5 ++
 src/Tasks/SystemState.cs                      |  4 +-
 src/Tasks/TaskEnvironmentExtensions.cs        | 33 ++++++++++
 20 files changed, 166 insertions(+), 16 deletions(-)
 create mode 100644 src/Tasks/TaskEnvironmentExtensions.cs

diff --git a/src/Tasks/AssemblyDependency/Reference.cs b/src/Tasks/AssemblyDependency/Reference.cs
index 20aa8c4c8c5..904de032813 100644
--- a/src/Tasks/AssemblyDependency/Reference.cs
+++ b/src/Tasks/AssemblyDependency/Reference.cs
@@ -821,6 +821,7 @@ internal void AddAssembliesConsideredAndRejected(List<ResolutionSearchLocation>
         /// <summary>
         /// Returns a collection of strings. Each string is the full path to an assembly that was
         /// considered for resolution but then rejected because it wasn't a complete match.
+        /// Note that these paths are not canonicalized — resolvers only absolutize paths, not canonicalize them.
         /// </summary>
         internal List<ResolutionSearchLocation> AssembliesConsideredAndRejected { get; private set; } = new List<ResolutionSearchLocation>();
 
diff --git a/src/Tasks/AssemblyDependency/ReferenceTable.cs b/src/Tasks/AssemblyDependency/ReferenceTable.cs
index aef5d224a70..ac197289389 100644
--- a/src/Tasks/AssemblyDependency/ReferenceTable.cs
+++ b/src/Tasks/AssemblyDependency/ReferenceTable.cs
@@ -1365,7 +1365,14 @@ private void ResolveReference(
             // If the path was resolved, then specify the full path on the reference.
             if (resolvedPath != null)
             {
-                resolvedPath = FileUtilities.FixFilePath(_taskEnvironment.GetAbsolutePath(resolvedPath).GetCanonicalForm()).Value;
+                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                {
+                    resolvedPath = FileUtilities.FixFilePath(_taskEnvironment.GetAbsolutePath(resolvedPath).GetCanonicalForm()).Value;
+                }
+                else
+                {
+                    resolvedPath = FileUtilities.NormalizePath(_taskEnvironment.GetAbsolutePath(resolvedPath));
+                }
                 if (isImmutableFrameworkReference)
                 {
                     _externallyResolvedImmutableFiles[resolvedPath] = GetAssemblyNameFromItemMetadata(reference.PrimarySourceItem);
diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 49d032a32a0..9aab229ef6c 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
@@ -300,8 +300,7 @@ public string[] LatestTargetFrameworkDirectories
 
             set
             {
-                _latestTargetFrameworkDirectories = value?.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray() ?? [];
+                _latestTargetFrameworkDirectories = MakeCanonicalPaths(value);
             }
         }
 
@@ -409,8 +408,7 @@ public string[] CandidateAssemblyFiles
             }
             set
             {
-                _candidateAssemblyFiles = value?.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray() ?? [];
+                _candidateAssemblyFiles = MakeAbsolutePaths(value);
             }
         }
 
@@ -438,8 +436,7 @@ public string[] TargetFrameworkDirectories
             }
             set
             {
-                _targetFrameworkDirectories = value?.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray() ?? [];
+                _targetFrameworkDirectories = MakeCanonicalPaths(value);
             }
         }
 
@@ -619,7 +616,7 @@ public string AssemblyInformationCacheOutputPath
             {
                 if (!string.IsNullOrEmpty(value))
                 {
-                    _assemblyInformationCacheOutputPath = TaskEnvironment.GetAbsolutePath(value);
+                    _assemblyInformationCacheOutputPath = MakeAbsolutePath(value);
                 }
             }
         }
@@ -709,7 +706,7 @@ public string AppConfigFile
             { 
                 if (!string.IsNullOrEmpty(value))
                 {
-                    _appConfigFile = TaskEnvironment.GetAbsolutePath(value);
+                    _appConfigFile = MakeAbsolutePath(value);
                 }
                 else if (value == string.Empty && !ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
                 {
@@ -807,7 +804,7 @@ public string StateFile
             { 
                 if (!string.IsNullOrEmpty(value))
                 {
-                    _stateFile = TaskEnvironment.GetAbsolutePath(value).GetCanonicalForm();
+                    _stateFile = MakeAbsolutePath(value);
                 }
             }
         }
@@ -959,8 +956,7 @@ public string[] FullFrameworkFolders
             set
             {
                 ErrorUtilities.VerifyThrowArgumentNull(value, "FullFrameworkFolders");
-                _fullFrameworkFolders = value.Select(
-                    path => string.IsNullOrEmpty(path) ? default : TaskEnvironment.GetAbsolutePath(path).GetCanonicalForm()).ToArray();
+                _fullFrameworkFolders = MakeCanonicalPaths(value);
             }
         }
 
@@ -1136,6 +1132,50 @@ public ITaskItem[] UnresolvedAssemblyConflicts
             get => [.. _unresolvedConflicts];
             internal set => _unresolvedConflicts = [.. value];
         }
+        
+        /// <summary>
+        /// Converts a path to an <see cref="AbsolutePath"/>.
+        /// Under Wave 18.6, absolutizes relative paths via <see cref="TaskEnvironment"/>.
+        /// Otherwise, wraps the raw string to preserve pre-wave behavior.
+        /// </summary>
+        private AbsolutePath MakeAbsolutePath(string path)
+        {
+            return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6)
+                ? TaskEnvironment.GetAbsolutePath(path)
+                : new AbsolutePath(path, ignoreRootedCheck: true);
+        }
+
+        /// <summary>
+        /// Converts each non-empty path in the array to an <see cref="AbsolutePath"/>.
+        /// Returns an empty array if <paramref name="paths"/> is null.
+        /// </summary>
+        private AbsolutePath[] MakeAbsolutePaths(string[] paths)
+        {
+            return paths?.Select(
+                path => string.IsNullOrEmpty(path) ? default : MakeAbsolutePath(path)).ToArray() ?? [];
+        }
+
+        /// <summary>
+        /// Converts a path to an <see cref="AbsolutePath"/> in canonical form (resolves ".." etc.).
+        /// Canonical form is needed for paths used in string comparisons.
+        /// Under Wave 18.6, absolutizes and canonicalizes. Otherwise, wraps the raw string.
+        /// </summary>
+        private AbsolutePath MakeCanonicalPath(string path)
+        {
+            return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6)
+                ? TaskEnvironment.GetAbsolutePath(path).TryGetCanonicalForm(Log)
+                : new AbsolutePath(path, ignoreRootedCheck: true);
+        }
+
+        /// <summary>
+        /// Converts each non-empty path in the array to a canonical <see cref="AbsolutePath"/>.
+        /// Returns an empty array if <paramref name="paths"/> is null.
+        /// </summary>
+        private AbsolutePath[] MakeCanonicalPaths(string[] paths)
+        {
+            return paths?.Select(
+                path => string.IsNullOrEmpty(path) ? default : MakeCanonicalPath(path)).ToArray() ?? [];
+        }
 
         #endregion
         #region Logging
@@ -2171,7 +2211,7 @@ internal void WriteStateFile()
         {
             if (_assemblyInformationCacheOutputPath.Value is not null)
             {
-                _cache.SerializePrecomputedCache(_assemblyInformationCacheOutputPath.Value, Log);
+                _cache.SerializePrecomputedCache(_assemblyInformationCacheOutputPath, Log);
             }
             else if (_stateFile.Value is not null && (_cache.IsDirty || _cache.instanceLocalOutgoingFileStateCache.Count < _cache.instanceLocalFileStateCache.Count))
             {
diff --git a/src/Tasks/Microsoft.Build.Tasks.csproj b/src/Tasks/Microsoft.Build.Tasks.csproj
index b5a8e2898ac..faf45491f09 100644
--- a/src/Tasks/Microsoft.Build.Tasks.csproj
+++ b/src/Tasks/Microsoft.Build.Tasks.csproj
@@ -252,6 +252,7 @@
     <Compile Include="system.design\stronglytypedresourcebuilder.cs" />
     <Compile Include="TaskExtension.cs" />
     <Compile Include="TaskTranslatorHelpers.cs" />
+    <Compile Include="TaskEnvironmentExtensions.cs" />
     <Compile Include="Telemetry.cs" />
     <Compile Include="ToolTaskExtension.cs" />
     <Compile Include="Touch.cs" />
diff --git a/src/Tasks/Resources/Strings.resx b/src/Tasks/Resources/Strings.resx
index fb697866cd8..36b081a1e5a 100644
--- a/src/Tasks/Resources/Strings.resx
+++ b/src/Tasks/Resources/Strings.resx
@@ -500,6 +500,9 @@
   <data name="General.ExpectedFileMissing">
     <value>Expected file "{0}" does not exist.</value>
   </data>
+  <data name="General.FailedToCanonicalizePath">
+    <value>Could not canonicalize path "{0}": {1}. The path will be used as-is.</value>
+  </data>
   <data name="General.FrameworksFileNotFound">
     <value>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</value>
     <comment>{StrBegin="MSB3082: "}</comment>
diff --git a/src/Tasks/Resources/xlf/Strings.cs.xlf b/src/Tasks/Resources/xlf/Strings.cs.xlf
index dde273ca0ae..8763eda1d85 100644
--- a/src/Tasks/Resources/xlf/Strings.cs.xlf
+++ b/src/Tasks/Resources/xlf/Strings.cs.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Očekávaný soubor {0} neexistuje.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: Úloha se nezdařila, protože nebyla nalezena položka {0} nebo není nainstalováno rozhraní .NET Framework {1}.  Nainstalujte rozhraní .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.de.xlf b/src/Tasks/Resources/xlf/Strings.de.xlf
index 99732a18ae6..2e11f7817cf 100644
--- a/src/Tasks/Resources/xlf/Strings.de.xlf
+++ b/src/Tasks/Resources/xlf/Strings.de.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Die erwartete Datei "{0}" ist nicht vorhanden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: Fehler bei der Aufgabe. "{0}" wurde nicht gefunden, oder .NET Framework {1} ist nicht installiert.  Installieren Sie .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.es.xlf b/src/Tasks/Resources/xlf/Strings.es.xlf
index 2ba711a7b04..f90964da4d9 100644
--- a/src/Tasks/Resources/xlf/Strings.es.xlf
+++ b/src/Tasks/Resources/xlf/Strings.es.xlf
@@ -619,6 +619,11 @@
         <target state="translated">El archivo esperado "{0}" no existe.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: Error en la tarea porque no se encuentra "{0}" o .NET Framework {1} no está instalado.  Instale .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.fr.xlf b/src/Tasks/Resources/xlf/Strings.fr.xlf
index a1bbc4343c5..fdbd95833c2 100644
--- a/src/Tasks/Resources/xlf/Strings.fr.xlf
+++ b/src/Tasks/Resources/xlf/Strings.fr.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Le fichier attendu "{0}" n'existe pas.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: La tâche a échoué, car "{0}" est introuvable ou le .NET Framework {1} n'est pas installé.  Installez le .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.it.xlf b/src/Tasks/Resources/xlf/Strings.it.xlf
index b5aba491c4a..80e39029e09 100644
--- a/src/Tasks/Resources/xlf/Strings.it.xlf
+++ b/src/Tasks/Resources/xlf/Strings.it.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Il file previsto "{0}" non esiste.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: l'attività non è riuscita perché "{0}" non è stato trovato oppure perché .NET Framework {1} non è installato. Installare .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.ja.xlf b/src/Tasks/Resources/xlf/Strings.ja.xlf
index 1c9a490b7e7..ed660e92eb6 100644
--- a/src/Tasks/Resources/xlf/Strings.ja.xlf
+++ b/src/Tasks/Resources/xlf/Strings.ja.xlf
@@ -619,6 +619,11 @@
         <target state="translated">指定されたファイル "{0}" は存在しません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: "{0}" が見つからなかったため、または .NET Framework {1} がインストールされていないため、タスクに失敗しました。.NET Framework {1} をインストールしてください。</target>
diff --git a/src/Tasks/Resources/xlf/Strings.ko.xlf b/src/Tasks/Resources/xlf/Strings.ko.xlf
index 5a2d828cb01..d59ef01ca32 100644
--- a/src/Tasks/Resources/xlf/Strings.ko.xlf
+++ b/src/Tasks/Resources/xlf/Strings.ko.xlf
@@ -619,6 +619,11 @@
         <target state="translated">필요한 "{0}" 파일이 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: "{0}"이(가) 없거나 .NET Framework {1}이(가) 설치되어 있지 않아 작업을 수행하지 못했습니다.  .NET Framework {1}을(를) 설치하세요.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.pl.xlf b/src/Tasks/Resources/xlf/Strings.pl.xlf
index 8e8b2953fcb..d8e4a416b28 100644
--- a/src/Tasks/Resources/xlf/Strings.pl.xlf
+++ b/src/Tasks/Resources/xlf/Strings.pl.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Oczekiwany plik „{0}” nie istnieje.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: Zadanie zakończyło się niepowodzeniem, ponieważ nie można odnaleźć „{0}” lub program .NET Framework {1} nie jest zainstalowany.  Zainstaluj program .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.pt-BR.xlf b/src/Tasks/Resources/xlf/Strings.pt-BR.xlf
index bdbc7054eee..ab704580f70 100644
--- a/src/Tasks/Resources/xlf/Strings.pt-BR.xlf
+++ b/src/Tasks/Resources/xlf/Strings.pt-BR.xlf
@@ -619,6 +619,11 @@
         <target state="translated">O arquivo esperado "{0}" não existe.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: Falha na tarefa porque "{0}" não foi encontrado ou o .NET Framework {1} não está instalado.  Instale o .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.ru.xlf b/src/Tasks/Resources/xlf/Strings.ru.xlf
index f5fedc7bcbe..8b4dc9b0f24 100644
--- a/src/Tasks/Resources/xlf/Strings.ru.xlf
+++ b/src/Tasks/Resources/xlf/Strings.ru.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Ожидаемый файл "{0}" не существует.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: задача не выполнена, так как не найден "{0}" или не установлена платформа .NET Framework {1}.  Установите .NET Framework {1}.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.tr.xlf b/src/Tasks/Resources/xlf/Strings.tr.xlf
index 88671129bf6..f9aa3b163ce 100644
--- a/src/Tasks/Resources/xlf/Strings.tr.xlf
+++ b/src/Tasks/Resources/xlf/Strings.tr.xlf
@@ -619,6 +619,11 @@
         <target state="translated">Beklenen "{0}" dosyası yok.</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: "{0}" bulunamadığından veya .NET Framework {1} yüklü olmadığından görev başarısız oldu.  Lütfen .NET Framework {1} yükleyin.</target>
diff --git a/src/Tasks/Resources/xlf/Strings.zh-Hans.xlf b/src/Tasks/Resources/xlf/Strings.zh-Hans.xlf
index 85c481533a7..a6d4a4b1a3c 100644
--- a/src/Tasks/Resources/xlf/Strings.zh-Hans.xlf
+++ b/src/Tasks/Resources/xlf/Strings.zh-Hans.xlf
@@ -619,6 +619,11 @@
         <target state="translated">所需文件“{0}”不存在。</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: 任务失败，因为未找到“{0}”，或者未安装 .NET Framework {1}。请安装 .NET Framework {1}。</target>
diff --git a/src/Tasks/Resources/xlf/Strings.zh-Hant.xlf b/src/Tasks/Resources/xlf/Strings.zh-Hant.xlf
index f5241dfc562..d62791bd214 100644
--- a/src/Tasks/Resources/xlf/Strings.zh-Hant.xlf
+++ b/src/Tasks/Resources/xlf/Strings.zh-Hant.xlf
@@ -619,6 +619,11 @@
         <target state="translated">預期的檔案 "{0}" 不存在。</target>
         <note />
       </trans-unit>
+      <trans-unit id="General.FailedToCanonicalizePath">
+        <source>Could not canonicalize path "{0}": {1}. The path will be used as-is.</source>
+        <target state="new">Could not canonicalize path "{0}": {1}. The path will be used as-is.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="General.FrameworksFileNotFound">
         <source>MSB3082: Task failed because "{0}" was not found, or the .NET Framework {1} is not installed.  Please install the .NET Framework {1}.</source>
         <target state="translated">MSB3082: 工作失敗，因為找不到 "{0}" 或者未安裝 .NET Framework {1}。請安裝 .NET Framework {1}。</target>
diff --git a/src/Tasks/SystemState.cs b/src/Tasks/SystemState.cs
index 15b01d6496d..563623f357a 100644
--- a/src/Tasks/SystemState.cs
+++ b/src/Tasks/SystemState.cs
@@ -618,7 +618,7 @@ internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles,
         /// </summary>
         /// <param name="stateFile">Path to which to write the precomputed cache</param>
         /// <param name="log">How to log</param>
-        internal void SerializePrecomputedCache(string stateFile, TaskLoggingHelper log)
+        internal void SerializePrecomputedCache(AbsolutePath stateFile, TaskLoggingHelper log)
         {
             // Save a copy of instanceLocalOutgoingFileStateCache so we can restore it later. SerializeCacheByTranslator serializes
             // instanceLocalOutgoingFileStateCache by default, so change that to the relativized form, then change it back.
@@ -629,7 +629,7 @@ internal void SerializePrecomputedCache(string stateFile, TaskLoggingHelper log)
             {
                 if (FileUtilities.FileExistsNoThrow(stateFile))
                 {
-                    log.LogWarningWithCodeFromResources("General.StateFileAlreadyPresent", stateFile);
+                    log.LogWarningWithCodeFromResources("General.StateFileAlreadyPresent", stateFile.OriginalValue);
                 }
                 SerializeCache(stateFile, log);
             }
diff --git a/src/Tasks/TaskEnvironmentExtensions.cs b/src/Tasks/TaskEnvironmentExtensions.cs
new file mode 100644
index 00000000000..7b6b8bdcdaa
--- /dev/null
+++ b/src/Tasks/TaskEnvironmentExtensions.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace Microsoft.Build.Tasks
+{
+    /// <summary>
+    /// Extension methods for <see cref="TaskEnvironment"/> used by built-in tasks.
+    /// </summary>
+    internal static class TaskEnvironmentExtensions
+    {
+        /// <summary>
+        /// Tries to return the canonical form of an <see cref="AbsolutePath"/> (resolving ".." segments, etc.).
+        /// On .NET Framework, <see cref="System.IO.Path.GetFullPath(string)"/> validates path characters and throws
+        /// for illegal characters. In that case the original absolute path is returned as-is and a message is logged.
+        /// </summary>
+        internal static AbsolutePath TryGetCanonicalForm(this AbsolutePath absolutePath, TaskLoggingHelper log)
+        {
+            try
+            {
+                return absolutePath.GetCanonicalForm();
+            }
+            catch (Exception e)
+            {
+                log.LogMessageFromResources(MessageImportance.Low, "General.FailedToCanonicalizePath", absolutePath.Value, e.Message);
+                return absolutePath;
+            }
+        }
+    }
+}

From 6979b95c4c684587f912f293149f15527af3840f Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 14:50:12 +0200
Subject: [PATCH 21/29] Ensure that canonicalization in AssemblyTableInfo does
 not throw.

---
 .../ResolveAssemblyReference.cs                  |  4 ++--
 src/Tasks/AssemblyDependency/Resolver.cs         |  2 +-
 src/Tasks/RedistList.cs                          | 16 +++++++++-------
 src/Tasks/TaskEnvironmentExtensions.cs           | 12 ++++++++----
 4 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 9aab229ef6c..2a075c58278 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -3188,7 +3188,7 @@ private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAs
                     string[] listPaths = GetAssemblyListPaths(targetFrameworkDirectory);
                     foreach (string listPath in listPaths)
                     {
-                        tableMap[listPath] = new AssemblyTableInfo(listPath, targetFrameworkDirectory, TaskEnvironment);
+                        tableMap[listPath] = AssemblyTableInfo.CreateFromRelativePath(listPath, targetFrameworkDirectory, TaskEnvironment, Log);
                     }
                 }
             }
@@ -3212,7 +3212,7 @@ private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAs
                     }
                 }
 
-                tableMap[installedAssemblyTable.ItemSpec] = new AssemblyTableInfo(installedAssemblyTable.ItemSpec, frameworkDirectory, TaskEnvironment);
+                tableMap[installedAssemblyTable.ItemSpec] = AssemblyTableInfo.CreateFromRelativePath(installedAssemblyTable.ItemSpec, frameworkDirectory, TaskEnvironment, Log);
             }
 
             AssemblyTableInfo[] extensions = new AssemblyTableInfo[tableMap.Count];
diff --git a/src/Tasks/AssemblyDependency/Resolver.cs b/src/Tasks/AssemblyDependency/Resolver.cs
index 3656ddc262f..1f134ffe56f 100644
--- a/src/Tasks/AssemblyDependency/Resolver.cs
+++ b/src/Tasks/AssemblyDependency/Resolver.cs
@@ -299,7 +299,7 @@ protected bool FileMatchesAssemblyName(
         /// <param name="isPrimaryProjectReference">True if this is a primary reference directly from the project file.</param>
         /// <param name="wantSpecificVersion">Whether an exact version match is requested.</param>
         /// <param name="executableExtensions">The possible filename extensions of the assembly. Must be one of these or its no match.</param>
-        /// <param name="fullPathToDirectory">Fully qualified path to the directory to look in</param>
+        /// <param name="fullPathToDirectory">Absolute path to the directory to look in. May not be in canonical form.</param>
         /// <param name="assembliesConsideredAndRejected">Receives the list of locations that this function tried to find the assembly. May be "null".</param>
         /// <returns>'null' if the assembly wasn't found.</returns>
         protected string ResolveFromDirectory(
diff --git a/src/Tasks/RedistList.cs b/src/Tasks/RedistList.cs
index cf4531720aa..e549403c2f4 100644
--- a/src/Tasks/RedistList.cs
+++ b/src/Tasks/RedistList.cs
@@ -979,15 +979,17 @@ internal class AssemblyTableInfo : IComparable
         private string _descriptor;
 
         /// <summary>
-        /// Constructor that converts relative paths to absolute paths using TaskEnvironment.
+        /// Creates an <see cref="AssemblyTableInfo"/> from a potentially relative path,
+        /// absolutizing it and canonicalizing it if possible using the provided <paramref name="taskEnvironment"/>.
         /// </summary>
-        /// <param name="path">Path to the assembly table file (can be relative)</param>
-        /// <param name="frameworkDirectory">Framework directory path</param>
-        /// <param name="taskEnvironment">TaskEnvironment for path conversion</param>
-        internal AssemblyTableInfo(string path, string frameworkDirectory, TaskEnvironment taskEnvironment)
+        /// <param name="path">Path to the assembly table file (can be relative).</param>
+        /// <param name="frameworkDirectory">Framework directory path.</param>
+        /// <param name="taskEnvironment">TaskEnvironment for path conversion.</param>
+        /// <param name="log">Logger for diagnostic messages when canonicalization fails.</param>
+        internal static AssemblyTableInfo CreateFromRelativePath(string path, string frameworkDirectory, TaskEnvironment taskEnvironment, TaskLoggingHelper log)
         {
-            Path = taskEnvironment.GetAbsolutePath(FileUtilities.NormalizeForPathComparison(path)).GetCanonicalForm();
-            FrameworkDirectory = FileUtilities.NormalizeForPathComparison(frameworkDirectory);
+            AbsolutePath canonicalPath = taskEnvironment.GetAbsolutePath(FileUtilities.NormalizeForPathComparison(path)).TryGetCanonicalForm(log);
+            return new AssemblyTableInfo(canonicalPath, FileUtilities.NormalizeForPathComparison(frameworkDirectory));
         }
 
         /// <summary>
diff --git a/src/Tasks/TaskEnvironmentExtensions.cs b/src/Tasks/TaskEnvironmentExtensions.cs
index 7b6b8bdcdaa..b6a8a55a006 100644
--- a/src/Tasks/TaskEnvironmentExtensions.cs
+++ b/src/Tasks/TaskEnvironmentExtensions.cs
@@ -14,10 +14,14 @@ internal static class TaskEnvironmentExtensions
     {
         /// <summary>
         /// Tries to return the canonical form of an <see cref="AbsolutePath"/> (resolving ".." segments, etc.).
-        /// On .NET Framework, <see cref="System.IO.Path.GetFullPath(string)"/> validates path characters and throws
-        /// for illegal characters. In that case the original absolute path is returned as-is and a message is logged.
+        /// <see cref="System.IO.Path.GetFullPath(string)"/> on .NET Framework validates path characters and throws
+        /// <see cref="ArgumentException"/> for illegal characters (e.g. <c>|</c>, <c>&lt;</c>, <c>&gt;</c>).
+        /// .NET Core is more permissive and delegates character validation to the OS.
+        /// When canonicalization fails, the original absolute path is returned as-is.
         /// </summary>
-        internal static AbsolutePath TryGetCanonicalForm(this AbsolutePath absolutePath, TaskLoggingHelper log)
+        /// <param name="absolutePath">The absolute path to canonicalize.</param>
+        /// <param name="log">Optional logger. When provided, a low-importance diagnostic message is logged on failure.</param>
+        internal static AbsolutePath TryGetCanonicalForm(this AbsolutePath absolutePath, TaskLoggingHelper? log = null)
         {
             try
             {
@@ -25,7 +29,7 @@ internal static AbsolutePath TryGetCanonicalForm(this AbsolutePath absolutePath,
             }
             catch (Exception e)
             {
-                log.LogMessageFromResources(MessageImportance.Low, "General.FailedToCanonicalizePath", absolutePath.Value, e.Message);
+                log?.LogMessageFromResources(MessageImportance.Low, "General.FailedToCanonicalizePath", absolutePath.Value, e.Message);
                 return absolutePath;
             }
         }

From 74ad0ec7955632062f3995da43ac1b20188dee3f Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 14:59:18 +0200
Subject: [PATCH 22/29] Remove unnecessary GetCanonicalForm in SystemState.cs

---
 src/Tasks/SystemState.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Tasks/SystemState.cs b/src/Tasks/SystemState.cs
index 563623f357a..5d27f71fd04 100644
--- a/src/Tasks/SystemState.cs
+++ b/src/Tasks/SystemState.cs
@@ -573,7 +573,7 @@ internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles,
                 string stateFilePath = null;
                 if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
                 {
-                    AbsolutePath stateFileAbsolutePath = taskEnvironment.GetAbsolutePath(stateFile.ItemSpec).GetCanonicalForm();
+                    AbsolutePath stateFileAbsolutePath = taskEnvironment.GetAbsolutePath(stateFile.ItemSpec);
                     stateFilePath = stateFileAbsolutePath.Value;
 
                     // Verify that it's a real stateFile. Log message but do not error if not.

From 47bb6601d2304a4d060f75a04369a52fe30e95fd Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 15:24:47 +0200
Subject: [PATCH 23/29] Remove path canonization and thus unnecessary cache in
 the InstalledSDKResolver.cs

---
 src/Tasks/InstalledSDKResolver.cs | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/src/Tasks/InstalledSDKResolver.cs b/src/Tasks/InstalledSDKResolver.cs
index 6c9feb32df5..631f631b808 100644
--- a/src/Tasks/InstalledSDKResolver.cs
+++ b/src/Tasks/InstalledSDKResolver.cs
@@ -21,11 +21,6 @@ internal class InstalledSDKResolver : Resolver
         /// </summary>
         private readonly Dictionary<string, ITaskItem> _resolvedSDKs;
 
-        /// <summary>
-        /// Cached absolute paths for resolved SDKs
-        /// </summary>
-        private readonly Dictionary<string, string> _resolvedSDKPaths;
-
         /// <summary>
         /// Construct.
         /// </summary>
@@ -33,13 +28,6 @@ public InstalledSDKResolver(Dictionary<string, ITaskItem> resolvedSDKs, string s
             : base(searchPathElement, getAssemblyName, fileExists, getRuntimeVersion, targetedRuntimeVesion, System.Reflection.ProcessorArchitecture.None, false, taskEnvironment)
         {
             _resolvedSDKs = resolvedSDKs;
-            _resolvedSDKPaths = new Dictionary<string, string>(resolvedSDKs.Count, resolvedSDKs.Comparer);
-            
-            // Cache absolute paths to avoid repeated TaskEnvironment.GetAbsolutePath calls
-            foreach (var kvp in resolvedSDKs)
-            {
-                _resolvedSDKPaths[kvp.Key] = taskEnvironment.GetAbsolutePath(kvp.Value.ItemSpec).GetCanonicalForm();
-            }
         }
 
         /// <inheritdoc/>
@@ -63,8 +51,9 @@ public override bool Resolve(
             if (assemblyName != null)
             {
                 // We have found a resolved SDK item that matches the one on the reference items.
-                if (_resolvedSDKs.TryGetValue(sdkName, out ITaskItem resolvedSDK) && _resolvedSDKPaths.TryGetValue(sdkName, out string sdkDirectory))
+                if (_resolvedSDKs.TryGetValue(sdkName, out ITaskItem resolvedSDK))
                 {
+                    string sdkDirectory = taskEnvironment.GetAbsolutePath(resolvedSDK.ItemSpec).Value;
                     string configuration = resolvedSDK.GetMetadata("TargetedSDKConfiguration");
                     string architecture = resolvedSDK.GetMetadata("TargetedSDKArchitecture");
 

From e24663919785afd27a8f889c3a0d6419b3d91509 Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 15:41:19 +0200
Subject: [PATCH 24/29] Refactor IsFrameworkFile functions.

---
 src/Tasks/AssemblyDependency/Reference.cs | 26 ++++++++++-------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/Reference.cs b/src/Tasks/AssemblyDependency/Reference.cs
index 904de032813..8eef0415c57 100644
--- a/src/Tasks/AssemblyDependency/Reference.cs
+++ b/src/Tasks/AssemblyDependency/Reference.cs
@@ -923,13 +923,7 @@ internal static bool IsFrameworkFile(string fullPath, string[] frameworkPaths)
             {
                 foreach (string frameworkPath in frameworkPaths)
                 {
-                    if
-                    (
-                        String.Compare(
-                            frameworkPath, 0,
-                            fullPath, 0,
-                            frameworkPath.Length,
-                            StringComparison.OrdinalIgnoreCase) == 0)
+                    if (IsUnderDirectory(fullPath, frameworkPath))
                     {
                         return true;
                     }
@@ -950,14 +944,7 @@ internal static bool IsFrameworkFile(string fullPath, AbsolutePath[] frameworkPa
             {
                 foreach (var frameworkPath in frameworkPaths)
                 {
-                    if
-                    (
-                        frameworkPath.Value is not null &&
-                        String.Compare(
-                            frameworkPath.Value, 0,
-                            fullPath, 0,
-                            frameworkPath.Value.Length,
-                            StringComparison.OrdinalIgnoreCase) == 0)
+                    if (IsUnderDirectory(fullPath, frameworkPath.Value))
                     {
                         return true;
                     }
@@ -966,6 +953,15 @@ frameworkPath.Value is not null &&
             return false;
         }
 
+        /// <summary>
+        /// Checks whether <paramref name="fullPath"/> starts with <paramref name="directoryPath"/> (case-insensitive).
+        /// </summary>
+        private static bool IsUnderDirectory(string fullPath, string directoryPath)
+        {
+            return directoryPath is not null &&
+                String.Compare(directoryPath, 0, fullPath, 0, directoryPath.Length, StringComparison.OrdinalIgnoreCase) == 0;
+        }
+
         /// <summary>
         /// Figure out the what the CopyLocal state of given assembly should be.
         /// </summary>

From 5a9d94e541205eb2d2ec4339643f3fb2a3aa9dcd Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 15:49:34 +0200
Subject: [PATCH 25/29] Defensively absolutize paths from registry.

---
 src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
index b5a16cfdce2..6919e577421 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersExResolver.cs
@@ -212,8 +212,10 @@ public override bool Resolve(
                     {
                         foreach (AssemblyFoldersExInfo assemblyFolder in _assemblyFoldersCache.AssemblyFoldersEx)
                         {
-                            // assemblyFolder.DirectoryPath is assumed to be absolute path as it was taken from registry.
-                            string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, assemblyFolder.DirectoryPath, assembliesConsideredAndRejected);
+                            // Defensively absolutize the directory path — it comes from the registry and should be absolute,
+                            // but we enforce it rather than assume it.
+                            string directoryPath = taskEnvironment.GetAbsolutePath(assemblyFolder.DirectoryPath).Value;
+                            string candidatePath = ResolveFromDirectory(assemblyName, isPrimaryProjectReference, wantSpecificVersion, executableExtensions, directoryPath, assembliesConsideredAndRejected);
 
                             // We have a full path returned
                             if (candidatePath != null)

From 627af671397c49934ced0229270fe8316de858dc Mon Sep 17 00:00:00 2001
From: AR-May <67507805+AR-May@users.noreply.github.com>
Date: Thu, 23 Apr 2026 15:58:20 +0200
Subject: [PATCH 26/29] Refactor the helper methods in RAR task

---
 .../ResolveAssemblyReference.cs               | 33 +++++++++----------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 2a075c58278..e4ed25ae768 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -614,10 +614,7 @@ public string AssemblyInformationCacheOutputPath
             get => _assemblyInformationCacheOutputPath.OriginalValue;
             set
             {
-                if (!string.IsNullOrEmpty(value))
-                {
-                    _assemblyInformationCacheOutputPath = MakeAbsolutePath(value);
-                }
+                _assemblyInformationCacheOutputPath = MakeAbsolutePath(value);
             }
         }
 
@@ -802,10 +799,7 @@ public string StateFile
             get => _stateFile.OriginalValue;
             set 
             { 
-                if (!string.IsNullOrEmpty(value))
-                {
-                    _stateFile = MakeAbsolutePath(value);
-                }
+                _stateFile = MakeAbsolutePath(value);
             }
         }
 
@@ -1134,12 +1128,17 @@ public ITaskItem[] UnresolvedAssemblyConflicts
         }
         
         /// <summary>
-        /// Converts a path to an <see cref="AbsolutePath"/>.
+        /// Converts a path to an <see cref="AbsolutePath"/>. Returns <c>default</c> for null or empty paths.
         /// Under Wave 18.6, absolutizes relative paths via <see cref="TaskEnvironment"/>.
         /// Otherwise, wraps the raw string to preserve pre-wave behavior.
         /// </summary>
         private AbsolutePath MakeAbsolutePath(string path)
         {
+            if (string.IsNullOrEmpty(path))
+            {
+                return default;
+            }
+
             return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6)
                 ? TaskEnvironment.GetAbsolutePath(path)
                 : new AbsolutePath(path, ignoreRootedCheck: true);
@@ -1151,17 +1150,22 @@ private AbsolutePath MakeAbsolutePath(string path)
         /// </summary>
         private AbsolutePath[] MakeAbsolutePaths(string[] paths)
         {
-            return paths?.Select(
-                path => string.IsNullOrEmpty(path) ? default : MakeAbsolutePath(path)).ToArray() ?? [];
+            return paths?.Select(path => MakeAbsolutePath(path)).ToArray() ?? [];
         }
 
         /// <summary>
         /// Converts a path to an <see cref="AbsolutePath"/> in canonical form (resolves ".." etc.).
+        /// Returns <c>default</c> for null or empty paths.
         /// Canonical form is needed for paths used in string comparisons.
         /// Under Wave 18.6, absolutizes and canonicalizes. Otherwise, wraps the raw string.
         /// </summary>
         private AbsolutePath MakeCanonicalPath(string path)
         {
+            if (string.IsNullOrEmpty(path))
+            {
+                return default;
+            }
+
             return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6)
                 ? TaskEnvironment.GetAbsolutePath(path).TryGetCanonicalForm(Log)
                 : new AbsolutePath(path, ignoreRootedCheck: true);
@@ -1173,8 +1177,7 @@ private AbsolutePath MakeCanonicalPath(string path)
         /// </summary>
         private AbsolutePath[] MakeCanonicalPaths(string[] paths)
         {
-            return paths?.Select(
-                path => string.IsNullOrEmpty(path) ? default : MakeCanonicalPath(path)).ToArray() ?? [];
+            return paths?.Select(path => MakeCanonicalPath(path)).ToArray() ?? [];
         }
 
         #endregion
@@ -3394,10 +3397,6 @@ public override bool Execute()
                 }
             }
 
-            // In a multithreaded node, relative paths must be resolved relative to the project directory
-            // rather than the process working directory. AbsolutePath objects are created in property setters
-            // when TaskEnvironment is available, so no additional processing needed here.
-
             return Execute(
                 p => FileUtilities.FileExistsNoThrow(p),
                 p => FileUtilities.DirectoryExistsNoThrow(p),

From b8295a5f9421de90fb47c048aaaae2749ca0b601 Mon Sep 17 00:00:00 2001
From: Jan Provaznik <janprovaznik@microsoft.com>
Date: Mon, 4 May 2026 11:41:53 +0200
Subject: [PATCH 27/29] changewave number

---
 src/Framework/ChangeWaves.cs                           |  3 ++-
 .../AssemblyFoldersFromConfigResolver.cs               |  6 +++---
 src/Tasks/AssemblyDependency/ReferenceTable.cs         |  2 +-
 .../AssemblyDependency/ResolveAssemblyReference.cs     | 10 +++++-----
 src/Tasks/SystemState.cs                               |  2 +-
 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/Framework/ChangeWaves.cs b/src/Framework/ChangeWaves.cs
index 52ab8929eeb..301873a3182 100644
--- a/src/Framework/ChangeWaves.cs
+++ b/src/Framework/ChangeWaves.cs
@@ -35,7 +35,8 @@ internal static class ChangeWaves
         internal static readonly Version Wave18_5 = new Version(18, 5);
         internal static readonly Version Wave18_6 = new Version(18, 6);
         internal static readonly Version Wave18_7 = new Version(18, 7);
-        internal static readonly Version[] AllWaves = [Wave17_10, Wave17_12, Wave17_14, Wave18_3, Wave18_4, Wave18_5, Wave18_6, Wave18_7];
+        internal static readonly Version Wave18_8 = new Version(18, 8);
+        internal static readonly Version[] AllWaves = [Wave17_10, Wave17_12, Wave17_14, Wave18_3, Wave18_4, Wave18_5, Wave18_6, Wave18_7, Wave18_8];
 
         /// <summary>
         /// Special value indicating that all features behind all Change Waves should be enabled.
diff --git a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
index e550c519a60..49427baf978 100644
--- a/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
+++ b/src/Tasks/AssemblyDependency/AssemblyFoldersFromConfig/AssemblyFoldersFromConfigResolver.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
@@ -183,12 +183,12 @@ public override bool Resolve(
                             string directoryPath;
                             if (string.IsNullOrEmpty(assemblyFolder.DirectoryPath))
                             {
-                                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8))
                                 {
                                     continue;
                                 }
 
-                                // Pre-Wave18_6: empty DirectoryPath was passed through and resolved from CWD (project directory).
+                                // Pre-Wave18_8: empty DirectoryPath was passed through and resolved from CWD (project directory).
                                 directoryPath = taskEnvironment.ProjectDirectory.Value;
                             }
                             else
diff --git a/src/Tasks/AssemblyDependency/ReferenceTable.cs b/src/Tasks/AssemblyDependency/ReferenceTable.cs
index ac197289389..ad0fde4c423 100644
--- a/src/Tasks/AssemblyDependency/ReferenceTable.cs
+++ b/src/Tasks/AssemblyDependency/ReferenceTable.cs
@@ -1365,7 +1365,7 @@ private void ResolveReference(
             // If the path was resolved, then specify the full path on the reference.
             if (resolvedPath != null)
             {
-                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8))
                 {
                     resolvedPath = FileUtilities.FixFilePath(_taskEnvironment.GetAbsolutePath(resolvedPath).GetCanonicalForm()).Value;
                 }
diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index e4ed25ae768..639d1300e86 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -705,7 +705,7 @@ public string AppConfigFile
                 {
                     _appConfigFile = MakeAbsolutePath(value);
                 }
-                else if (value == string.Empty && !ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                else if (value == string.Empty && !ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8))
                 {
                     _appConfigValueIsEmptyString = true;
                 }
@@ -1139,7 +1139,7 @@ private AbsolutePath MakeAbsolutePath(string path)
                 return default;
             }
 
-            return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6)
+            return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8)
                 ? TaskEnvironment.GetAbsolutePath(path)
                 : new AbsolutePath(path, ignoreRootedCheck: true);
         }
@@ -1166,7 +1166,7 @@ private AbsolutePath MakeCanonicalPath(string path)
                 return default;
             }
 
-            return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6)
+            return ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8)
                 ? TaskEnvironment.GetAbsolutePath(path).TryGetCanonicalForm(Log)
                 : new AbsolutePath(path, ignoreRootedCheck: true);
         }
@@ -2503,10 +2503,10 @@ internal bool Execute(
                         {
                             appConfigRemappedAssemblies = GetAssemblyRemappingsFromAppConfig();
 
-                            if (!ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6) && _appConfigValueIsEmptyString)
+                            if (!ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8) && _appConfigValueIsEmptyString)
                             {
                                 // Preserve backward compatibility for empty AppConfigFile handling.
-                                // Prior to Wave18_6, empty strings would cause TaskEnvironment.GetAbsolutePath() to throw an exception,
+                                // Prior to Wave18_8, empty strings would cause TaskEnvironment.GetAbsolutePath() to throw an exception,
                                 // which would be caught and logged as an error, stopping RAR execution.
                                 // With the new behavior, empty strings are silently ignored (treated like null).
                                 // When Wave 18.6 is disabled, we preserve the old failure behavior.
diff --git a/src/Tasks/SystemState.cs b/src/Tasks/SystemState.cs
index 5d27f71fd04..ebb88501e8b 100644
--- a/src/Tasks/SystemState.cs
+++ b/src/Tasks/SystemState.cs
@@ -571,7 +571,7 @@ internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles,
             {
                 SystemState sysState = null;
                 string stateFilePath = null;
-                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_6))
+                if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave18_8))
                 {
                     AbsolutePath stateFileAbsolutePath = taskEnvironment.GetAbsolutePath(stateFile.ItemSpec);
                     stateFilePath = stateFileAbsolutePath.Value;

From afd952db07d8d60ec1891222e363e30c71f785c2 Mon Sep 17 00:00:00 2001
From: Jan Provaznik <janprovaznik@microsoft.com>
Date: Mon, 4 May 2026 11:52:32 +0200
Subject: [PATCH 28/29] Remove unnecessary TaskEnvironment =
 TaskEnvironmentHelper.CreateForTest() from tests and change Wave18_6 to
 Wave18_8

Remove property-assignment-style TaskEnvironmentHelper.CreateForTest() additions
from test files where they were not required by production API changes.
Keep method argument additions where production code signatures require them.
Change ChangeWave from 18_6 to 18_8 and add Wave18_8 definition.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../AssemblyFoldersFromConfig_Tests.cs        |   8 +-
 .../AssemblyDependency/FilePrimary.cs         |   8 -
 .../InstalledSDKResolverFixture.cs            |   2 -
 .../AssemblyDependency/Miscellaneous.cs       | 167 +-----------------
 .../Node/OutOfProcRarNode_Tests.cs            |   3 -
 .../Node/RarNodeExecuteRequest_Tests.cs       |   6 +-
 .../NonSpecificVersionStrictPrimary.cs        |   5 -
 .../AssemblyDependency/Perf.cs                |   2 -
 .../SpecificVersionPrimary.cs                 |   5 -
 .../StronglyNamedDependency.cs                |   6 -
 .../StronglyNamedDependencyAppConfig.cs       |  12 --
 .../StronglyNamedDependencyAutoUnify.cs       |   7 -
 .../AssemblyDependency/SuggestedRedirects.cs  |  10 --
 ...erifyIgnoreVersionForFrameworkReference.cs |   6 -
 .../VerifyTargetFrameworkAttribute.cs         |  12 --
 .../VerifyTargetFrameworkHigherThanRedist.cs  |  18 --
 .../AssemblyDependency/WinMDTests.cs          |  16 --
 .../GetReferencePaths_Tests.cs                |   1 -
 src/Tasks.UnitTests/HintPathResolver_Tests.cs |   2 +-
 .../RARPrecomputedCache_Tests.cs              |   5 -
 20 files changed, 8 insertions(+), 293 deletions(-)

diff --git a/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs b/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs
index 9981f8b31ed..53a96f9cb58 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/AssemblyFoldersFromConfig_Tests.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.IO;
@@ -44,7 +44,6 @@ public void AssemblyFoldersFromConfigTest()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig2") },
                     SearchPaths = new[] { moniker }
                 };
@@ -74,7 +73,6 @@ public void AssemblyFoldersFromConfigPlatformSpecificAssemblyFirstTest()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig_common.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "x86"
@@ -105,7 +103,6 @@ public void AssemblyFoldersFromConfigNormalizeNetFrameworkVersion()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("v5assembly.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "x86"
@@ -121,7 +118,6 @@ public void AssemblyFoldersFromConfigNormalizeNetFrameworkVersion()
                 t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("v5assembly.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "AMD64"
@@ -151,7 +147,6 @@ public void AssemblyFoldersFromConfigFileNotFoundTest()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = new MockEngine(_output),
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig_common.dll") },
                     SearchPaths = new[] { moniker },
                     TargetProcessorArchitecture = "x86"
@@ -180,7 +175,6 @@ public void AssemblyFoldersFromConfigFileMalformed()
                 ResolveAssemblyReference t = new ResolveAssemblyReference
                 {
                     BuildEngine = engine,
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     Assemblies = new ITaskItem[] { new TaskItem("assemblyfromconfig2") },
                     SearchPaths = new[] { moniker }
                 };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs b/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs
index 3d1c183593d..a81f24fc635 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/FilePrimary.cs
@@ -62,7 +62,6 @@ public void Exists()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -110,7 +109,6 @@ public void BadAppconfigOldVersion()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -162,7 +160,6 @@ public void BadAppconfigNewVersion()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -239,7 +236,6 @@ public void ExistsPromotedDependencyInTheDenyList()
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblyNames;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -296,7 +292,6 @@ public void ExistsDifferentName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -348,7 +343,6 @@ public void ExistsOldVersionRange()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -400,7 +394,6 @@ public void HighVersionDoesntExist()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -450,7 +443,6 @@ public void LowVersionDoesntExist()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs b/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs
index 04bc52da407..6a214b373d8 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/InstalledSDKResolverFixture.cs
@@ -37,7 +37,6 @@ public void SDkNameNotInResolvedSDKListButOnSearchPath()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.SearchPaths = new String[] { @"C:\FakeSDK\References" };
             bool succeeded = Execute(t);
@@ -84,7 +83,6 @@ private static void ResolveSDKFromRefereneAssemblyLocation(string referenceName,
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.ResolvedSDKReferences = new ITaskItem[] { resolvedSDK };
             t.SearchPaths = new String[] { @"C:\SomeOtherPlace" };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
index 5c0bb09e666..68fa4bea1d1 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Miscellaneous.cs
@@ -106,7 +106,6 @@ public void VerifyPrimaryReferenceToBadImageDoesNotThrow()
             ITaskItem xpdb = new TaskItem(Path.Combine(s_myComponentsRootPath, "X.pdb"));
             ResolveAssemblyReference t = new()
             {
-                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 BuildEngine = new MockEngine(),
                 AllowedRelatedFileExtensions = new string[] { ".pdb" },
                 Assemblies = new ITaskItem[] { xpdb },
@@ -142,7 +141,6 @@ public void CopyLocalDependenciesWhenParentReferenceInGacFalseAllParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -181,7 +179,6 @@ public void ValidateFrameworkNameError()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = new string[] { s_myComponentsRootPath };
             t.TargetFrameworkMoniker = "I am a random frameworkName";
@@ -220,7 +217,6 @@ public void CopyLocalDependenciesWhenParentReferenceInGacFalseSomeParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -282,7 +278,6 @@ public void CopyLocalDependenciesWhenParentReferenceInGacTrueAllParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -332,7 +327,6 @@ public void CopyLocalDependenciesWhenParentReferenceInGacTrueSomeParentsInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
 
             if (NativeMethodsShared.IsWindows)
@@ -375,7 +369,6 @@ public void CopyLocalDependenciesWhenParentReferenceNotInGac()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = new string[] { "{gac}", @"c:\MyComponents" };
             bool succeeded = Execute(t);
@@ -413,7 +406,6 @@ public void CopyLocalLegacyBehavior()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.DoNotCopyLocalIfInGac = true;
             t.SearchPaths = new string[] { @"c:\MyComponents", "{gac}", };
@@ -474,7 +466,6 @@ public void Basic()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
@@ -763,7 +754,6 @@ public void EmbedInteropTypes()
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblies;
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
@@ -819,7 +809,6 @@ public void NOPForEmptyItemLists()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
 
@@ -853,7 +842,6 @@ public void DefaultAllowedRelatedFileExtensionsAreUsed()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -918,7 +906,6 @@ public void RelatedFilesAreNotFoundForExternallyResolvedReferences(bool findDepe
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -954,7 +941,6 @@ public void InputAllowedRelatedFileExtensionsAreUsed()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblies;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -1001,7 +987,6 @@ private void SimulateCreateProjectAgainstWhidbeyInternal(string fxfolder)
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("System"),
                 new TaskItem("System.Deployment"),
@@ -1054,7 +1039,6 @@ public void Regress286699_InvalidCandidateAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.CandidateAssemblyFiles = new string[] { "|" };
@@ -1075,7 +1059,6 @@ public void Regress286699_InvalidAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.AssemblyFiles = new ITaskItem[] { new TaskItem("|") };
@@ -1096,7 +1079,6 @@ public void Regress286699_InvalidAssembliesParameter()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("|!@#$%::") };
 
@@ -1122,7 +1104,6 @@ public void Regress286699_InvalidTargetFrameworkDirectory()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.TargetFrameworkDirectories = new string[] { "\nc:\\blah\\v2.0.1234" };
 
@@ -1142,7 +1123,6 @@ public void Regress286699_InvalidSearchPath()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.SearchPaths = new string[] { "|" };
@@ -1157,7 +1137,7 @@ public void Regress286699_InvalidSearchPath()
         /// <summary>
         /// Invalid or empty app.config paths should not crash.
         /// Invalid path "|" causes a logged error and task failure.
-        /// Empty string is silently ignored (Wave18_6 behavior) and task succeeds.
+        /// Empty string is silently ignored (Wave18_8 behavior) and task succeeds.
         /// </summary>
         [Theory]
         [InlineData("|", false)]
@@ -1167,7 +1147,6 @@ public void InvalidOrEmptyAppConfig_DoesNotCrash(string appConfigFile, bool expe
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = [new TaskItem("mscorlib")];
             t.AppConfigFile = appConfigFile;
 
@@ -1177,25 +1156,24 @@ public void InvalidOrEmptyAppConfig_DoesNotCrash(string appConfigFile, bool expe
         }
 
         /// <summary>
-        /// When Wave18_6 is disabled, empty AppConfigFile should cause the task to fail
+        /// When Wave18_8 is disabled, empty AppConfigFile should cause the task to fail
         /// with an error, preserving backward-compatible behavior.
         /// </summary>
         [Fact]
-        public void EmptyAppConfigFile_Wave18_6_Disabled_Fails()
+        public void EmptyAppConfigFile_Wave18_8_Disabled_Fails()
         {            
             try
             {
                 using TestEnvironment env = TestEnvironment.Create(_output);
 
                 ChangeWaves.ResetStateForTests();
-                env.SetEnvironmentVariable("MSBUILDDISABLEFEATURESFROMVERSION", ChangeWaves.Wave18_6.ToString());
+                env.SetEnvironmentVariable("MSBUILDDISABLEFEATURESFROMVERSION", ChangeWaves.Wave18_8.ToString());
                 BuildEnvironmentHelper.ResetInstance_ForUnitTestsOnly();
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 MockEngine engine = new MockEngine(_output);
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
                 t.AppConfigFile = string.Empty;
 
@@ -1218,7 +1196,6 @@ public void NonExistentReference()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("System.Xml"), new TaskItem("System.Nonexistent")
             };
@@ -1249,7 +1226,6 @@ public void StrongWeakMismatchInDependency()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("DependsOnSimpleA")
@@ -1274,7 +1250,6 @@ public void DependenciesOfExternallyResolvedReferencesAreNotSearched()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("DependsOnSimpleA")
@@ -1302,7 +1277,6 @@ public void UseSuppliedHintPath()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem i = new TaskItem("My.Assembly");
 
@@ -1331,7 +1305,6 @@ public void Regress200872()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("mscorlib") };
             t.SearchPaths = new string[]
@@ -1355,7 +1328,6 @@ public void AssemblyFoldersExBasic()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyGrid") };
             t.SearchPaths = DefaultPaths;
@@ -1376,7 +1348,6 @@ public void AssemblyFoldersExVerifyComponentFolderSorting()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("CustomComponent") };
             t.SearchPaths = DefaultPaths;
@@ -1398,7 +1369,6 @@ public void AssemblyFoldersExTargetFrameworkVersionDoesNotBeginWithV()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyGrid") };
             t.SearchPaths = new string[] { @"{Registry:Software\Microsoft\.NetFramework,2.0,AssemblyFoldersEx}" };
@@ -1423,7 +1393,6 @@ public void AssemblyFoldersExProcessorArchDoesNotMatch()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1449,7 +1418,6 @@ public void AssemblyFoldersExProcessorArchMSILX86()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1472,7 +1440,6 @@ public void VerifyProcessArchitectureMismatchWarning()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A"), new TaskItem("B") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1497,7 +1464,6 @@ public void VerifyProcessArchitectureMismatchWarningDefault()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A"), new TaskItem("B") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1521,7 +1487,6 @@ public void VerifyProcessArchitectureMismatchError()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A"), new TaskItem("B") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1549,7 +1514,6 @@ public void AssemblyFoldersExProcessorArchNoneX86()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1570,7 +1534,6 @@ public void AssemblyFoldersExProcessorArchNoneMix()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MIX}" };
@@ -1599,7 +1562,6 @@ public void AssemblyFoldersExProcessorArchMSILLastFolder()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,AssemblyFoldersEx}" };
@@ -1625,7 +1587,6 @@ public void AssemblyFoldersExProcessorArchNoneLastFolder()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,AssemblyFoldersEx}" };
@@ -1650,7 +1611,6 @@ public void AssemblyFoldersExProcessorArchX86FirstFolder()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,AssemblyFoldersEx}" };
@@ -1674,7 +1634,6 @@ public void AssemblyFoldersExProcessorArchX86MSIL()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MSIL}" };
@@ -1697,7 +1656,6 @@ public void AssemblyFoldersExProcessorArchX86None()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,None}" };
@@ -1720,7 +1678,6 @@ public void AssemblyFoldersExProcessorArchNoneNone()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,None}" };
@@ -1742,7 +1699,6 @@ public void AssemblyFoldersExProcessorArcMSILNone()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,None}" };
@@ -1764,7 +1720,6 @@ public void AssemblyFoldersExProcessorArchNoneMSIL()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MSIL}" };
@@ -1787,7 +1742,6 @@ public void AssemblyFoldersExProcessorArchMSILMSIL()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine mockEngine = new MockEngine(_output);
             t.BuildEngine = mockEngine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,MSIL}" };
@@ -1810,7 +1764,6 @@ public void AssemblyFoldersExProcessorArchMatches()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("A") };
             t.SearchPaths = new string[] { @"{Registry:Software\Regress714052,v2.0.0,X86}" };
@@ -1835,7 +1788,6 @@ public void AssemblyFoldersExTargetFrameworkVersionBogusValue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem assemblyToResolve = new TaskItem("MyGrid");
             assemblyToResolve.SetMetadata("HintPath", @"C:\MyComponents\MyGrid.dll");
@@ -1857,7 +1809,6 @@ public void Regress357227_AssemblyFoldersExAgainstRawDrop()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyRawDropControl") };
             t.SearchPaths = DefaultPaths;
@@ -1878,7 +1829,6 @@ public void AssemblyFoldersExHKLM()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyHKLMControl") };
             t.SearchPaths = DefaultPaths;
@@ -1903,7 +1853,6 @@ public void AssemblyFoldersExHKCUTrumpsHKLM()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyHKLMandHKCUControl") };
             t.SearchPaths = DefaultPaths;
@@ -1923,7 +1872,6 @@ public void AssemblyFoldersExFutureTargetNDPVersionsDontMatch()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyControlWithFutureTargetNDPVersion") };
             t.SearchPaths = DefaultPaths;
@@ -1943,7 +1891,6 @@ public void AssemblyFoldersExMatchBackVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyNDP1Control") };
             t.SearchPaths = DefaultPaths;
@@ -1963,7 +1910,6 @@ public void AssemblyFoldersExCurrentTargetVersionTrumpsPastTargetVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyControlWithPastTargetNDPVersion") };
             t.SearchPaths = DefaultPaths;
@@ -1983,7 +1929,6 @@ public void AssemblyFoldersExServicePackTrumpsBaseVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyControlWithServicePack") };
             t.SearchPaths = DefaultPaths;
@@ -2009,7 +1954,6 @@ public void AssemblyFoldersExConditionFilterMaxOS()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyDeviceControlAssembly") };
             t.SearchPaths = new string[]
@@ -2048,7 +1992,6 @@ public void AssemblyFoldersExConditionFilterMinOS()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyDeviceControlAssembly") };
             t.SearchPaths = new string[]
@@ -2362,7 +2305,6 @@ public void AssemblyFoldersExConditionFilterPlatform()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("MyDeviceControlAssembly") };
             t.SearchPaths = new string[]
@@ -2438,7 +2380,6 @@ public void CandidateAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("System.XML") };
             t.SearchPaths = new string[] { "{CandidateAssemblyFiles}" };
@@ -2459,7 +2400,6 @@ public void ThreePartVersionNumberRequiredFrameworkHigherThanTargetFramework()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             TaskItem item = new TaskItem("System.XML");
             item.SetMetadata("RequiredTargetFramework", "v4.0.255");
             t.Assemblies = new ITaskItem[] { item };
@@ -2480,7 +2420,6 @@ public void ThreePartVersionNumberRequiredFrameworkLowerThanTargetFramework()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             TaskItem item = new TaskItem("System.XML");
             item.SetMetadata("RequiredTargetFramework", "v4.0.255");
             t.Assemblies = new ITaskItem[] { item };
@@ -2503,7 +2442,6 @@ public void Regress242970()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("System.XML") };
             t.SearchPaths = new string[] { "{CandidateAssemblyFiles}" };
@@ -2546,7 +2484,6 @@ public void RawFileName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(Path.Combine(s_myVersion20Path, "System.Xml.dll")) };
             t.SearchPaths = new string[]
@@ -3039,7 +2976,6 @@ public void RawFileNameRelative()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             string testPath = Path.Combine(Path.GetTempPath(), @"RawFileNameRelative");
             string previousCurrentDirectory = Directory.GetCurrentDirectory();
@@ -3076,7 +3012,6 @@ public void RelativeDirectoryResolver()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             string testPath = Path.Combine(Path.GetTempPath(), @"RawFileNameRelative");
             string previousCurrentDirectory = Directory.GetCurrentDirectory();
@@ -3112,7 +3047,6 @@ public void HintPathRelative()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             string testPath = Path.Combine(Path.GetTempPath(), @"RawFileNameRelative");
             string previousCurrentDirectory = Directory.GetCurrentDirectory();
@@ -3150,7 +3084,6 @@ public void RawFileNameWithSpecificVersionFalse()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem taskItem = new TaskItem(Path.Combine(s_myVersion20Path, "System.Xml.dll"));
             taskItem.SetMetadata("SpecificVersion", "false");
@@ -3176,7 +3109,6 @@ public void RawFileNameWithSpecificVersionTrue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ITaskItem taskItem = new TaskItem(Path.Combine(s_myVersion20Path, "System.Xml.dll"));
             taskItem.SetMetadata("SpecificVersion", "true");
@@ -3202,7 +3134,6 @@ public void Regress363340_RawFileNameMissing()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3233,7 +3164,6 @@ public void Regress444793()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             TaskItem item = new TaskItem(@"c:\DoesntExist\System.Xml.dll");
             item.SetMetadata("HintPath", Path.Combine(s_myVersion20Path, "System.Data.dll"));
@@ -3263,7 +3193,6 @@ public void RawFileNameDoesntExist()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(@"c:\DoesntExist\System.Xml.dll") };
             t.SearchPaths = new string[] { "{RawFileName}" };
@@ -3283,7 +3212,6 @@ public void CandidateAssemblyFilesDifferentBaseName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("VendorAssembly") };
             t.SearchPaths = new string[] { "{CandidateAssemblyFiles}" };
@@ -3303,7 +3231,6 @@ public void ResolveToGAC()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem("System") };
             t.TargetedRuntimeVersion = typeof(Object).Assembly.ImageRuntimeVersion;
@@ -3322,7 +3249,6 @@ public void ResolveToGACSpecificVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             TaskItem item = new TaskItem("System");
             item.SetMetadata("SpecificVersion", "true");
@@ -3385,7 +3311,6 @@ public void ResolveBadImageInPrimary()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("BadImage")
@@ -3427,7 +3352,6 @@ public void ResolveBadImageInSecondary()
 
             MockEngine engine = new MockEngine(true);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3466,7 +3390,6 @@ public void ResolveReferenceThatHasWrongPKTInEarlierAssembly()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(AssemblyRef.SystemData) };
             t.SearchPaths = new string[]
@@ -3490,7 +3413,6 @@ public void PrimaryFXAssemblyRefIsNotCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] { new TaskItem(AssemblyRef.SystemData) };
             t.SearchPaths = new string[]
@@ -3534,7 +3456,6 @@ public void PrivateItemInFrameworksGetsCopyLocalTrue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -3561,7 +3482,6 @@ public void NoFrameworkDirectoriesStillCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = Array.Empty<string>();
             t.SearchPaths = new string[] { "{RawFileName}" };
@@ -3590,7 +3510,6 @@ public void Regress284485_PrivateItemWithBogusValue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.TargetFrameworkDirectories = new string[] { s_myVersion20Path };
             t.SearchPaths = DefaultPaths;
@@ -3625,7 +3544,6 @@ public void ConflictBetweenCopyLocalDependenciesRegress444809()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("A, Version=2.0.0.0, Culture=Neutral, PublicKeyToken=null"), new TaskItem("C, Version=1.0.0.0, Culture=Neutral, PublicKeyToken=null")
@@ -3671,7 +3589,6 @@ public void ConflictBetweenCopyLocalDependenciesRegress444809UnResolvedPrimaryRe
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("A, Version=20.0.0.0, Culture=Neutral, PublicKeyToken=null"),
@@ -3713,7 +3630,6 @@ public void ConflictGeneratesMessageReferencingAssemblyName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3746,7 +3662,6 @@ public void ConflictOutputsExtraInformationOnDemand()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3790,7 +3705,6 @@ public void ConflictGeneratesMessageReferencingEachConflictingAssemblyName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3842,7 +3756,6 @@ public void ConflictWithForeVersionPrimary()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3885,7 +3798,6 @@ public void ConflictBetweenBackAndForeVersionsCopyLocal()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3924,7 +3836,6 @@ public void ConflictBetweenBackAndForeVersionsNotCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3961,7 +3872,6 @@ public void ConflictingDependenciesWithNonMatchingNames()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -3997,7 +3907,6 @@ public void ConflictingDependenciesWithNonMatchingNamesAndHardReferenceInProject
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4027,7 +3936,6 @@ public void SpecificVersionFalse()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4053,7 +3961,6 @@ public void SpecificVersionTrue()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem(@"System.XML, Version=9.9.9999.9, Culture=neutral, PublicKeyToken=abababababababab")
@@ -4077,7 +3984,6 @@ public void SpecificVersionAbsent()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem(@"System.XML, Version=9.9.9999.9, Culture=neutral, PublicKeyToken=abababababababab")
@@ -4099,7 +4005,6 @@ public void Regress199998()
 
             MockEngine m = new MockEngine(_output);
             t.BuildEngine = m;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4133,7 +4038,6 @@ public void ExecutableExtensionEXE()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4173,7 +4077,6 @@ public void ExecutableExtensionDLL()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4214,7 +4117,6 @@ public void ExecutableExtensionDefaultDLLFirst()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4253,7 +4155,6 @@ public void ExecutableExtensionDefaultEXEFirst()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4295,7 +4196,6 @@ public void SimpleNameWithSpecificVersionTrue()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4334,7 +4234,6 @@ public void SimpleNameWithSpecificVersionFalse()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4372,7 +4271,6 @@ public void IrrelevantAssemblyNameElement()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4423,7 +4321,6 @@ public void RegressQFE626()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4484,7 +4381,6 @@ public void Regress265054()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4548,7 +4444,6 @@ public void Regress312873_UnresolvedPrimaryWithResolveDependency()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4591,7 +4486,6 @@ public void Regress275161_ScatterAssemblies()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4644,7 +4538,6 @@ public void Regress317975_LeftoverLowerVersion()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4697,7 +4590,6 @@ public void Regress313086_Part1_MscorlibAsRawFilename()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4739,7 +4631,6 @@ public void Regress313086_Part2_MscorlibAsRawFilename()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4777,7 +4668,6 @@ public void Regress284466_DirectoryIntoAssemblyFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = DefaultPaths;
 
@@ -4816,7 +4706,6 @@ public void RelativeAssemblyFiles()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
 
@@ -4847,7 +4736,6 @@ public void Regress316906_UnauthorizedAccessViolation_PrimaryReferenceIsInaccess
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4879,7 +4767,6 @@ public void Regress316906_UnauthorizedAccessViolation_PrimaryFileIsInaccessible(
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.AssemblyFiles = new ITaskItem[]
             {
@@ -4903,7 +4790,6 @@ public void Regress316906_UnauthorizedAccessViolation_PrimaryAsRawFileIsInaccess
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4928,7 +4814,6 @@ public void Regress269704_MissingRegistryElements()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -4972,7 +4857,6 @@ public void Regress276548_AssemblyNameDifferentThanFusionName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5007,7 +4891,6 @@ public void Regress314573_VeryLongPaths()
 
             MockEngine e = new (_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = [new TaskItem("A")]; // Resolved by HintPath
             t.Assemblies[0].SetMetadata(
@@ -5035,7 +4918,6 @@ public void Regress265003_EscapedCharactersInFusionName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5072,7 +4954,6 @@ public void Regress284081_UnescapedCharactersInFusionNameWithHintPath()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5109,7 +4990,6 @@ public void Regress366322_ReferencesWithFileExtensions()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5139,7 +5019,6 @@ public void Regress366814_MultipleFrameworksFolders()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5186,7 +5065,6 @@ public void Regress271273_BogusAppConfig()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = assemblyFiles;
                 t.SearchPaths = DefaultPaths;
                 t.AppConfigFile = appConfigFile;
@@ -5210,7 +5088,6 @@ public void Regress354669_HintPathWithTrailingSlash()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5251,7 +5128,6 @@ public void Regress339786_CrossVersionsWithAppConfig()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5296,7 +5172,6 @@ public void Regress_DogfoodCLRThrowsFileLoadException()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5322,7 +5197,6 @@ public void Regress407623_RedistListDoesNotImplyPresenceInFrameworks()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5372,7 +5246,6 @@ public void InvalidCharsInInstalledAssemblyTable()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5406,7 +5279,6 @@ public void Regress435487_FxFileResolvedByHintPathShouldByCopyLocal()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5508,7 +5380,6 @@ public void Regress46599_BogusInGACValueForAssemblyInRedistList()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5560,7 +5431,6 @@ public void VerifyFrameworkFileMetadataFiles()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -5987,7 +5857,6 @@ public void RedistListNoAssembliesinRedistList()
             string microsoftBuildEnginePath = Path.Combine(ObjectModelHelpers.TempProjectDir, "v3.5\\Microsoft.Build.Engine.dll");
             string systemXmlPath = Path.Combine(ObjectModelHelpers.TempProjectDir, "v3.5\\System.Xml.dll");
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -6355,7 +6224,6 @@ public void IgnoreDefaultInstalledAssemblyTables()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -6491,7 +6359,6 @@ public void ReferenceTablePrimaryItemInDenyList()
             MockEngine mockEngine = new MockEngine(_output);
             ResolveAssemblyReference rar = new ResolveAssemblyReference();
             rar.BuildEngine = mockEngine;
-            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ReferenceTable referenceTable = MakeEmptyReferenceTable(rar.Log);
             Dictionary<AssemblyNameExtension, Reference> table = referenceTable.References;
@@ -6531,7 +6398,6 @@ public void ReferenceTablePrimaryItemInDenyListSpecificVersionTrue()
             MockEngine mockEngine = new MockEngine(_output);
             ResolveAssemblyReference rar = new ResolveAssemblyReference();
             rar.BuildEngine = mockEngine;
-            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ReferenceTable referenceTable = MakeEmptyReferenceTable(rar.Log);
             Dictionary<AssemblyNameExtension, Reference> table = referenceTable.References;
@@ -6609,7 +6475,6 @@ public void ReferenceTablePrimaryItemInDenyListRemoveOnlyNoWarn()
             MockEngine mockEngine = new MockEngine(_output);
             ResolveAssemblyReference rar = new ResolveAssemblyReference();
             rar.BuildEngine = mockEngine;
-            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ReferenceTable referenceTable = MakeEmptyReferenceTable(rar.Log);
             Dictionary<AssemblyNameExtension, Reference> table = referenceTable.References;
@@ -7180,7 +7045,6 @@ private static void InitializeRARwithMockEngine(ITestOutputHelper output, out Mo
         {
             mockEngine = new MockEngine(output);
             rar = new ResolveAssemblyReference();
-            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             rar.BuildEngine = mockEngine;
         }
 
@@ -7218,7 +7082,6 @@ private void InitializeMockEngine(out ReferenceTable referenceTable, out MockEng
         {
             mockEngine = new MockEngine(_output);
             rar = new ResolveAssemblyReference();
-            rar.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             rar.BuildEngine = mockEngine;
 
             referenceTable = MakeEmptyReferenceTable(rar.Log);
@@ -7273,7 +7136,6 @@ public void IgnoreDefaultInstalledSubsetTables()
                 string explicitSubsetListPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("v3.5\\SubsetList\\ExplicitList.xml", _xmlOnlySubset);
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}" };
 
@@ -7358,7 +7220,6 @@ public void NoClientSubsetButInstalledSubTables()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}" };
@@ -7440,7 +7301,6 @@ public void FakeSubsetListPathsNoAdditionalSubsets()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}" };
@@ -7481,7 +7341,6 @@ public void ResolveAssemblyReferenceVerifyFullClientName()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("System.Xml") };
@@ -7515,7 +7374,6 @@ public void ResolveAssemblyReferenceVerifyFullClientNameWithSubsetTables()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("System.Xml") };
 
@@ -7551,7 +7409,6 @@ public void ResolveAssemblyReferenceVerifyFullClientNameNoTablesPassedIn()
             {
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 // These are the assemblies we are going to try and resolve
                 t.Assemblies = new ITaskItem[] { new TaskItem("System.Xml") };
 
@@ -7583,7 +7440,6 @@ public void DoNotAssumeFilesDescribedByRedistListExistOnDisk()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = new MockEngine(_output);
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 t.Assemblies = new ITaskItem[]
             {
@@ -7668,7 +7524,6 @@ public void Regress397129_HandleInvalidDirectoriesAndFiles_Case1()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7701,7 +7556,6 @@ public void Regress397129_HandleInvalidDirectoriesAndFiles_Case2()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7743,7 +7597,6 @@ public void ByDesignRelatedTo454863_PrimaryReferencesDontResolveToParentFolders(
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7770,7 +7623,6 @@ public void Regress393931_AllowAlternateAssemblyExtensions_Case1()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7802,7 +7654,6 @@ public void Regress393931_AllowAlternateAssemblyExtensions()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7831,7 +7682,6 @@ public void SGenDependeicies()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new TaskItem[]
             {
@@ -7875,7 +7725,6 @@ public void Regress315619_TwoWeaklyNamedPrimariesIsInsoluble()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.AssemblyFiles = new ITaskItem[]
             {
@@ -7915,7 +7764,6 @@ public void ForwardRedistRoot()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -7967,7 +7815,6 @@ private int RunTargetFrameworkFilteringTest(string projectTargetFramework)
         {
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             t.BuildEngine = new MockEngine(_output);
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = new ITaskItem[]
             {
                 new TaskItem("A"),
@@ -8332,7 +8179,6 @@ public void Verifyp2pAndProfile()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.AssemblyFiles = new ITaskItem[] { new TaskItem(Path.Combine(s_myComponentsMiscPath, "DependsOn9Also.dll")) };
                 t.SearchPaths = new string[] { @"{TargetFrameworkDirectory}", fullFrameworkDirectory };
                 t.TargetFrameworkDirectories = new string[] { targetFrameworkDirectory };
@@ -8381,7 +8227,6 @@ public void Verifyp2pAndProfile2()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 TaskItem item = new TaskItem(Path.Combine(s_myComponentsMiscPath, "DependsOn9Also.dll"));
                 item.SetMetadata("SpecificVersion", "true");
                 t.AssemblyFiles = new ITaskItem[] { item };
@@ -8424,7 +8269,6 @@ public void VerifyClientProfileRedistListAndProfileList()
                 GenerateRedistAndProfileXmlLocations(_fullRedistListContents, _engineOnlySubset, out profileRedistList, out fullRedistList, fullFrameworkDirectory, targetFrameworkDirectory);
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
@@ -8472,7 +8316,6 @@ public void VerifyClientProfileRedistListAndProfileList2()
                 GenerateRedistAndProfileXmlLocations(_fullRedistListContents, _engineOnlySubset, out profileRedistList, out fullRedistList, fullFrameworkDirectory, targetFrameworkDirectory);
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
@@ -8529,7 +8372,6 @@ public void VerifyAssemblyInGacButNotInProfileIsNotResolved()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 TaskItem item = new TaskItem(@"DependsOnOnlyv4Assemblies, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089");
                 t.Assemblies = new ITaskItem[] { item };
                 t.SearchPaths = new string[] { s_myComponents40ComponentPath, "{GAC}" };
@@ -8582,7 +8424,6 @@ public void VerifyProfileErrorsAreLogged()
                 GenerateRedistAndProfileXmlLocations(fullRedistListContentsErrors, _engineOnlySubset, out profileRedistList, out fullRedistList, fullFrameworkDirectory, targetFrameworkDirectory);
 
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 MockEngine e = new MockEngine(_output);
                 t.BuildEngine = e;
                 t.Assemblies = new ITaskItem[] { new TaskItem("Microsoft.Build.Engine"), new TaskItem("System.Xml") };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs b/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs
index bf08bc9513b..56a62f79a80 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Node/OutOfProcRarNode_Tests.cs
@@ -34,7 +34,6 @@ public void RunsOutOfProcIfAllFlagsAreEnabled()
             {
                 AllowOutOfProcNode = true,
                 BuildEngine = engine,
-                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System")],
                 SearchPaths = [Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)],
             };
@@ -74,7 +73,6 @@ public void SkipsOutOfProcNodeIfAnyFlagIsDisabled(bool buildEngineFlag, bool tas
             {
                 AllowOutOfProcNode = taskInputFlag,
                 BuildEngine = engine,
-                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System")],
                 SearchPaths = [Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)],
             };
@@ -101,7 +99,6 @@ public void FallsBackToInProcTaskIfClientFailsToConnect()
             {
                 AllowOutOfProcNode = true,
                 BuildEngine = engine,
-                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System")],
                 SearchPaths = [Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)],
             };
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs b/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs
index 5dbfd1dbc1e..cc80fbbf105 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Node/RarNodeExecuteRequest_Tests.cs
@@ -21,7 +21,6 @@ public void TaskInputsArePropagated()
             ResolveAssemblyReference clientRar = new()
             {
                 BuildEngine = new MockEngine(),
-                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 Assemblies = [new TaskItem("System"), new TaskItem("System.IO")],
                 AssemblyFiles = [],
                 AllowedAssemblyExtensions = [".dll", ".exe"],
@@ -66,10 +65,10 @@ public void BuildEngineSettingsArePropagated()
                 MinimumMessageImportance = MessageImportance.Normal,
                 SetIsTaskInputLoggingEnabled = false,
             };
-            ResolveAssemblyReference clientRar = new() { BuildEngine = mockEngine, TaskEnvironment = TaskEnvironmentHelper.CreateForTest() };
+            ResolveAssemblyReference clientRar = new() { BuildEngine = mockEngine };
             RarNodeExecuteRequest request = new(clientRar);
 
-            ResolveAssemblyReference nodeRar = new() { TaskEnvironment = TaskEnvironmentHelper.CreateForTest() };
+            ResolveAssemblyReference nodeRar = new();
             request.SetTaskInputs(nodeRar, CreateBuildEngine());
 
             Assert.Equal(mockEngine.LineNumberOfTaskNode, nodeRar.BuildEngine.LineNumberOfTaskNode);
@@ -93,7 +92,6 @@ public void OutOfProcExecutionFlagsAreDisabledOnHydrate()
             ResolveAssemblyReference clientRar = new()
             {
                 BuildEngine = mockEngine,
-                TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                 AllowOutOfProcNode = true,
             };
             RarNodeExecuteRequest request = new(clientRar);
diff --git a/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs b/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs
index a3393a13ff7..e445209045a 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/NonSpecificVersionStrictPrimary.cs
@@ -65,7 +65,6 @@ public void Exists()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -118,7 +117,6 @@ public void ExistsDifferentName()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -172,7 +170,6 @@ public void ExistsOldVersionRange()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -225,7 +222,6 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -278,7 +274,6 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/Perf.cs b/src/Tasks.UnitTests/AssemblyDependency/Perf.cs
index caca89ce220..dccccf6f98f 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/Perf.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/Perf.cs
@@ -70,7 +70,6 @@ public void DependeeDirectoryIsProbedForDependency()
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblyNames;
                 t.SearchPaths = new[] { "{RawFileName}" };
                 t.AutoUnify = true;
@@ -116,7 +115,6 @@ public void DependeeDirectoryShouldNotBeProbedForDependencyWhenDependencyResolve
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
 
                 t.BuildEngine = engine;
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.Assemblies = assemblyNames;
                 t.SearchPaths = new[] { "{RawFileName}" };
                 t.AutoUnify = true;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs b/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs
index 3edffbf6511..a7fb899d4f8 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/SpecificVersionPrimary.cs
@@ -62,7 +62,6 @@ public void Exists()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -127,7 +126,6 @@ public void ExistsDifferentName()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyNames;
             t.SearchPaths = DefaultPaths;
             t.AppConfigFile = appConfigFile;
@@ -178,7 +176,6 @@ public void ExistsOldVersionRange()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -231,7 +228,6 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -284,7 +280,6 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs
index 47daf25bc19..64ec1d5dae6 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependency.cs
@@ -60,7 +60,6 @@ public void Exists()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -111,7 +110,6 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -141,7 +139,6 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t1 = new ResolveAssemblyReference();
-            t1.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t1.TargetFrameworkVersion = "v4.5";
             t1.TargetFrameworkDirectories = new string[] { actualFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t1, e, items, redistString1, true, new List<string>() { "{RawFileName}" });
@@ -154,7 +151,6 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t2 = new ResolveAssemblyReference();
-            t2.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t2.TargetFrameworkVersion = "v4.5";
             t2.TargetFrameworkDirectories = new string[] { actualFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t2, e, items, redistString2, true, new List<string>() { "{RawFileName}" });
@@ -167,7 +163,6 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t3 = new ResolveAssemblyReference();
-            t3.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t3.TargetFrameworkVersion = "v4.5";
             t3.TargetFrameworkDirectories = new string[] { alternativeFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t3, e, items, redistString3, true, new List<string>() { "{RawFileName}" });
@@ -180,7 +175,6 @@ public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute()
                                    "</FileList >";
 
             ResolveAssemblyReference t4 = new ResolveAssemblyReference();
-            t4.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t4.TargetFrameworkVersion = "v4.5";
             t4.TargetFrameworkDirectories = new string[] { alternativeFrameworkDirectory };
             ExecuteRAROnItemsAndRedist(t4, e, items, redistString4, true, new List<string>() { "{RawFileName}" });
diff --git a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs
index 80cc4fe8c29..90b8ff8caea 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAppConfig.cs
@@ -66,7 +66,6 @@ public void Exists(string appConfigNameSuffix)
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -138,7 +137,6 @@ public void ExistsPromotedDependencyInTheDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
@@ -198,7 +196,6 @@ public void ExistsDifferentName()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -249,7 +246,6 @@ public void ExistsOldVersionRange()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -302,7 +298,6 @@ public void HighVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -369,7 +364,6 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -416,7 +410,6 @@ public void GarbageVersionInAppConfigFile()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -459,7 +452,6 @@ public void GarbageAppConfigMissingOldVersion()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -504,7 +496,6 @@ public void GarbageAppConfigMissingNewVersion()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -550,7 +541,6 @@ public void GarbageAppConfigAssemblyNameMissingPKTAndCulture()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -595,7 +585,6 @@ public void AppConfigSpecifiedWhenAutoUnifyEqualsTrue()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -634,7 +623,6 @@ public void AppConfigDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs
index 66bead1d181..e336ef4febd 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/StronglyNamedDependencyAutoUnify.cs
@@ -69,7 +69,6 @@ internal void ExistsImpl(RARSimulationMode rarSimulationMode = RARSimulationMode
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -139,7 +138,6 @@ public void ExistsWithPrimaryReferenceOnDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
@@ -226,7 +224,6 @@ public void ExistsPromotedDependencyInTheDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
@@ -298,7 +295,6 @@ public void ExistsWithBothDependentReferenceOnDenyList()
 
                 // Now, pass feed resolved primary references into ResolveAssemblyReference.
                 ResolveAssemblyReference t = new ResolveAssemblyReference();
-                t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
                 t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
                 t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
@@ -373,7 +369,6 @@ public void MultipleUnifiedFromNamesMiddlePrimaryOnDenyList()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.InstalledAssemblyTables = new TaskItem[] { new TaskItem(redistListPath) };
             t.InstalledAssemblySubsetTables = new TaskItem[] { new TaskItem(subsetListPath) };
 
@@ -433,7 +428,6 @@ public void MultipleUnifiedFromNames()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
@@ -486,7 +480,6 @@ public void LowVersionDoesntExist()
 
             // Now, pass feed resolved primary references into ResolveAssemblyReference.
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.BuildEngine = engine;
             t.Assemblies = assemblyNames;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs b/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs
index b2b1d8d73b5..d45e0ff7f38 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/SuggestedRedirects.cs
@@ -45,7 +45,6 @@ public void ConflictBetweenNonCopyLocalDependencies()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -91,7 +90,6 @@ public void ConflictBetweenCopyLocalDependencies()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[] {
                 new TaskItem("A"), new TaskItem("B")
@@ -141,7 +139,6 @@ public void ConflictBetweenCopyLocalDependenciesWithAutoUnify()
 
             MockEngine engine = new MockEngine(_output);
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AutoUnify = true;
 
             t.Assemblies = new ITaskItem[] {
@@ -182,7 +179,6 @@ public void ConflictWithBackVersionPrimary()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -226,7 +222,6 @@ public void ConflictWithBackVersionPrimaryWithAutoUnify()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -280,7 +275,6 @@ public void Regress313747_FalseSuggestedRedirectsWhenAssembliesDifferOnlyByPkt()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -320,7 +314,6 @@ public void Regress442570_MissingBackVersionShouldWarn()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -356,7 +349,6 @@ public void RedirectsAreSuggestedInExternallyResolvedGraph()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             // NB: These are what common targets would set when AutoGenerateBindingRedirects is enabled.
             t.AutoUnify = true;
@@ -401,7 +393,6 @@ public void Regress387218_UnificationRequiresStrongName()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
@@ -445,7 +436,6 @@ public void Regress390219_UnificationRequiresSameCulture()
 
             MockEngine e = new MockEngine(_output);
             t.BuildEngine = e;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.Assemblies = new ITaskItem[]
             {
diff --git a/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs b/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs
index 54b57ded832..e6e5f93dd52 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/VerifyIgnoreVersionForFrameworkReference.cs
@@ -40,7 +40,6 @@ public void IgnoreVersionBasic()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             t.IgnoreVersionForFrameworkReferences = true;
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
@@ -66,7 +65,6 @@ public void IgnoreVersionBasic()
                            "</FileList >";
 
             t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
@@ -98,7 +96,6 @@ public void IgnoreVersionBasicTestMetadata()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -121,7 +118,6 @@ public void IgnoreVersionBasicTestMetadata()
                            "</FileList >";
 
             t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
@@ -153,7 +149,6 @@ public void IgnoreVersionDisableIfSpecificVersionTrue()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -184,7 +179,6 @@ public void IgnoreVersionDisableIfHintPath()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
diff --git a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs
index c5739420b33..a3805d2a22d 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkAttribute.cs
@@ -35,7 +35,6 @@ public void FrameworksDoNotMatch()
 
     
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "BAR, Version=4.0";
@@ -63,7 +62,6 @@ public void LowerVersionSameFrameworkDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=v4.0";
@@ -91,7 +89,6 @@ public void SameVersionSameFrameworkDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -122,7 +119,6 @@ public void HigherVersionButSpecificVersionDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -150,7 +146,6 @@ public void LowerVersionSameFrameworkInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=v4.0";
@@ -180,7 +175,6 @@ public void SameVersionSameFrameworkInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -213,7 +207,6 @@ public void HigherVersionButSpecificVersionInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -245,7 +238,6 @@ public void HigherVersionInDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -276,7 +268,6 @@ public void HigherVersionInDirectIgnoreMismatch()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest(); 
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -309,7 +300,6 @@ public void HigherVersionDirectIgnoreMismatch()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -342,7 +332,6 @@ public void HigherVersionDirect()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.TargetFrameworkMoniker = "Foo, Version=4.0";
@@ -375,7 +364,6 @@ public void HigherVersionDirectDependenciesFalse()
             };
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.BuildEngine = e;
             t.Assemblies = items;
             t.FindDependencies = false;
diff --git a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs
index e99c56a9e2f..9490dca5559 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/VerifyTargetFrameworkHigherThanRedist.cs
@@ -40,7 +40,6 @@ public void TargetCurrentTargetFramework()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -82,7 +81,6 @@ public void RemapAssemblyBasic()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(0, e.Warnings); // "Expected NO warning in this scenario."
@@ -115,7 +113,6 @@ public void HigherThanHighestInRedistList()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
@@ -144,7 +141,6 @@ public void HigherThanHighestInRedistListForMSBuildAssembly()
                                   "</FileList >";
 
             ResolveAssemblyReference t1 = new ResolveAssemblyReference();
-            t1.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t1.TargetFrameworkVersion = "v4.5";
 
             ExecuteRAROnItemsAndRedist(t1, e, items, redistString, false);
@@ -154,7 +150,6 @@ public void HigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Single(t1.ResolvedFiles);
 
             ResolveAssemblyReference t2 = new ResolveAssemblyReference();
-            t2.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t2.TargetFrameworkVersion = "v4.0";
 
             ExecuteRAROnItemsAndRedist(t2, e, items, redistString, false);
@@ -166,7 +161,6 @@ public void HigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Empty(t2.ResolvedFiles);
 
             ResolveAssemblyReference t3 = new ResolveAssemblyReference();
-            t3.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t3.TargetFrameworkVersion = "v4.5";
             t3.UnresolveFrameworkAssembliesFromHigherFrameworks = true;
 
@@ -197,7 +191,6 @@ public void HigherThanHighestInRedistList3rdPartyRedist()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(0, e.Warnings); // "Expected one warning in this scenario."
@@ -226,7 +219,6 @@ public void HigherThanHighestInRedistListWithSpecificVersionMetadata()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -257,7 +249,6 @@ public void DependenciesHigherThanHighestInRedistList()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
             Assert.Equal(2, e.Warnings); // "Expected one warning in this scenario."
@@ -286,7 +277,6 @@ public void DependenciesHigherThanHighestInRedistListForMSBuildAssembly()
                                   "</FileList >";
 
             ResolveAssemblyReference t1 = new ResolveAssemblyReference();
-            t1.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t1.TargetFrameworkVersion = "v5.0";
 
             ExecuteRAROnItemsAndRedist(t1, e, items, redistString, false);
@@ -297,7 +287,6 @@ public void DependenciesHigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Single(t1.ResolvedFiles);
 
             ResolveAssemblyReference t2 = new ResolveAssemblyReference();
-            t2.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t2.TargetFrameworkVersion = "v4.0";
 
             ExecuteRAROnItemsAndRedist(t2, e, items, redistString, false);
@@ -310,7 +299,6 @@ public void DependenciesHigherThanHighestInRedistListForMSBuildAssembly()
             Assert.Empty(t2.ResolvedFiles);
 
             ResolveAssemblyReference t3 = new ResolveAssemblyReference();
-            t3.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             // t2.TargetFrameworkVersion is null
 
             ExecuteRAROnItemsAndRedist(t3, e, items, redistString, false);
@@ -344,7 +332,6 @@ public void DependenciesHigherThanHighestInRedistListSpecificVersionMetadata()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -378,7 +365,6 @@ public void TwoDependenciesHigherThanHighestInRedistListIgnoreOnOne()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
@@ -414,7 +400,6 @@ public void TwoDependenciesHigherThanHighestInRedistListIgnoreOnBoth()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, true);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -445,7 +430,6 @@ public void TwoDependenciesSameNameDependOnHigherVersion()
                                   "</FileList >";
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false);
 
@@ -486,7 +470,6 @@ public void MixedDependenciesSpecificVersionOnHigherVersionMetadataSet()
 
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false, additionalPaths);
 
             Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario."
@@ -527,7 +510,6 @@ public void MixedDependenciesSpecificVersionOnLowerVersionMetadataSet()
             additionalPaths.Add(s_myVersion90Path + Path.DirectorySeparatorChar);
 
             ResolveAssemblyReference t = new ResolveAssemblyReference();
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
 
             ExecuteRAROnItemsAndRedist(t, e, items, redistString, false, additionalPaths);
 
diff --git a/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs b/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs
index c6fc4c10aec..2f949c261ec 100644
--- a/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs
+++ b/src/Tasks.UnitTests/AssemblyDependency/WinMDTests.cs
@@ -148,7 +148,6 @@ public void VerifyP2PHaveCorrectMetadataWinMD(bool setImplementationMetadata)
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -208,7 +207,6 @@ public void VerifyP2PHaveCorrectMetadataWinMDStaticLib()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -254,7 +252,6 @@ public void VerifyP2PHaveCorrectMetadataWinMDManaged()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
@@ -292,7 +289,6 @@ public void VerifyP2PHaveCorrectMetadataNonWinMD()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.AssemblyFiles = assemblyFiles;
             bool succeeded = Execute(t);
 
@@ -324,7 +320,6 @@ public void IgnoreReferenceToMscorlib()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -356,7 +351,6 @@ public void MixedWinMDGoodReferenceToMscorlib()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
@@ -388,7 +382,6 @@ public void WinMdFileDependsOnAnotherWinMDFile()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.TargetProcessorArchitecture = "X86";
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
@@ -430,7 +423,6 @@ public void ResolveWinmdBesideDll()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { "{RAWFILENAME}" };
             bool succeeded = Execute(t);
@@ -463,7 +455,6 @@ public void ResolveWinmdBesideDll2()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"{RAWFILENAME}" };
             bool succeeded = Execute(t);
@@ -495,7 +486,6 @@ public void WinMdFileDependsOnAnotherWinMDFileWithFrameworkDependencies()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"{TargetFrameworkDirectory}", @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             t.TargetFrameworkDirectories = new string[] { @"c:\WINNT\Microsoft.NET\Framework\v4.0.MyVersion" };
@@ -538,7 +528,6 @@ public void DotNetAssemblyDependsOnAWinMDFile()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
             t.TargetProcessorArchitecture = "X86";
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
@@ -575,7 +564,6 @@ public void ResolveWinmdWithInvalidPENativeDependency()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             bool succeeded = Execute(t);
@@ -608,7 +596,6 @@ public void ResolveWinmdWithArchitectureDependencyMatchingArchitecturesX86()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             t.TargetProcessorArchitecture = "X86";
@@ -643,7 +630,6 @@ public void ResolveWinmdWithArchitectureDependencyAnyCPUNative()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             t.TargetProcessorArchitecture = "X86";
@@ -705,7 +691,6 @@ private void VerifyImplementationArchitecture(string winmdName, string targetPro
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMDArchVerification" };
             t.TargetProcessorArchitecture = targetProcessorArchitecture;
@@ -780,7 +765,6 @@ public void DotNetAssemblyDependsOnAWinMDFileWithVersion255()
             ResolveAssemblyReference t = new ResolveAssemblyReference();
 
             t.BuildEngine = engine;
-            t.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             t.Assemblies = assemblyFiles;
             t.SearchPaths = new String[] { @"C:\WinMD", @"C:\WinMD\v4\", @"C:\WinMD\v255\" };
             bool succeeded = Execute(t);
diff --git a/src/Tasks.UnitTests/GetReferencePaths_Tests.cs b/src/Tasks.UnitTests/GetReferencePaths_Tests.cs
index 0d71f55d841..dd95e6eef56 100644
--- a/src/Tasks.UnitTests/GetReferencePaths_Tests.cs
+++ b/src/Tasks.UnitTests/GetReferencePaths_Tests.cs
@@ -37,7 +37,6 @@ public void TestGeneralFrameworkMonikerGood()
             string targetFrameworkMoniker = ".NetFramework, Version=v4.8";
             MockEngine engine = new();
             GetReferenceAssemblyPaths getReferencePaths = new();
-            getReferencePaths.TaskEnvironment = TaskEnvironmentHelper.CreateForTest();
             getReferencePaths.BuildEngine = engine;
             getReferencePaths.TargetFrameworkMoniker = targetFrameworkMoniker;
             getReferencePaths.Execute();
diff --git a/src/Tasks.UnitTests/HintPathResolver_Tests.cs b/src/Tasks.UnitTests/HintPathResolver_Tests.cs
index 8aee9df8ea1..59298eb9e2a 100644
--- a/src/Tasks.UnitTests/HintPathResolver_Tests.cs
+++ b/src/Tasks.UnitTests/HintPathResolver_Tests.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
diff --git a/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs b/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs
index 018a8191931..19b6b7cb664 100644
--- a/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs
+++ b/src/Tasks.UnitTests/RARPrecomputedCache_Tests.cs
@@ -25,7 +25,6 @@ public void TestPrecomputedCacheOutput()
                 TransientTestFile standardCache = env.CreateFile(".cache");
                 ResolveAssemblyReference t = new ResolveAssemblyReference()
                 {
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     _cache = new SystemState()
                 };
                 t._cache.instanceLocalFileStateCache = new Dictionary<string, SystemState.FileState>() {
@@ -61,7 +60,6 @@ public void StandardCacheTakesPrecedence()
                 TransientTestFile standardCache = env.CreateFile(".cache");
                 ResolveAssemblyReference rarWriterTask = new ResolveAssemblyReference()
                 {
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     _cache = new SystemState()
                 };
                 rarWriterTask._cache.instanceLocalFileStateCache = new() {
@@ -91,7 +89,6 @@ public void StandardCacheTakesPrecedence()
 
                 ResolveAssemblyReference rarReaderTask = new ResolveAssemblyReference()
                 {
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest()
                 };
                 rarReaderTask.StateFile = standardCache.Path;
                 rarReaderTask.AssemblyInformationCachePaths = new ITaskItem[]
@@ -116,7 +113,6 @@ public void TestPreComputedCacheInputMatchesOutput()
                 TransientTestFile precomputedCache = env.CreateFile(".cache");
                 ResolveAssemblyReference rarWriterTask = new ResolveAssemblyReference()
                 {
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest(),
                     _cache = new SystemState()
                 };
                 string dllName = Path.Combine(Path.GetDirectoryName(precomputedCache.Path), "randomFolder", "dll.dll");
@@ -139,7 +135,6 @@ public void TestPreComputedCacheInputMatchesOutput()
 
                 ResolveAssemblyReference rarReaderTask = new ResolveAssemblyReference()
                 {
-                    TaskEnvironment = TaskEnvironmentHelper.CreateForTest()
                 };
                 rarReaderTask.StateFile = precomputedCache.Path.Substring(0, precomputedCache.Path.Length - 6); // Not a real path; should not be used.
                 rarReaderTask.AssemblyInformationCachePaths = new ITaskItem[]

From 4d72a84dc01346d2025245f5c0e5454e5088dc95 Mon Sep 17 00:00:00 2001
From: Jan Provaznik <janprovaznik@microsoft.com>
Date: Mon, 4 May 2026 18:40:00 +0200
Subject: [PATCH 29/29] Fix stale Wave 18.6 comments to Wave 18.8

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
index 3c203a391f0..a75fb8b2140 100644
--- a/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
+++ b/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs
@@ -1129,7 +1129,7 @@ public ITaskItem[] UnresolvedAssemblyConflicts
         
         /// <summary>
         /// Converts a path to an <see cref="AbsolutePath"/>. Returns <c>default</c> for null or empty paths.
-        /// Under Wave 18.6, absolutizes relative paths via <see cref="TaskEnvironment"/>.
+        /// Under Wave 18.8, absolutizes relative paths via <see cref="TaskEnvironment"/>.
         /// Otherwise, wraps the raw string to preserve pre-wave behavior.
         /// </summary>
         private AbsolutePath MakeAbsolutePath(string path)
@@ -1157,7 +1157,7 @@ private AbsolutePath[] MakeAbsolutePaths(string[] paths)
         /// Converts a path to an <see cref="AbsolutePath"/> in canonical form (resolves ".." etc.).
         /// Returns <c>default</c> for null or empty paths.
         /// Canonical form is needed for paths used in string comparisons.
-        /// Under Wave 18.6, absolutizes and canonicalizes. Otherwise, wraps the raw string.
+        /// Under Wave 18.8, absolutizes and canonicalizes. Otherwise, wraps the raw string.
         /// </summary>
         private AbsolutePath MakeCanonicalPath(string path)
         {
@@ -2509,7 +2509,7 @@ internal bool Execute(
                                 // Prior to Wave18_8, empty strings would cause TaskEnvironment.GetAbsolutePath() to throw an exception,
                                 // which would be caught and logged as an error, stopping RAR execution.
                                 // With the new behavior, empty strings are silently ignored (treated like null).
-                                // When Wave 18.6 is disabled, we preserve the old failure behavior.
+                                // When Wave 18.8 is disabled, we preserve the old failure behavior.
                                 // When cleaning up this change wave, also clean up the _appConfigValueIsEmptyString field.
                                 
                                 // Note, second part of the sentence is not localized: this is a temporary fallback behind a change wave that is off by default