@atelierai/uco 1.0.6 → 1.0.8

package/vendor/plugin/com.atelierai.unity.copilot/Tests/Editor/DependencyResolver/NuGetLegacyMigrationTests.cs

@@ -1,304 +1,304 @@
-/*
-+------------------------------------------------------------------+
-|  Author: Ivan Murzak (https://github.com/IvanMurzak)             |
-|  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    |
-|  Copyright (c) 2025 Ivan Murzak                                  |
-|  Licensed under the Apache License, Version 2.0.                 |
-|  See the LICENSE file in the project root for more information.  |
-+------------------------------------------------------------------+
-*/
-
-#nullable enable
-using System.IO;
-using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using NUnit.Framework;
-using UnityEngine.TestTools;
-using com.AtelierAI.Unity.Copilot.Editor.DependencyResolver;
-
-namespace com.AtelierAI.Unity.Copilot.Editor.Tests.DependencyResolverTests
-{
-    /// <summary>
-    /// Coverage for issue #733's mandatory legacy → flat-layout migration. Every
-    /// existing user upgrading to the new resolver still has DLLs sitting under
-    /// <c>Assets/Plugins/NuGet/{Id}.{Version}/</c> from a pre-fix install. The
-    /// migration MUST delete those folders before any flat-layout DLL is
-    /// written, in the same restore cycle, otherwise the project ends up with
-    /// duplicate copies of every assembly and Unity's compiler errors with
-    /// CS0436 / CS0433.
-    /// </summary>
-    [TestFixture]
-    public class NuGetLegacyMigrationTests
-    {
-        string _installPath = string.Empty;
-
-        [SetUp]
-        public void SetUp()
-        {
-            _installPath = Path.Combine(
-                Path.GetTempPath(),
-                "UnityMcp-Migration-" + Path.GetRandomFileName());
-            Directory.CreateDirectory(_installPath);
-        }
-
-        [TearDown]
-        public void TearDown()
-        {
-            if (Directory.Exists(_installPath))
-            {
-                try { Directory.Delete(_installPath, recursive: true); }
-                catch { /* best-effort cleanup */ }
-            }
-        }
-
-        [Test]
-        public void Run_NoLegacyState_ReturnsNoLegacyState_OnEmptyInstallPath()
-        {
-            var result = NuGetLegacyMigration.Run(_installPath);
-
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.NoLegacyState, result.Outcome);
-            Assert.AreEqual(0, result.RemovedItems.Count);
-        }
-
-        [Test]
-        public void Run_NoLegacyState_ReturnsNoLegacyState_OnUnversionedFlatInstall()
-        {
-            // Steady-state install in the unversioned flat layout: no legacy
-            // {Id}.{Version}/ directories, no versioned-filename {stem}.{v}.dll
-            // siblings — the migration must short-circuit and touch nothing.
-            File.WriteAllText(Path.Combine(_installPath, "System.Memory.dll"), "dummy");
-            File.WriteAllText(Path.Combine(_installPath, "System.Memory.dll.meta"), "meta");
-            File.WriteAllText(Path.Combine(_installPath, ".nuget-installed.json"), "{}");
-
-            var result = NuGetLegacyMigration.Run(_installPath);
-
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.NoLegacyState, result.Outcome);
-            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "System.Memory.dll")));
-        }
-
-        [Test]
-        public void Run_HappyPath_RemovesLegacyDirectoriesAndMetas()
-        {
-            // Seed several legacy directories: single-DLL package and a multi-DLL package.
-            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
-            CreateLegacyPackage("Microsoft.Bcl.Memory", "10.0.3",
-                "System.Memory.dll", "System.Buffers.dll", "System.Runtime.CompilerServices.Unsafe.dll");
-
-            var result = NuGetLegacyMigration.Run(_installPath);
-
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
-            Assert.AreEqual(2, result.RemovedItems.Count);
-            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
-            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5.meta")));
-            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3")));
-            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3.meta")));
-        }
-
-        [Test]
-        public void Run_Idempotent_SecondRunIsNoOp()
-        {
-            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
-
-            var first = NuGetLegacyMigration.Run(_installPath);
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, first.Outcome);
-
-            var second = NuGetLegacyMigration.Run(_installPath);
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.NoLegacyState, second.Outcome);
-            Assert.AreEqual(0, second.RemovedItems.Count);
-        }
-
-        [Test]
-        public void Run_MixedLegacyState_MigratesLegacyDirsAndVersionedFiles_LeavesUnrelatedContent()
-        {
-            // Mixed install: a legacy {Id}.{Version}/ folder, a flat
-            // versioned-filename DLL, and unrelated user content. The migration
-            // sweeps both legacy artifacts in one pass and leaves the user's
-            // directory + unversioned canonical untouched.
-            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
-            File.WriteAllText(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3.dll"), "flat-versioned-leftover");
-            File.WriteAllText(Path.Combine(_installPath, "Microsoft.Bcl.Memory.dll"), "canonical");
-            Directory.CreateDirectory(Path.Combine(_installPath, "ReadMe"));
-            File.WriteAllText(Path.Combine(_installPath, "ReadMe", "notes.txt"), "user notes");
-
-            var result = NuGetLegacyMigration.Run(_installPath);
-
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
-            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
-            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3.dll")),
-                "Versioned-filename flat DLLs are now legacy and must be swept.");
-            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.dll")),
-                "Unversioned canonical filenames must not be touched by migration.");
-            Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "ReadMe")),
-                "Non-package directories must not be touched by migration.");
-        }
-
-        [Test]
-        public void Run_VersionedFilenameDllsAtRoot_AreSwept()
-        {
-            // Migration from the pre-unversioned-filename resolver: any flat
-            // {stem}.{numericVersion}.dll at the install root is by
-            // definition stale once the canonical filename is just {stem}.dll.
-            // The migration sweeps them in the same pass that removes
-            // legacy {Id}.{Version}/ directories.
-            File.WriteAllText(Path.Combine(_installPath, "McpPlugin.6.2.1.dll"), "stale");
-            File.WriteAllText(Path.Combine(_installPath, "McpPlugin.6.2.1.dll.meta"), "meta");
-            File.WriteAllText(Path.Combine(_installPath, "System.Text.Json.8.0.5.dll"), "stale");
-            File.WriteAllText(Path.Combine(_installPath, "System.Text.Json.8.0.5.dll.meta"), "meta");
-            // Unversioned canonicals must NOT be touched.
-            File.WriteAllText(Path.Combine(_installPath, "ReadMe.dll"), "user-content");
-            File.WriteAllText(Path.Combine(_installPath, "Foo.dll"), "canonical");
-
-            var result = NuGetLegacyMigration.Run(_installPath);
-
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
-            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "McpPlugin.6.2.1.dll")));
-            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "McpPlugin.6.2.1.dll.meta")),
-                ".meta sidecar must be deleted alongside the DLL.");
-            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5.dll")));
-            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "ReadMe.dll")),
-                "Unversioned filenames are the new canonical and must be preserved.");
-            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "Foo.dll")));
-        }
-
-        [Test]
-        public void Run_LegacyDirWithSemVerPrerelease_RemovedAsLegacy()
-        {
-            // NuGet folder names can contain SemVer prerelease / build-metadata
-            // suffixes (e.g. `Microsoft.Extensions.Logging.8.0.1-preview`).
-            // System.Version.TryParse rejects those tails, so an earlier version
-            // of the migration silently left those folders on disk and the user
-            // ended up with both the legacy nested DLL and the new flat-layout
-            // DLL coexisting — duplicate-assembly compile errors. Pin the
-            // SemVer-shape fallback in `ExtractPackageIdFromDirName` so the
-            // migration removes them.
-            CreateLegacyPackage("Foo.Bar", "1.0.0-preview", "Foo.Bar.dll");
-            CreateLegacyPackage("Baz", "2.3.4+build.42", "Baz.dll");
-            CreateLegacyPackage("Qux", "1.0.0-rc.1", "Qux.dll");
-
-            var result = NuGetLegacyMigration.Run(_installPath);
-
-            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
-            Assert.AreEqual(3, result.RemovedItems.Count);
-            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Foo.Bar.1.0.0-preview")));
-            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Baz.2.3.4+build.42")));
-            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Qux.1.0.0-rc.1")));
-        }
-
-#if UNITY_EDITOR_WIN
-        // Windows-only: simulates a `FileShare.None` lock that Unity holds on a
-        // DLL it has loaded into the editor AppDomain. Linux/macOS use advisory
-        // locking — `FileShare.None` does not prevent `File.Delete` there — so
-        // gating on `UNITY_EDITOR_WIN` keeps the assertion honest. The
-        // post-best-effort migration no longer aborts the entire restore on a
-        // single locked file: the call returns `AbortedFileLock` to surface
-        // that some directory is still on disk, but the caller may continue
-        // safely (the locked file's PluginImporter is disabled so the next
-        // domain reload unloads it and the next migration pass cleans it up).
-        [Test]
-        public void Run_FileLock_LeavesBlockedFolderIntactAndReportsAbortedFileLock()
-        {
-            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
-            var lockedDll = Path.Combine(_installPath, "System.Text.Json.8.0.5", "System.Text.Json.dll");
-
-            // Best-effort migration logs a warning (not an error) for blocked folders.
-            LogAssert.Expect(UnityEngine.LogType.Warning, new Regex(@"\[NuGet\] Could not fully remove legacy install directory"));
-
-            using (var lockHandle = new FileStream(lockedDll, FileMode.Open, FileAccess.Read, FileShare.None))
-            {
-                var result = NuGetLegacyMigration.Run(_installPath);
-
-                Assert.AreEqual(NuGetLegacyMigration.Outcome.AbortedFileLock, result.Outcome);
-                Assert.IsNotNull(result.FirstFailedItem);
-                Assert.IsNotNull(result.FirstFailureMessage);
-                // Blocked folder still on disk — the next reload picks it back up.
-                Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
-            }
-        }
-
-        [Test]
-        public void Run_FileLock_OneFolderBlocked_OtherFoldersAreStillRemoved()
-        {
-            // Mixed state: a blocked folder must NOT prevent unblocked folders
-            // from being cleaned up — that's the whole point of best-effort.
-            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
-            CreateLegacyPackage("R3", "1.3.0", "R3.dll");
-            var lockedDll = Path.Combine(_installPath, "System.Text.Json.8.0.5", "System.Text.Json.dll");
-
-            LogAssert.Expect(UnityEngine.LogType.Warning, new Regex(@"\[NuGet\] Could not fully remove legacy install directory"));
-
-            using (var lockHandle = new FileStream(lockedDll, FileMode.Open, FileAccess.Read, FileShare.None))
-            {
-                var result = NuGetLegacyMigration.Run(_installPath);
-
-                Assert.AreEqual(NuGetLegacyMigration.Outcome.AbortedFileLock, result.Outcome);
-                Assert.AreEqual(1, result.RemovedItems.Count,
-                    "The unblocked folder must still be removed even though a sibling folder was locked.");
-                Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")),
-                    "Blocked folder remains on disk for retry on the next pass.");
-                Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "R3.1.3.0")),
-                    "Unblocked folder must have been removed.");
-            }
-        }
-#endif
-
-#if !UNITY_EDITOR_WIN
-        // Unix counterpart of Run_FileLock_LeavesBlockedFolderIntactAndReportsAbortedFileLock.
-        // The migration catches both `IOException` (Windows file-lock) and
-        // `UnauthorizedAccessException` (Unix permission denial / antivirus /
-        // read-only flags) inside its per-file delete loop. Here we deny write
-        // on the install-path parent via `chmod 0o500`, which makes
-        // `File.Delete` and the trailing `Directory.Delete` both throw
-        // `UnauthorizedAccessException`. Self-skips when running as root.
-        [Test]
-        public void Run_PermissionDenied_LeavesBlockedFolderIntactAndReportsAbortedFileLock()
-        {
-            if (geteuid() == 0)
-                Assert.Ignore("chmod-based permission denial is bypassed by the kernel for uid=0; run this test as a non-root user.");
-
-            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
-
-            LogAssert.Expect(UnityEngine.LogType.Warning, new Regex(@"\[NuGet\] Could not fully remove legacy install directory"));
-
-            const uint READ_EXEC_ONLY = 0b101_000_000; // 0o500 — r-x------
-            const uint READ_WRITE_EXEC = 0b111_000_000; // 0o700 — rwx------ (TearDown-friendly)
-            if (chmod(_installPath, READ_EXEC_ONLY) != 0)
-                Assert.Inconclusive($"chmod {_installPath} -> 0o500 failed (errno={Marshal.GetLastWin32Error()})");
-
-            try
-            {
-                var result = NuGetLegacyMigration.Run(_installPath);
-
-                Assert.AreEqual(NuGetLegacyMigration.Outcome.AbortedFileLock, result.Outcome);
-                Assert.IsNotNull(result.FirstFailedItem);
-                Assert.IsNotNull(result.FirstFailureMessage);
-                Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
-            }
-            finally
-            {
-                // Always restore so [TearDown]'s recursive delete of `_installPath` succeeds.
-                chmod(_installPath, READ_WRITE_EXEC);
-            }
-        }
-
-        [DllImport("libc", SetLastError = true)]
-        static extern int chmod(string pathname, uint mode);
-
-        [DllImport("libc", SetLastError = true)]
-        static extern uint geteuid();
-#endif
-
-        /// <summary>
-        /// Creates a fake legacy <c>{Id}.{Version}/</c> directory with the
-        /// given DLL filenames inside, plus the sibling <c>.meta</c>.
-        /// </summary>
-        void CreateLegacyPackage(string id, string version, params string[] dllNames)
-        {
-            var dirName = $"{id}.{version}";
-            var dirPath = Path.Combine(_installPath, dirName);
-            Directory.CreateDirectory(dirPath);
-            foreach (var dll in dllNames)
-                File.WriteAllText(Path.Combine(dirPath, dll), "dummy");
-            File.WriteAllText(dirPath + ".meta", "fileFormatVersion: 2\nguid: 00000000000000000000000000000000\n");
-        }
-    }
-}
+/*
++------------------------------------------------------------------+
+|  Author: Ivan Murzak (https://github.com/IvanMurzak)             |
+|  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    |
+|  Copyright (c) 2025 Ivan Murzak                                  |
+|  Licensed under the Apache License, Version 2.0.                 |
+|  See the LICENSE file in the project root for more information.  |
++------------------------------------------------------------------+
+*/
+
+#nullable enable
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+using com.AtelierAI.Unity.Copilot.Editor.DependencyResolver;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.Tests.DependencyResolverTests
+{
+    /// <summary>
+    /// Coverage for issue #733's mandatory legacy → flat-layout migration. Every
+    /// existing user upgrading to the new resolver still has DLLs sitting under
+    /// <c>Assets/Plugins/NuGet/{Id}.{Version}/</c> from a pre-fix install. The
+    /// migration MUST delete those folders before any flat-layout DLL is
+    /// written, in the same restore cycle, otherwise the project ends up with
+    /// duplicate copies of every assembly and Unity's compiler errors with
+    /// CS0436 / CS0433.
+    /// </summary>
+    [TestFixture]
+    public class NuGetLegacyMigrationTests
+    {
+        string _installPath = string.Empty;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _installPath = Path.Combine(
+                Path.GetTempPath(),
+                "UnityMcp-Migration-" + Path.GetRandomFileName());
+            Directory.CreateDirectory(_installPath);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (Directory.Exists(_installPath))
+            {
+                try { Directory.Delete(_installPath, recursive: true); }
+                catch { /* best-effort cleanup */ }
+            }
+        }
+
+        [Test]
+        public void Run_NoLegacyState_ReturnsNoLegacyState_OnEmptyInstallPath()
+        {
+            var result = NuGetLegacyMigration.Run(_installPath);
+
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.NoLegacyState, result.Outcome);
+            Assert.AreEqual(0, result.RemovedItems.Count);
+        }
+
+        [Test]
+        public void Run_NoLegacyState_ReturnsNoLegacyState_OnUnversionedFlatInstall()
+        {
+            // Steady-state install in the unversioned flat layout: no legacy
+            // {Id}.{Version}/ directories, no versioned-filename {stem}.{v}.dll
+            // siblings — the migration must short-circuit and touch nothing.
+            File.WriteAllText(Path.Combine(_installPath, "System.Memory.dll"), "dummy");
+            File.WriteAllText(Path.Combine(_installPath, "System.Memory.dll.meta"), "meta");
+            File.WriteAllText(Path.Combine(_installPath, ".nuget-installed.json"), "{}");
+
+            var result = NuGetLegacyMigration.Run(_installPath);
+
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.NoLegacyState, result.Outcome);
+            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "System.Memory.dll")));
+        }
+
+        [Test]
+        public void Run_HappyPath_RemovesLegacyDirectoriesAndMetas()
+        {
+            // Seed several legacy directories: single-DLL package and a multi-DLL package.
+            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
+            CreateLegacyPackage("Microsoft.Bcl.Memory", "10.0.3",
+                "System.Memory.dll", "System.Buffers.dll", "System.Runtime.CompilerServices.Unsafe.dll");
+
+            var result = NuGetLegacyMigration.Run(_installPath);
+
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
+            Assert.AreEqual(2, result.RemovedItems.Count);
+            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
+            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5.meta")));
+            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3")));
+            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3.meta")));
+        }
+
+        [Test]
+        public void Run_Idempotent_SecondRunIsNoOp()
+        {
+            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
+
+            var first = NuGetLegacyMigration.Run(_installPath);
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, first.Outcome);
+
+            var second = NuGetLegacyMigration.Run(_installPath);
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.NoLegacyState, second.Outcome);
+            Assert.AreEqual(0, second.RemovedItems.Count);
+        }
+
+        [Test]
+        public void Run_MixedLegacyState_MigratesLegacyDirsAndVersionedFiles_LeavesUnrelatedContent()
+        {
+            // Mixed install: a legacy {Id}.{Version}/ folder, a flat
+            // versioned-filename DLL, and unrelated user content. The migration
+            // sweeps both legacy artifacts in one pass and leaves the user's
+            // directory + unversioned canonical untouched.
+            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
+            File.WriteAllText(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3.dll"), "flat-versioned-leftover");
+            File.WriteAllText(Path.Combine(_installPath, "Microsoft.Bcl.Memory.dll"), "canonical");
+            Directory.CreateDirectory(Path.Combine(_installPath, "ReadMe"));
+            File.WriteAllText(Path.Combine(_installPath, "ReadMe", "notes.txt"), "user notes");
+
+            var result = NuGetLegacyMigration.Run(_installPath);
+
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
+            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
+            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.10.0.3.dll")),
+                "Versioned-filename flat DLLs are now legacy and must be swept.");
+            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "Microsoft.Bcl.Memory.dll")),
+                "Unversioned canonical filenames must not be touched by migration.");
+            Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "ReadMe")),
+                "Non-package directories must not be touched by migration.");
+        }
+
+        [Test]
+        public void Run_VersionedFilenameDllsAtRoot_AreSwept()
+        {
+            // Migration from the pre-unversioned-filename resolver: any flat
+            // {stem}.{numericVersion}.dll at the install root is by
+            // definition stale once the canonical filename is just {stem}.dll.
+            // The migration sweeps them in the same pass that removes
+            // legacy {Id}.{Version}/ directories.
+            File.WriteAllText(Path.Combine(_installPath, "UcoPlugin.6.2.1.dll"), "stale");
+            File.WriteAllText(Path.Combine(_installPath, "UcoPlugin.6.2.1.dll.meta"), "meta");
+            File.WriteAllText(Path.Combine(_installPath, "System.Text.Json.8.0.5.dll"), "stale");
+            File.WriteAllText(Path.Combine(_installPath, "System.Text.Json.8.0.5.dll.meta"), "meta");
+            // Unversioned canonicals must NOT be touched.
+            File.WriteAllText(Path.Combine(_installPath, "ReadMe.dll"), "user-content");
+            File.WriteAllText(Path.Combine(_installPath, "Foo.dll"), "canonical");
+
+            var result = NuGetLegacyMigration.Run(_installPath);
+
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
+            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "UcoPlugin.6.2.1.dll")));
+            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "UcoPlugin.6.2.1.dll.meta")),
+                ".meta sidecar must be deleted alongside the DLL.");
+            Assert.IsFalse(File.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5.dll")));
+            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "ReadMe.dll")),
+                "Unversioned filenames are the new canonical and must be preserved.");
+            Assert.IsTrue(File.Exists(Path.Combine(_installPath, "Foo.dll")));
+        }
+
+        [Test]
+        public void Run_LegacyDirWithSemVerPrerelease_RemovedAsLegacy()
+        {
+            // NuGet folder names can contain SemVer prerelease / build-metadata
+            // suffixes (e.g. `Microsoft.Extensions.Logging.8.0.1-preview`).
+            // System.Version.TryParse rejects those tails, so an earlier version
+            // of the migration silently left those folders on disk and the user
+            // ended up with both the legacy nested DLL and the new flat-layout
+            // DLL coexisting — duplicate-assembly compile errors. Pin the
+            // SemVer-shape fallback in `ExtractPackageIdFromDirName` so the
+            // migration removes them.
+            CreateLegacyPackage("Foo.Bar", "1.0.0-preview", "Foo.Bar.dll");
+            CreateLegacyPackage("Baz", "2.3.4+build.42", "Baz.dll");
+            CreateLegacyPackage("Qux", "1.0.0-rc.1", "Qux.dll");
+
+            var result = NuGetLegacyMigration.Run(_installPath);
+
+            Assert.AreEqual(NuGetLegacyMigration.Outcome.Migrated, result.Outcome);
+            Assert.AreEqual(3, result.RemovedItems.Count);
+            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Foo.Bar.1.0.0-preview")));
+            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Baz.2.3.4+build.42")));
+            Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "Qux.1.0.0-rc.1")));
+        }
+
+#if UNITY_EDITOR_WIN
+        // Windows-only: simulates a `FileShare.None` lock that Unity holds on a
+        // DLL it has loaded into the editor AppDomain. Linux/macOS use advisory
+        // locking — `FileShare.None` does not prevent `File.Delete` there — so
+        // gating on `UNITY_EDITOR_WIN` keeps the assertion honest. The
+        // post-best-effort migration no longer aborts the entire restore on a
+        // single locked file: the call returns `AbortedFileLock` to surface
+        // that some directory is still on disk, but the caller may continue
+        // safely (the locked file's PluginImporter is disabled so the next
+        // domain reload unloads it and the next migration pass cleans it up).
+        [Test]
+        public void Run_FileLock_LeavesBlockedFolderIntactAndReportsAbortedFileLock()
+        {
+            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
+            var lockedDll = Path.Combine(_installPath, "System.Text.Json.8.0.5", "System.Text.Json.dll");
+
+            // Best-effort migration logs a warning (not an error) for blocked folders.
+            LogAssert.Expect(UnityEngine.LogType.Warning, new Regex(@"\[NuGet\] Could not fully remove legacy install directory"));
+
+            using (var lockHandle = new FileStream(lockedDll, FileMode.Open, FileAccess.Read, FileShare.None))
+            {
+                var result = NuGetLegacyMigration.Run(_installPath);
+
+                Assert.AreEqual(NuGetLegacyMigration.Outcome.AbortedFileLock, result.Outcome);
+                Assert.IsNotNull(result.FirstFailedItem);
+                Assert.IsNotNull(result.FirstFailureMessage);
+                // Blocked folder still on disk — the next reload picks it back up.
+                Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
+            }
+        }
+
+        [Test]
+        public void Run_FileLock_OneFolderBlocked_OtherFoldersAreStillRemoved()
+        {
+            // Mixed state: a blocked folder must NOT prevent unblocked folders
+            // from being cleaned up — that's the whole point of best-effort.
+            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
+            CreateLegacyPackage("R3", "1.3.0", "R3.dll");
+            var lockedDll = Path.Combine(_installPath, "System.Text.Json.8.0.5", "System.Text.Json.dll");
+
+            LogAssert.Expect(UnityEngine.LogType.Warning, new Regex(@"\[NuGet\] Could not fully remove legacy install directory"));
+
+            using (var lockHandle = new FileStream(lockedDll, FileMode.Open, FileAccess.Read, FileShare.None))
+            {
+                var result = NuGetLegacyMigration.Run(_installPath);
+
+                Assert.AreEqual(NuGetLegacyMigration.Outcome.AbortedFileLock, result.Outcome);
+                Assert.AreEqual(1, result.RemovedItems.Count,
+                    "The unblocked folder must still be removed even though a sibling folder was locked.");
+                Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")),
+                    "Blocked folder remains on disk for retry on the next pass.");
+                Assert.IsFalse(Directory.Exists(Path.Combine(_installPath, "R3.1.3.0")),
+                    "Unblocked folder must have been removed.");
+            }
+        }
+#endif
+
+#if !UNITY_EDITOR_WIN
+        // Unix counterpart of Run_FileLock_LeavesBlockedFolderIntactAndReportsAbortedFileLock.
+        // The migration catches both `IOException` (Windows file-lock) and
+        // `UnauthorizedAccessException` (Unix permission denial / antivirus /
+        // read-only flags) inside its per-file delete loop. Here we deny write
+        // on the install-path parent via `chmod 0o500`, which makes
+        // `File.Delete` and the trailing `Directory.Delete` both throw
+        // `UnauthorizedAccessException`. Self-skips when running as root.
+        [Test]
+        public void Run_PermissionDenied_LeavesBlockedFolderIntactAndReportsAbortedFileLock()
+        {
+            if (geteuid() == 0)
+                Assert.Ignore("chmod-based permission denial is bypassed by the kernel for uid=0; run this test as a non-root user.");
+
+            CreateLegacyPackage("System.Text.Json", "8.0.5", "System.Text.Json.dll");
+
+            LogAssert.Expect(UnityEngine.LogType.Warning, new Regex(@"\[NuGet\] Could not fully remove legacy install directory"));
+
+            const uint READ_EXEC_ONLY = 0b101_000_000; // 0o500 — r-x------
+            const uint READ_WRITE_EXEC = 0b111_000_000; // 0o700 — rwx------ (TearDown-friendly)
+            if (chmod(_installPath, READ_EXEC_ONLY) != 0)
+                Assert.Inconclusive($"chmod {_installPath} -> 0o500 failed (errno={Marshal.GetLastWin32Error()})");
+
+            try
+            {
+                var result = NuGetLegacyMigration.Run(_installPath);
+
+                Assert.AreEqual(NuGetLegacyMigration.Outcome.AbortedFileLock, result.Outcome);
+                Assert.IsNotNull(result.FirstFailedItem);
+                Assert.IsNotNull(result.FirstFailureMessage);
+                Assert.IsTrue(Directory.Exists(Path.Combine(_installPath, "System.Text.Json.8.0.5")));
+            }
+            finally
+            {
+                // Always restore so [TearDown]'s recursive delete of `_installPath` succeeds.
+                chmod(_installPath, READ_WRITE_EXEC);
+            }
+        }
+
+        [DllImport("libc", SetLastError = true)]
+        static extern int chmod(string pathname, uint mode);
+
+        [DllImport("libc", SetLastError = true)]
+        static extern uint geteuid();
+#endif
+
+        /// <summary>
+        /// Creates a fake legacy <c>{Id}.{Version}/</c> directory with the
+        /// given DLL filenames inside, plus the sibling <c>.meta</c>.
+        /// </summary>
+        void CreateLegacyPackage(string id, string version, params string[] dllNames)
+        {
+            var dirName = $"{id}.{version}";
+            var dirPath = Path.Combine(_installPath, dirName);
+            Directory.CreateDirectory(dirPath);
+            foreach (var dll in dllNames)
+                File.WriteAllText(Path.Combine(dirPath, dll), "dummy");
+            File.WriteAllText(dirPath + ".meta", "fileFormatVersion: 2\nguid: 00000000000000000000000000000000\n");
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Tests/Editor/Environment/EnvironmentUtilsTests.cs

@@ -15,7 +15,7 @@ using System.Text.Json;
 using System.Text.Json.Serialization;
 using com.AtelierAI.Unity.Copilot.Runtime.Utils;
 using NUnit.Framework;
-using static com.AtelierAI.Uco.Framework.Common.Consts.MCP.Server;
+using static com.AtelierAI.Uco.Framework.Common.Consts.Uco.Server;
 
 namespace com.AtelierAI.Unity.Copilot.Editor.Tests
 {
@@ -107,14 +107,14 @@ namespace com.AtelierAI.Unity.Copilot.Editor.Tests
             EnvironmentUtils.ApplyEnvironmentOverrides(config, args, env);
 
             Assert.AreEqual("FLAG_TOKEN", config.LocalToken,
-                "When both --token and UNITY_MCP_TOKEN are set, the flag must win.");
+                "When both --token and UNITY_COPILOT_TOKEN are set, the flag must win.");
         }
 
         [Test]
         public void Override_UnityMcpStyleFlag_BeatsEnvVar()
         {
-            // CLI translates --token foo into UNITY_MCP_TOKEN env, but the plugin still
-            // accepts --UNITY_MCP_TOKEN=foo style flags directly. They must beat env vars.
+            // CLI translates --token foo into UNITY_COPILOT_TOKEN env, but the plugin still
+            // accepts --UNITY_COPILOT_TOKEN=foo style flags directly. They must beat env vars.
             var config = BuildDiskConfig();
             var args = Args((EnvironmentUtils.EnvToken, "FLAG_VIA_FULL_NAME"));
             var env = Env((EnvironmentUtils.EnvToken, "ENV_TOKEN"));