@mflrevan/ucp 0.4.6 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.4.6` of the Unity Control Protocol CLI.
+Version `0.5.0` of the Unity Control Protocol CLI.
 
 This package installs the `ucp` command, downloads the matching published binary for your platform during `postinstall`, and ships the matching Unity bridge payload inside the npm package.
 

package/bridge/com.ucp.bridge/Editor/Bridge/BridgeServer.cs

@@ -26,7 +26,7 @@ namespace UCP.Bridge
         private const int DefaultPort = 21342;
         private const int MaxPort = 21352;
         private const int MaxConnections = 4;
-        private const string ProtocolVersion = "0.4.6";
+        private const string ProtocolVersion = "0.5.0";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;
@@ -162,6 +162,9 @@ namespace UCP.Bridge
 
             // Package management
             PackagesController.Register(s_router);
+
+            // Reference search (bridge fallback)
+            ReferenceController.Register(s_router);
         }
 
         private static void StartServer()

package/bridge/com.ucp.bridge/Editor/Controllers/AssetController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Reflection;
 using UnityEditor;
 using UnityEngine;
@@ -17,6 +18,8 @@ namespace UCP.Bridge
             router.Register("asset/write-batch", HandleWriteScriptableObjectBatch);
             router.Register("asset/create-so", HandleCreateScriptableObject);
             router.Register("asset/delete", HandleDeleteAsset);
+            router.Register("asset/move", HandleMoveAsset);
+            router.Register("asset/bulk-move", HandleBulkMoveAssets);
         }
 
         private static object HandleSearch(string paramsJson)
@@ -334,6 +337,87 @@ namespace UCP.Bridge
             };
         }
 
+        private static object HandleMoveAsset(string paramsJson)
+        {
+            var parameters = ParseParameters(paramsJson);
+            var sourcePath = RequirePathParameter(parameters, "path");
+            var destination = RequirePathParameter(parameters, "destination");
+
+            var result = MoveAssetInternal(sourcePath, destination, true);
+            return result;
+        }
+
+        private static object HandleBulkMoveAssets(string paramsJson)
+        {
+            var parameters = ParseParameters(paramsJson);
+            if (!parameters.TryGetValue("moves", out var movesObject) || movesObject == null)
+                throw new ArgumentException("Missing 'moves' parameter");
+
+            var continueOnError = TryGetOptionalBool(parameters, "continueOnError");
+            var requests = ParseMoveRequests(movesObject);
+            var results = new List<object>();
+            var errors = new List<object>();
+            var movedCount = 0;
+            var stopped = false;
+            var anyChanged = false;
+
+            AssetDatabase.StartAssetEditing();
+            try
+            {
+                for (var index = 0; index < requests.Count; index++)
+                {
+                    var request = requests[index];
+                    try
+                    {
+                        var moveResult = MoveAssetInternal(request.SourcePath, request.Destination, false);
+                        results.Add(AddMoveIndex(moveResult, index));
+                        if (GetBool(moveResult, "changed"))
+                        {
+                            movedCount++;
+                            anyChanged = true;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        errors.Add(new Dictionary<string, object>
+                        {
+                            ["index"] = index,
+                            ["sourcePath"] = request.SourcePath,
+                            ["destinationPath"] = request.Destination,
+                            ["message"] = ex.Message
+                        });
+
+                        if (!continueOnError)
+                        {
+                            stopped = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                AssetDatabase.StopAssetEditing();
+            }
+
+            if (anyChanged)
+            {
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["requested"] = requests.Count,
+                ["moved"] = movedCount,
+                ["failed"] = errors.Count,
+                ["stopped"] = stopped,
+                ["results"] = results,
+                ["errors"] = errors
+            };
+        }
+
         private static void CreateFoldersRecursive(string path)
         {
             var parts = path.Replace("\\", "/").Split('/');
@@ -421,5 +505,266 @@ namespace UCP.Bridge
             return typeFilter?.Trim() ?? string.Empty;
         }
 
+        private static Dictionary<string, object> MoveAssetInternal(string sourcePath, string destination, bool finalize)
+        {
+            var normalizedSource = NormalizeMovePath(sourcePath);
+            var isFolder = AssetDatabase.IsValidFolder(normalizedSource);
+            if (!isFolder && !AssetDatabase.AssetPathExists(normalizedSource))
+                throw new ArgumentException($"Asset not found: {normalizedSource}");
+
+            if (!IsMovableAssetPath(normalizedSource))
+                throw new ArgumentException($"Asset moves are only supported under Assets/: {normalizedSource}");
+
+            var identity = DescribeExistingAsset(normalizedSource, isFolder);
+            var resolvedDestination = ResolveDestinationPath(normalizedSource, destination);
+            if (!IsMovableAssetPath(resolvedDestination))
+                throw new ArgumentException($"Destination must be under Assets/: {resolvedDestination}");
+
+            if (string.Equals(normalizedSource, resolvedDestination, StringComparison.OrdinalIgnoreCase))
+            {
+                return DescribeMovedAsset(normalizedSource, resolvedDestination, false, identity);
+            }
+
+            if (AssetDatabase.AssetPathExists(resolvedDestination) || AssetDatabase.IsValidFolder(resolvedDestination))
+                throw new ArgumentException($"Destination already exists: {resolvedDestination}");
+
+            EnsureParentFoldersExist(resolvedDestination);
+
+            var moveError = AssetDatabase.MoveAsset(normalizedSource, resolvedDestination);
+            if (!string.IsNullOrEmpty(moveError))
+                throw new InvalidOperationException(moveError);
+
+            if (finalize)
+            {
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            }
+
+            return DescribeMovedAsset(normalizedSource, resolvedDestination, true, identity);
+        }
+
+        private static Dictionary<string, object> DescribeMovedAsset(
+            string sourcePath,
+            string destinationPath,
+            bool changed,
+            AssetIdentity identity)
+        {
+            var payload = new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["sourcePath"] = sourcePath,
+                ["destinationPath"] = destinationPath,
+                ["changed"] = changed,
+                ["guid"] = identity.Guid,
+                ["isFolder"] = identity.IsFolder
+            };
+
+            if (!string.IsNullOrEmpty(identity.Name))
+            {
+                payload["name"] = identity.Name;
+            }
+
+            if (!string.IsNullOrEmpty(identity.Type))
+            {
+                payload["type"] = identity.Type;
+            }
+
+            return payload;
+        }
+
+        private static AssetIdentity DescribeExistingAsset(string assetPath, bool isFolder)
+        {
+            var guid = GetGuidForAssetPath(assetPath);
+            var name = isFolder ? System.IO.Path.GetFileName(assetPath.TrimEnd('/')) : null;
+            var type = isFolder ? "Folder" : null;
+
+            if (!isFolder)
+            {
+                var mainAsset = AssetDatabase.LoadMainAssetAtPath(assetPath);
+                if (mainAsset != null)
+                {
+                    name = mainAsset.name;
+                    type = mainAsset.GetType().Name;
+                }
+            }
+
+            return new AssetIdentity(guid, name, type, isFolder);
+        }
+
+        private static string GetGuidForAssetPath(string assetPath)
+        {
+            var guid = AssetDatabase.AssetPathToGUID(assetPath);
+            if (!string.IsNullOrEmpty(guid))
+                return guid;
+
+            var metaPath = ResolveProjectRelativePath(assetPath + ".meta");
+            if (!File.Exists(metaPath))
+                return string.Empty;
+
+            foreach (var line in File.ReadLines(metaPath))
+            {
+                if (!line.TrimStart().StartsWith("guid:", StringComparison.Ordinal))
+                    continue;
+
+                var parts = line.Split(new[] { ':' }, 2);
+                return parts.Length == 2 ? parts[1].Trim() : string.Empty;
+            }
+
+            return string.Empty;
+        }
+
+        private static string ResolveProjectRelativePath(string assetPath)
+        {
+            var projectRoot = Path.GetDirectoryName(Application.dataPath);
+            return Path.Combine(projectRoot, assetPath.Replace('/', Path.DirectorySeparatorChar));
+        }
+
+        private static string ResolveDestinationPath(string sourcePath, string destination)
+        {
+            var normalizedDestination = NormalizeMovePath(destination);
+            if (string.IsNullOrEmpty(normalizedDestination))
+                throw new ArgumentException("Missing 'destination' parameter");
+
+            if (AssetDatabase.IsValidFolder(normalizedDestination))
+                return normalizedDestination + "/" + System.IO.Path.GetFileName(sourcePath);
+
+            if (normalizedDestination.EndsWith("/", StringComparison.Ordinal))
+                return normalizedDestination.TrimEnd('/') + "/" + System.IO.Path.GetFileName(sourcePath);
+
+            return normalizedDestination;
+        }
+
+        private static void EnsureParentFoldersExist(string assetPath)
+        {
+            var parent = System.IO.Path.GetDirectoryName(assetPath)?.Replace("\\", "/");
+            if (string.IsNullOrEmpty(parent) || AssetDatabase.IsValidFolder(parent))
+                return;
+
+            CreateFoldersRecursive(parent);
+        }
+
+        private static string NormalizeMovePath(string path)
+        {
+            return path?.Trim().Replace('\\', '/');
+        }
+
+        private static bool IsMovableAssetPath(string path)
+        {
+            return !string.IsNullOrEmpty(path)
+                && (path.Equals("Assets", StringComparison.OrdinalIgnoreCase)
+                    || path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase));
+        }
+
+        private static Dictionary<string, object> ParseParameters(string paramsJson)
+        {
+            return MiniJson.Deserialize(paramsJson) as Dictionary<string, object>
+                ?? throw new ArgumentException("Invalid parameters");
+        }
+
+        private static string RequirePathParameter(Dictionary<string, object> parameters, string key)
+        {
+            if (!parameters.TryGetValue(key, out var valueObject) || valueObject == null)
+                throw new ArgumentException($"Missing '{key}' parameter");
+
+            var value = valueObject.ToString();
+            if (string.IsNullOrWhiteSpace(value))
+                throw new ArgumentException($"Missing '{key}' parameter");
+
+            return value;
+        }
+
+        private static bool TryGetOptionalBool(Dictionary<string, object> parameters, string key)
+        {
+            return parameters.TryGetValue(key, out var valueObject)
+                && valueObject != null
+                && Convert.ToBoolean(valueObject);
+        }
+
+        private static List<MoveRequest> ParseMoveRequests(object movesObject)
+        {
+            var requests = new List<MoveRequest>();
+
+            if (movesObject is List<object> list)
+            {
+                foreach (var item in list)
+                {
+                    if (!(item is Dictionary<string, object> entry))
+                        throw new ArgumentException("Each bulk move entry must be an object");
+
+                    requests.Add(new MoveRequest(
+                        RequireMoveEntry(entry, "from"),
+                        RequireMoveEntry(entry, "to")));
+                }
+            }
+            else if (movesObject is Dictionary<string, object> map)
+            {
+                foreach (var entry in map)
+                {
+                    if (entry.Value == null)
+                        throw new ArgumentException($"Missing destination for bulk move source '{entry.Key}'");
+                    requests.Add(new MoveRequest(entry.Key, entry.Value.ToString()));
+                }
+            }
+            else
+            {
+                throw new ArgumentException("'moves' must be a JSON array or object map");
+            }
+
+            return requests;
+        }
+
+        private static string RequireMoveEntry(Dictionary<string, object> entry, string key)
+        {
+            if (!entry.TryGetValue(key, out var valueObject) || valueObject == null)
+                throw new ArgumentException($"Bulk move entry missing '{key}'");
+
+            var value = valueObject.ToString();
+            if (string.IsNullOrWhiteSpace(value))
+                throw new ArgumentException($"Bulk move entry missing '{key}'");
+
+            return value;
+        }
+
+        private static Dictionary<string, object> AddMoveIndex(Dictionary<string, object> payload, int index)
+        {
+            payload["index"] = index;
+            return payload;
+        }
+
+        private static bool GetBool(Dictionary<string, object> payload, string key)
+        {
+            return payload.TryGetValue(key, out var valueObject)
+                && valueObject != null
+                && Convert.ToBoolean(valueObject);
+        }
+
+        private readonly struct MoveRequest
+        {
+            public MoveRequest(string sourcePath, string destination)
+            {
+                SourcePath = sourcePath;
+                Destination = destination;
+            }
+
+            public string SourcePath { get; }
+            public string Destination { get; }
+        }
+
+        private readonly struct AssetIdentity
+        {
+            public AssetIdentity(string guid, string name, string type, bool isFolder)
+            {
+                Guid = guid ?? string.Empty;
+                Name = name;
+                Type = type;
+                IsFolder = isFolder;
+            }
+
+            public string Guid { get; }
+            public string Name { get; }
+            public string Type { get; }
+            public bool IsFolder { get; }
+        }
+
     }
 }

package/bridge/com.ucp.bridge/Editor/Controllers/ReferenceController.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// Bridge controller for reference search - used as a fallback when native Rust
+    /// indexing is not available (non-Force-Text projects) or for correctness verification.
+    /// </summary>
+    public static class ReferenceController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("references/find", HandleFind);
+            router.Register("references/serialization-status", HandleSerializationStatus);
+        }
+
+        private static object HandleSerializationStatus(string paramsJson)
+        {
+            var settings = new SerializedObject(
+                AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/EditorSettings.asset")[0]);
+            try
+            {
+                settings.Update();
+                var modeProp = settings.FindProperty("m_SerializationMode");
+                int mode = modeProp != null ? modeProp.intValue : -1;
+
+                return new Dictionary<string, object>
+                {
+                    { "serializationMode", mode },
+                    { "forceText", mode == 2 },
+                    { "visibleMetaFiles", EditorSettings.externalVersionControl == "Visible Meta Files" }
+                };
+            }
+            finally
+            {
+                settings.Dispose();
+            }
+        }
+
+        private static object HandleFind(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null)
+                throw new ArgumentException("Invalid parameters");
+
+            string targetGuid = null;
+            long targetFileId = 0;
+            int maxResults = 100;
+
+            if (p.TryGetValue("guid", out var gObj) && gObj != null)
+                targetGuid = gObj.ToString();
+            if (p.TryGetValue("fileId", out var fObj) && fObj != null)
+                targetFileId = Convert.ToInt64(fObj);
+            if (p.TryGetValue("maxResults", out var mObj) && mObj != null)
+                maxResults = Convert.ToInt32(mObj);
+
+            if (string.IsNullOrEmpty(targetGuid))
+                throw new ArgumentException("Missing 'guid' parameter");
+
+            var targetPath = AssetDatabase.GUIDToAssetPath(targetGuid);
+            var references = new List<object>();
+
+            // Phase 1: Find all assets that depend on the target using AssetDatabase
+            var allAssets = AssetDatabase.GetAllAssetPaths();
+            var dependentPaths = new List<string>();
+
+            foreach (var assetPath in allAssets)
+            {
+                if (!assetPath.StartsWith("Assets/") && !assetPath.StartsWith("Packages/"))
+                    continue;
+
+                var deps = AssetDatabase.GetDependencies(assetPath, false);
+                foreach (var dep in deps)
+                {
+                    if (dep == targetPath)
+                    {
+                        dependentPaths.Add(assetPath);
+                        break;
+                    }
+                }
+            }
+
+            // Phase 2: Walk SerializedObject properties to find exact reference locations
+            foreach (var sourcePath in dependentPaths)
+            {
+                if (references.Count >= maxResults)
+                    break;
+
+                var assets = AssetDatabase.LoadAllAssetsAtPath(sourcePath);
+                foreach (var asset in assets)
+                {
+                    if (asset == null) continue;
+                    if (references.Count >= maxResults) break;
+
+                    var so = new SerializedObject(asset);
+                    try
+                    {
+                        so.Update();
+                        var iterator = so.GetIterator();
+                        bool enterChildren = true;
+
+                        while (iterator.Next(enterChildren))
+                        {
+                            enterChildren = true;
+
+                            if (iterator.propertyType != SerializedPropertyType.ObjectReference)
+                                continue;
+
+                            var refValue = iterator.objectReferenceValue;
+                            if (refValue == null) continue;
+
+                            string refPath = AssetDatabase.GetAssetPath(refValue);
+                            if (string.IsNullOrEmpty(refPath)) continue;
+
+                            string refGuid = AssetDatabase.AssetPathToGUID(refPath);
+                            if (refGuid != targetGuid) continue;
+
+                            // If a specific fileId was requested, check it
+                            if (targetFileId != 0)
+                            {
+                                if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(
+                                    refValue, out string _, out long localId))
+                                    continue;
+                                if (localId != targetFileId)
+                                    continue;
+                            }
+
+                            references.Add(new Dictionary<string, object>
+                            {
+                                { "sourcePath", sourcePath },
+                                { "sourceObjectName", asset.name },
+                                { "sourceObjectType", asset.GetType().Name },
+                                { "propertyPath", iterator.propertyPath },
+                                { "targetGuid", targetGuid },
+                                { "targetPath", targetPath },
+                                { "referencedObjectName", refValue.name },
+                                { "referencedObjectType", refValue.GetType().Name }
+                            });
+
+                            if (references.Count >= maxResults)
+                                break;
+                        }
+                    }
+                    finally
+                    {
+                        so.Dispose();
+                    }
+                }
+            }
+
+            return new Dictionary<string, object>
+            {
+                { "targetGuid", targetGuid },
+                { "targetPath", targetPath ?? "" },
+                { "count", references.Count },
+                { "references", references }
+            };
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/ReferenceController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b9c94573b1b483180df2cfe7a7c6396
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/bridge/com.ucp.bridge/Tests/Editor/ControllerSmokeTests.cs

@@ -21,6 +21,12 @@ namespace UCP.Bridge.Tests
         private const string TempTextPath = "Assets/UcpControllerSmoke.txt";
         private const string TempScriptPath = "Assets/UcpControllerSmokeComponent.cs";
         private const string TempTexturePath = "Assets/UcpImporterSmoke.png";
+        private const string TempScenePath = "Assets/UcpControllerMoveScene.unity";
+        private const string TempMovedFolderPath = "Assets/UcpControllerMoved";
+        private const string TempMovedAssetPath = "Assets/UcpControllerMoved/UcpControllerSmoke.asset";
+        private const string TempMovedReferenceAssetPath = "Assets/UcpControllerMoved/UcpControllerReference.asset";
+        private const string TempMovedMaterialPath = "Assets/UcpControllerMoved/UcpControllerSmoke.mat";
+        private const string TempMovedScenePath = "Assets/UcpControllerMoved/UcpControllerMoveScene.unity";
         private const string TempProfilerExportPath = "ProfilerCaptures\\smoke-export.json";
         private const string TempLocalPackageFolder = "TempUcpLocalPackage";
         private const string TempLocalPackageName = "com.ucp.temp.local";
@@ -53,6 +59,8 @@ namespace UCP.Bridge.Tests
             DeleteTempTextFile();
             DeleteTempScriptFile();
             DeleteTempTextureAsset();
+            DeleteTempScene();
+            DeleteTempMovedFolder();
             DeleteTempProfilerExport();
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
@@ -74,6 +82,8 @@ namespace UCP.Bridge.Tests
             DeleteTempTextFile();
             DeleteTempScriptFile();
             DeleteTempTextureAsset();
+            DeleteTempScene();
+            DeleteTempMovedFolder();
             DeleteTempProfilerExport();
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
@@ -477,6 +487,144 @@ namespace UCP.Bridge.Tests
             Assert.That(AssetDatabase.GetAssetPath(reloaded.referenceAsset), Is.EqualTo(TempReferenceAssetPath));
         }
 
+        [Test]
+        public void AssetMove_PreservesCustomAssetReferenceAndGuid()
+        {
+            var reference = ScriptableObject.CreateInstance<SearchRootAsset>();
+            reference.name = "MoveTarget";
+            AssetDatabase.CreateAsset(reference, TempReferenceAssetPath);
+
+            var asset = ScriptableObject.CreateInstance<BatchWritableAsset>();
+            asset.referenceAsset = reference;
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var originalGuid = AssetDatabase.AssetPathToGUID(TempReferenceAssetPath);
+
+            var response = _router.Dispatch(
+                "asset/move",
+                1,
+                "{\"path\":\"" + TempReferenceAssetPath + "\",\"destination\":\"" + TempMovedReferenceAssetPath + "\"}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["changed"]), Is.True);
+            Assert.That(result["sourcePath"], Is.EqualTo(TempReferenceAssetPath));
+            Assert.That(result["destinationPath"], Is.EqualTo(TempMovedReferenceAssetPath));
+            Assert.That(result["guid"], Is.EqualTo(originalGuid));
+
+            var reloaded = AssetDatabase.LoadAssetAtPath<BatchWritableAsset>(TempAssetPath);
+            Assert.That(reloaded, Is.Not.Null);
+            Assert.That(reloaded.referenceAsset, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(reloaded.referenceAsset), Is.EqualTo(TempMovedReferenceAssetPath));
+            Assert.That(AssetDatabase.AssetPathToGUID(TempMovedReferenceAssetPath), Is.EqualTo(originalGuid));
+        }
+
+        [Test]
+        public void AssetBulkMove_MovesMultipleAssetsAndPreservesReferences()
+        {
+            var reference = ScriptableObject.CreateInstance<SearchRootAsset>();
+            reference.name = "BulkMoveRef";
+            AssetDatabase.CreateAsset(reference, TempReferenceAssetPath);
+
+            var asset = ScriptableObject.CreateInstance<BatchWritableAsset>();
+            asset.referenceAsset = reference;
+            asset.maxPlayers = 7;
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var response = _router.Dispatch(
+                "asset/bulk-move",
+                1,
+                "{\"moves\":["
+                + "{\"from\":\"" + TempReferenceAssetPath + "\",\"to\":\"" + TempMovedReferenceAssetPath + "\"},"
+                + "{\"from\":\"" + TempAssetPath + "\",\"to\":\"" + TempMovedAssetPath + "\"}"
+                + "]}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt32(result["requested"]), Is.EqualTo(2));
+            Assert.That(Convert.ToInt32(result["moved"]), Is.EqualTo(2));
+            Assert.That(Convert.ToInt32(result["failed"]), Is.EqualTo(0));
+
+            var movedAsset = AssetDatabase.LoadAssetAtPath<BatchWritableAsset>(TempMovedAssetPath);
+            Assert.That(movedAsset, Is.Not.Null);
+            Assert.That(movedAsset.maxPlayers, Is.EqualTo(7));
+            Assert.That(movedAsset.referenceAsset, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(movedAsset.referenceAsset), Is.EqualTo(TempMovedReferenceAssetPath));
+        }
+
+        [Test]
+        public void AssetMove_PreservesSceneMaterialReference()
+        {
+            var shader = Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard");
+            Assert.That(shader, Is.Not.Null);
+
+            var material = new Material(shader) { name = "MoveSceneMaterial" };
+            AssetDatabase.CreateAsset(material, TempMaterialPath);
+            AssetDatabase.SaveAssets();
+
+            var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            cube.name = "MoveSceneCube";
+            cube.GetComponent<MeshRenderer>().sharedMaterial = material;
+            Assert.That(EditorSceneManager.SaveScene(scene, TempScenePath), Is.True);
+
+            var response = _router.Dispatch(
+                "asset/move",
+                1,
+                "{\"path\":\"" + TempMaterialPath + "\",\"destination\":\"" + TempMovedMaterialPath + "\"}");
+
+            Assert.That(response.error, Is.Null);
+
+            EditorSceneManager.OpenScene(TempScenePath, OpenSceneMode.Single);
+            var movedCube = GameObject.Find("MoveSceneCube");
+            Assert.That(movedCube, Is.Not.Null);
+            var renderer = movedCube.GetComponent<MeshRenderer>();
+            Assert.That(renderer, Is.Not.Null);
+            Assert.That(renderer.sharedMaterial, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(renderer.sharedMaterial), Is.EqualTo(TempMovedMaterialPath));
+        }
+
+        [Test]
+        public void AssetMove_UpdatesBuildSettingsWhenSceneMoves()
+        {
+            var originalScenes = EditorBuildSettings.scenes;
+            try
+            {
+                var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+                var marker = new GameObject("MovedSceneMarker");
+                marker.transform.position = new Vector3(1f, 2f, 3f);
+                Assert.That(EditorSceneManager.SaveScene(scene, TempScenePath), Is.True);
+
+                var originalGuid = AssetDatabase.AssetPathToGUID(TempScenePath);
+                EditorBuildSettings.scenes = new[]
+                {
+                    new EditorBuildSettingsScene(TempScenePath, true)
+                };
+
+                var response = _router.Dispatch(
+                    "asset/move",
+                    1,
+                    "{\"path\":\"" + TempScenePath + "\",\"destination\":\"" + TempMovedScenePath + "\"}");
+
+                Assert.That(response.error, Is.Null);
+                Assert.That(AssetDatabase.AssetPathToGUID(TempMovedScenePath), Is.EqualTo(originalGuid));
+
+                Assert.That(EditorBuildSettings.scenes, Has.Length.EqualTo(1));
+                Assert.That(EditorBuildSettings.scenes[0].path, Is.EqualTo(TempMovedScenePath));
+
+                EditorSceneManager.OpenScene(TempMovedScenePath, OpenSceneMode.Single);
+                Assert.That(GameObject.Find("MovedSceneMarker"), Is.Not.Null);
+            }
+            finally
+            {
+                EditorBuildSettings.scenes = originalScenes;
+            }
+        }
+
         [Test]
         public void FileController_WritePatchRead_AndRejectsPathTraversal()
         {
@@ -935,6 +1083,24 @@ namespace UCP.Bridge.Tests
             AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
         }
 
+        private static void DeleteTempScene()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempScenePath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempScenePath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempMovedFolder()
+        {
+            if (AssetDatabase.IsValidFolder(TempMovedFolderPath))
+            {
+                AssetDatabase.DeleteAsset(TempMovedFolderPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
         private static void DeleteTempProfilerExport()
         {
             var fullPath = ResolveProjectRelativePath(TempProfilerExportPath);

package/bridge/com.ucp.bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "displayName": "Unity Control Protocol Bridge",
   "description": "WebSocket bridge for programmatic Unity Editor control via CLI and AI agents.",
   "unity": "2021.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mflrevan/ucp",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "Unity Control Protocol - CLI for programmatic Unity Editor control",
   "license": "MIT",
   "repository": {