@mflrevan/ucp 0.2.3 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.2.3` of the Unity Control Protocol CLI.
+Version `0.3.1` 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.
 
@@ -42,12 +42,14 @@ ucp build targets
 ucp install
 ```
 
+Default `ucp install` writes a tracked git dependency to `Packages/manifest.json` pinned to the CLI version. It does not write a local `file:` dependency unless you explicitly choose a local embedded mode.
+
 Or add this to `Packages/manifest.json`:
 
 ```json
 {
   "dependencies": {
-    "com.ucp.bridge": "https://github.com/mflRevan/unity-control-protocol.git?path=unity-package/com.ucp.bridge#v0.2.3"
+    "com.ucp.bridge": "https://github.com/mflRevan/unity-control-protocol.git?path=unity-package/com.ucp.bridge#v0.3.1"
   }
 }
 ```

package/bridge/com.ucp.bridge/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [0.3.1] - 2026-03-14
+
+### Added
+
+- Added `asset/write-batch` for multi-field serialized asset updates in one bridge call.
+
+### Changed
+
+- Player settings now expose `defaultIsNativeResolution` so installer automation can reconcile live editor state as well as on-disk project settings.
+- Object reference payloads now include asset `path` and `guid` when available.
+
+### Fixed
+
+- Fixed buffered log searches by applying regex filtering before count truncation.
+- Fixed buffered log list requests being capped to 10 returned entries regardless of requested `count`.
+- Fixed serialized object reference writes silently accepting unresolved references in both object and asset controllers.
+
+## [0.3.0] - 2026-03-13
+
+### Added
+
+- Dirty-scene automation controls in bridge scene/play handlers so unattended CLI workflows can avoid save-confirmation modal interruptions.
+
+### Changed
+
+- Scene load and play entry now auto-handle dirty scenes by default for non-interactive automation flows.
+
+### Fixed
+
+- Fixed edit-mode test execution when called during Play Mode by deferring run start until Play Mode exits.
+- Fixed workflow interruptions caused by Unity save-scene prompts during scene transitions and play mode entry.
+
 ## [0.2.3] - 2026-03-12
 
 ### Fixed

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.2.3";
+        private const string ProtocolVersion = "0.3.1";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;

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

@@ -14,6 +14,7 @@ namespace UCP.Bridge
             router.Register("asset/info", HandleInfo);
             router.Register("asset/read", HandleReadScriptableObject);
             router.Register("asset/write", HandleWriteScriptableObject);
+            router.Register("asset/write-batch", HandleWriteScriptableObjectBatch);
             router.Register("asset/create-so", HandleCreateScriptableObject);
         }
 
@@ -207,15 +208,44 @@ namespace UCP.Bridge
 
             string fieldName = fieldObj.ToString();
             var so = new SerializedObject(asset);
-            var prop = so.FindProperty(fieldName);
-            if (prop == null)
+            Undo.RecordObject(asset, $"UCP Write {fieldName}");
+            WriteFieldValue(so, asset, fieldName, p["value"]);
+            so.ApplyModifiedProperties();
+            EditorUtility.SetDirty(asset);
+            AssetDatabase.SaveAssetIfDirty(asset);
+            so.Dispose();
+
+            return new Dictionary<string, object>
             {
-                so.Dispose();
-                throw new ArgumentException($"Field '{fieldName}' not found on {asset.GetType().Name}");
+                ["status"] = "ok",
+                ["path"] = assetPath,
+                ["field"] = fieldName
+            };
+        }
+
+        private static object HandleWriteScriptableObjectBatch(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("path", out var pathObj))
+                throw new ArgumentException("Missing 'path' parameter");
+            if (!p.TryGetValue("values", out var valuesObj) || !(valuesObj is Dictionary<string, object> values))
+                throw new ArgumentException("Missing 'values' parameter");
+
+            string assetPath = pathObj.ToString();
+            var asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
+            if (asset == null)
+                throw new ArgumentException($"Asset not found: {assetPath}");
+
+            var so = new SerializedObject(asset);
+            Undo.RecordObject(asset, $"UCP Batch Write {asset.name}");
+
+            var fields = new List<object>();
+            foreach (var entry in values)
+            {
+                WriteFieldValue(so, asset, entry.Key, entry.Value);
+                fields.Add(entry.Key);
             }
 
-            Undo.RecordObject(asset, $"UCP Write {fieldName}");
-            WriteSerializedValue(prop, p["value"]);
             so.ApplyModifiedProperties();
             EditorUtility.SetDirty(asset);
             AssetDatabase.SaveAssetIfDirty(asset);
@@ -225,7 +255,7 @@ namespace UCP.Bridge
             {
                 ["status"] = "ok",
                 ["path"] = assetPath,
-                ["field"] = fieldName
+                ["fields"] = fields
             };
         }
 
@@ -381,14 +411,7 @@ namespace UCP.Bridge
                     var c = prop.colorValue;
                     return new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
                 case SerializedPropertyType.ObjectReference:
-                    if (prop.objectReferenceValue != null)
-                        return new Dictionary<string, object>
-                        {
-                            ["instanceId"] = prop.objectReferenceValue.GetInstanceID(),
-                            ["name"] = prop.objectReferenceValue.name,
-                            ["type"] = prop.objectReferenceValue.GetType().Name
-                        };
-                    return null;
+                    return ObjectReferenceResolver.Serialize(prop.objectReferenceValue);
                 case SerializedPropertyType.Enum:
                     return prop.enumValueIndex < prop.enumDisplayNames.Length
                         ? prop.enumDisplayNames[prop.enumValueIndex]
@@ -483,10 +506,9 @@ namespace UCP.Bridge
                         prop.quaternionValue = new Quaternion(Convert.ToSingle(qArr[0]), Convert.ToSingle(qArr[1]), Convert.ToSingle(qArr[2]), Convert.ToSingle(qArr[3]));
                     break;
                 case SerializedPropertyType.ObjectReference:
-                    if (value == null)
-                        prop.objectReferenceValue = null;
-                    else if (value is Dictionary<string, object> refDict && refDict.TryGetValue("instanceId", out var refId))
-                        prop.objectReferenceValue = EditorUtility.InstanceIDToObject(Convert.ToInt32(refId));
+                    prop.objectReferenceValue = ObjectReferenceResolver.Resolve(value, prop.displayName);
+                    if (value != null && prop.objectReferenceValue == null)
+                        throw new ArgumentException($"Unable to assign object reference to '{prop.displayName}'");
                     break;
                 case SerializedPropertyType.LayerMask:
                     prop.intValue = Convert.ToInt32(value);
@@ -495,5 +517,14 @@ namespace UCP.Bridge
                     throw new ArgumentException($"Cannot write property of type {prop.propertyType}");
             }
         }
+
+        private static void WriteFieldValue(SerializedObject serializedObject, UnityEngine.Object asset, string fieldName, object value)
+        {
+            var prop = serializedObject.FindProperty(fieldName);
+            if (prop == null)
+                throw new ArgumentException($"Field '{fieldName}' not found on {asset.GetType().Name}");
+
+            WriteSerializedValue(prop, value);
+        }
     }
 }

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

@@ -30,7 +30,7 @@ namespace UCP.Bridge
                 ["companyName"] = PlayerSettings.companyName,
                 ["productName"] = PlayerSettings.productName,
                 ["bundleVersion"] = PlayerSettings.bundleVersion,
-                ["defaultIsFullScreen"] = PlayerSettings.defaultIsNativeResolution,
+                ["defaultIsNativeResolution"] = PlayerSettings.defaultIsNativeResolution,
                 ["runInBackground"] = PlayerSettings.runInBackground,
                 ["colorSpace"] = PlayerSettings.colorSpace.ToString(),
                 ["graphicsApi"] = PlayerSettings.GetGraphicsAPIs(EditorUserBuildSettings.activeBuildTarget)?[0].ToString() ?? "Unknown",
@@ -67,6 +67,9 @@ namespace UCP.Bridge
                 case "runInBackground":
                     PlayerSettings.runInBackground = Convert.ToBoolean(value);
                     break;
+                case "defaultIsNativeResolution":
+                    PlayerSettings.defaultIsNativeResolution = Convert.ToBoolean(value);
+                    break;
                 case "defaultScreenWidth":
                     PlayerSettings.defaultScreenWidth = Convert.ToInt32(value);
                     break;

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

@@ -9,7 +9,6 @@ namespace UCP.Bridge
     public static class LogsController
     {
         private const int MaxHistoryEntries = 2000;
-        private const int MaxBulkResults = 10;
         private const int DefaultSearchWindow = 200;
         private const int MaxPreviewLength = 200;
 
@@ -145,8 +144,6 @@ namespace UCP.Bridge
                 if (!string.IsNullOrEmpty(query.Level))
                     candidates = candidates.Where(entry => PassesLevel(entry.Level, query.Level));
 
-                candidates = candidates.OrderByDescending(entry => entry.Id).Take(query.Count);
-
                 if (query.Regex != null)
                 {
                     candidates = candidates.Where(entry =>
@@ -155,14 +152,14 @@ namespace UCP.Bridge
                     );
                 }
 
-                var allMatches = candidates.ToList();
-                var returned = allMatches.Take(MaxBulkResults).Select(SerializeSummary).ToList();
+                var allMatches = candidates.OrderByDescending(entry => entry.Id).ToList();
+                var returned = allMatches.Take(query.Count).Select(SerializeSummary).ToList();
 
                 return new LogQueryResult
                 {
                     Total = allMatches.Count,
                     Returned = returned,
-                    Truncated = allMatches.Count > MaxBulkResults
+                    Truncated = allMatches.Count > returned.Count
                 };
             }
         }

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

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    internal static class ObjectReferenceResolver
+    {
+        public static Dictionary<string, object> Serialize(UnityEngine.Object obj)
+        {
+            if (obj == null)
+                return null;
+
+            var result = new Dictionary<string, object>
+            {
+                ["instanceId"] = obj.GetInstanceID(),
+                ["name"] = obj.name,
+                ["type"] = obj.GetType().Name
+            };
+
+            var assetPath = AssetDatabase.GetAssetPath(obj);
+            if (!string.IsNullOrEmpty(assetPath))
+            {
+                result["path"] = assetPath;
+                var guid = AssetDatabase.AssetPathToGUID(assetPath);
+                if (!string.IsNullOrEmpty(guid))
+                    result["guid"] = guid;
+            }
+
+            return result;
+        }
+
+        public static UnityEngine.Object Resolve(object value, string propertyName)
+        {
+            if (value == null)
+                return null;
+
+            if (value is Dictionary<string, object> reference)
+            {
+                if (reference.TryGetValue("instanceId", out var instanceId) && instanceId != null)
+                    return ResolveByInstanceId(Convert.ToInt32(instanceId), propertyName);
+
+                if (reference.TryGetValue("path", out var path) && path != null)
+                    return ResolveByPath(path.ToString(), propertyName);
+
+                if (reference.TryGetValue("guid", out var guid) && guid != null)
+                    return ResolveByGuid(guid.ToString(), propertyName);
+
+                throw new ArgumentException($"Object reference for '{propertyName}' must include instanceId, path, or guid");
+            }
+
+            if (value is string stringValue)
+            {
+                return stringValue.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)
+                    ? ResolveByPath(stringValue, propertyName)
+                    : ResolveByGuid(stringValue, propertyName);
+            }
+
+            if (value is sbyte || value is byte || value is short || value is ushort || value is int || value is uint || value is long || value is ulong)
+                return ResolveByInstanceId(Convert.ToInt32(value), propertyName);
+
+            throw new ArgumentException($"Unsupported object reference value for '{propertyName}'");
+        }
+
+        private static UnityEngine.Object ResolveByInstanceId(int instanceId, string propertyName)
+        {
+            var resolved = EditorUtility.InstanceIDToObject(instanceId);
+            if (resolved == null)
+                throw new ArgumentException($"Object reference for '{propertyName}' could not resolve instance id {instanceId}");
+
+            return resolved;
+        }
+
+        private static UnityEngine.Object ResolveByPath(string assetPath, string propertyName)
+        {
+            var resolved = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
+            if (resolved == null)
+                throw new ArgumentException($"Object reference for '{propertyName}' could not load asset at {assetPath}");
+
+            return resolved;
+        }
+
+        private static UnityEngine.Object ResolveByGuid(string guid, string propertyName)
+        {
+            var assetPath = AssetDatabase.GUIDToAssetPath(guid);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException($"Object reference for '{propertyName}' could not resolve guid {guid}");
+
+            return ResolveByPath(assetPath, propertyName);
+        }
+    }
+}

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

@@ -1,4 +1,7 @@
 using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+using System.Collections.Generic;
 
 namespace UCP.Bridge
 {
@@ -16,10 +19,53 @@ namespace UCP.Bridge
             if (EditorApplication.isPlaying)
                 return new { status = "already_playing" };
 
+            var saveDirtyScenes = GetBoolParam(paramsJson, "saveDirtyScenes", true);
+            var discardUntitled = GetBoolParam(paramsJson, "discardUntitled", true);
+            SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
+
             EditorApplication.isPlaying = true;
             return new { status = "ok" };
         }
 
+        private static bool GetBoolParam(string paramsJson, string key, bool defaultValue)
+        {
+            var parameters = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (parameters != null && parameters.TryGetValue(key, out var valueObj) && valueObj is bool value)
+                return value;
+
+            return defaultValue;
+        }
+
+        private static void SaveDirtyScenesIfRequested(bool saveDirtyScenes, bool discardUntitled)
+        {
+            if (!saveDirtyScenes)
+                return;
+
+            var requiresUntitledDiscard = false;
+
+            for (var index = 0; index < SceneManager.sceneCount; index++)
+            {
+                var scene = SceneManager.GetSceneAt(index);
+                if (!scene.isLoaded || !scene.isDirty)
+                    continue;
+
+                if (string.IsNullOrEmpty(scene.path))
+                {
+                    if (!discardUntitled)
+                        throw new System.InvalidOperationException("Dirty untitled scene cannot be auto-saved. Retry with discardUntitled=true.");
+
+                    requiresUntitledDiscard = true;
+                    continue;
+                }
+
+                if (!EditorSceneManager.SaveScene(scene))
+                    throw new System.InvalidOperationException($"Failed to auto-save dirty scene: {scene.path}");
+            }
+
+            if (requiresUntitledDiscard)
+                EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+        }
+
         private static object HandleStop(string paramsJson)
         {
             if (!EditorApplication.isPlaying)

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

@@ -218,14 +218,7 @@ namespace UCP.Bridge
                     var c = prop.colorValue;
                     return new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
                 case SerializedPropertyType.ObjectReference:
-                    if (prop.objectReferenceValue != null)
-                        return new Dictionary<string, object>
-                        {
-                            ["instanceId"] = prop.objectReferenceValue.GetInstanceID(),
-                            ["name"] = prop.objectReferenceValue.name,
-                            ["type"] = prop.objectReferenceValue.GetType().Name
-                        };
-                    return null;
+                    return ObjectReferenceResolver.Serialize(prop.objectReferenceValue);
                 case SerializedPropertyType.LayerMask:
                     return prop.intValue;
                 case SerializedPropertyType.Enum:
@@ -422,15 +415,9 @@ namespace UCP.Bridge
                     }
                     break;
                 case SerializedPropertyType.ObjectReference:
-                    if (value == null)
-                    {
-                        prop.objectReferenceValue = null;
-                    }
-                    else if (value is Dictionary<string, object> refDict && refDict.TryGetValue("instanceId", out var refId))
-                    {
-                        var obj = EditorUtility.InstanceIDToObject(Convert.ToInt32(refId));
-                        prop.objectReferenceValue = obj;
-                    }
+                    prop.objectReferenceValue = ObjectReferenceResolver.Resolve(value, prop.displayName);
+                    if (value != null && prop.objectReferenceValue == null)
+                        throw new ArgumentException($"Unable to assign object reference to '{prop.displayName}'");
                     break;
                 case SerializedPropertyType.LayerMask:
                     prop.intValue = Convert.ToInt32(value);
@@ -457,12 +444,7 @@ namespace UCP.Bridge
             if (value is Color c)
                 return new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
             if (value is UnityEngine.Object uObj)
-                return new Dictionary<string, object>
-                {
-                    ["instanceId"] = uObj.GetInstanceID(),
-                    ["name"] = uObj.name,
-                    ["type"] = uObj.GetType().Name
-                };
+                return ObjectReferenceResolver.Serialize(uObj);
             return value.ToString();
         }
 

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

@@ -40,6 +40,8 @@ namespace UCP.Bridge
                 throw new System.ArgumentException("Missing 'path' parameter");
 
             var path = pathObj.ToString();
+            var saveDirtyScenes = GetBoolParam(p, "saveDirtyScenes", true);
+            var discardUntitled = GetBoolParam(p, "discardUntitled", true);
 
             if (EditorApplication.isPlaying)
             {
@@ -47,12 +49,51 @@ namespace UCP.Bridge
             }
             else
             {
-                EditorSceneManager.OpenScene(path);
+                SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
+                EditorSceneManager.OpenScene(path, OpenSceneMode.Single);
             }
 
             return new { status = "ok", loaded = path };
         }
 
+        private static bool GetBoolParam(Dictionary<string, object> parameters, string key, bool defaultValue)
+        {
+            if (parameters != null && parameters.TryGetValue(key, out var valueObj) && valueObj is bool value)
+                return value;
+
+            return defaultValue;
+        }
+
+        private static void SaveDirtyScenesIfRequested(bool saveDirtyScenes, bool discardUntitled)
+        {
+            if (!saveDirtyScenes)
+                return;
+
+            var requiresUntitledDiscard = false;
+
+            for (var index = 0; index < SceneManager.sceneCount; index++)
+            {
+                var scene = SceneManager.GetSceneAt(index);
+                if (!scene.isLoaded || !scene.isDirty)
+                    continue;
+
+                if (string.IsNullOrEmpty(scene.path))
+                {
+                    if (!discardUntitled)
+                        throw new System.InvalidOperationException("Dirty untitled scene cannot be auto-saved. Retry with discardUntitled=true.");
+
+                    requiresUntitledDiscard = true;
+                    continue;
+                }
+
+                if (!EditorSceneManager.SaveScene(scene))
+                    throw new System.InvalidOperationException($"Failed to auto-save dirty scene: {scene.path}");
+            }
+
+            if (requiresUntitledDiscard)
+                EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+        }
+
         private static object HandleActive(string paramsJson)
         {
             var scene = SceneManager.GetActiveScene();

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

@@ -55,7 +55,21 @@ namespace UCP.Bridge
                 executionSettings.filters[0].testNames = new[] { filter };
             }
 
-            s_api.Execute(executionSettings);
+            var shouldWaitForPlayModeExit =
+                testMode == TestMode.EditMode &&
+                (EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode);
+
+            if (shouldWaitForPlayModeExit)
+            {
+                if (EditorApplication.isPlaying)
+                    EditorApplication.isPlaying = false;
+
+                ExecuteWhenReady(executionSettings, testMode, EditorApplication.timeSinceStartup + 30.0);
+            }
+            else
+            {
+                s_api.Execute(executionSettings);
+            }
 
             // Tests run asynchronously in Unity. We return immediately with a pending status.
             // Results will be sent as notifications when complete.
@@ -63,7 +77,53 @@ namespace UCP.Bridge
             {
                 ["status"] = "started",
                 ["mode"] = mode,
-                ["message"] = "Tests started. Results will arrive as notifications."
+                ["message"] = shouldWaitForPlayModeExit
+                    ? "Edit-mode tests queued. Waiting for Unity to exit play mode before starting."
+                    : "Tests started. Results will arrive as notifications."
+            };
+        }
+
+        private static void ExecuteWhenReady(ExecutionSettings settings, TestMode mode, double deadline)
+        {
+            EditorApplication.delayCall += () =>
+            {
+                var stillInPlayMode = EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode;
+                if (mode == TestMode.EditMode && stillInPlayMode)
+                {
+                    if (EditorApplication.timeSinceStartup > deadline)
+                    {
+                        BridgeServer.BroadcastNotification("tests/result", new Dictionary<string, object>
+                        {
+                            ["summary"] = new Dictionary<string, object>
+                            {
+                                ["total"] = 1,
+                                ["passed"] = 0,
+                                ["failed"] = 1,
+                                ["skipped"] = 0,
+                                ["duration"] = 0.0
+                            },
+                            ["tests"] = new List<object>
+                            {
+                                new Dictionary<string, object>
+                                {
+                                    ["name"] = "UCP.Bridge.Tests.PlayModeExitGuard",
+                                    ["status"] = "failed",
+                                    ["duration"] = 0.0,
+                                    ["message"] = "Timed out waiting for Unity to exit play mode before running edit-mode tests."
+                                }
+                            }
+                        });
+
+                        if (s_api != null && s_collector != null)
+                            s_api.UnregisterCallbacks(s_collector);
+                        return;
+                    }
+
+                    ExecuteWhenReady(settings, mode, deadline);
+                    return;
+                }
+
+                s_api.Execute(settings);
             };
         }
 

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

@@ -1,15 +1,22 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Text.RegularExpressions;
 using NUnit.Framework;
 using UnityEditor;
 using UnityEditor.SceneManagement;
 using UnityEngine;
+using UnityEngine.TestTools;
 
 namespace UCP.Bridge.Tests
 {
     public class ControllerSmokeTests
     {
         private const string TempAssetPath = "Assets/UcpControllerSmoke.asset";
+        private const string TempReferenceAssetPath = "Assets/UcpControllerReference.asset";
+        private const string TempPrefabPath = "Assets/UcpControllerSmoke.prefab";
+        private const string TempMaterialPath = "Assets/UcpControllerSmoke.mat";
+        private const string TempTextPath = "Assets/UcpControllerSmoke.txt";
 
         private CommandRouter _router;
 
@@ -20,8 +27,19 @@ namespace UCP.Bridge.Tests
             SnapshotController.Register(_router);
             AssetController.Register(_router);
             LogsController.Register(_router);
+            HierarchyController.Register(_router);
+            PropertyController.Register(_router);
+            FileController.Register(_router);
+            MaterialController.Register(_router);
+            PrefabController.Register(_router);
+            BuildController.Register(_router);
+            EditorSettingsController.Register(_router);
             EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
             DeleteTempAsset();
+            DeleteTempReferenceAsset();
+            DeleteTempPrefab();
+            DeleteTempMaterial();
+            DeleteTempTextFile();
             LogsController.ClearHistoryForTests();
         }
 
@@ -29,6 +47,10 @@ namespace UCP.Bridge.Tests
         public void TearDown()
         {
             DeleteTempAsset();
+            DeleteTempReferenceAsset();
+            DeleteTempPrefab();
+            DeleteTempMaterial();
+            DeleteTempTextFile();
             LogsController.ClearHistoryForTests();
             EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
         }
@@ -76,17 +98,18 @@ namespace UCP.Bridge.Tests
             var response = _router.Dispatch(
                 "asset/search",
                 1,
-                "{\"type\":\"SearchNestedAsset\",\"name\":\"SmokeNested\",\"path\":\"Assets\",\"maxResults\":10}"
+                "{\"name\":\"SmokeNested\",\"path\":\"Assets\",\"maxResults\":10}"
             );
 
             Assert.That(response.error, Is.Null);
 
             var result = (Dictionary<string, object>)response.result;
-            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(1));
-            Assert.That(Convert.ToInt32(result["returned"]), Is.EqualTo(1));
+            Assert.That(Convert.ToInt32(result["total"]), Is.GreaterThanOrEqualTo(1));
+            Assert.That(Convert.ToInt32(result["returned"]), Is.GreaterThanOrEqualTo(1));
 
             var matches = (List<object>)result["results"];
-            var match = (Dictionary<string, object>)matches[0];
+            var match = FindAssetMatch(matches, TempAssetPath, "SmokeNested");
+            Assert.That(match, Is.Not.Null);
             Assert.That(match["path"], Is.EqualTo(TempAssetPath));
             Assert.That(match["type"], Is.EqualTo("SearchNestedAsset"));
             Assert.That(match["name"], Is.EqualTo("SmokeNested"));
@@ -94,7 +117,7 @@ namespace UCP.Bridge.Tests
         }
 
         [Test]
-        public void LogsTail_TruncatesBulkResultsToTenEntries()
+        public void LogsTail_ReturnsRequestedBufferedCount()
         {
             for (var index = 0; index < 12; index++)
                 LogsController.RecordTestLog("info", $"log {index}");
@@ -105,8 +128,8 @@ namespace UCP.Bridge.Tests
 
             var result = (Dictionary<string, object>)response.result;
             Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(12));
-            Assert.That(Convert.ToInt32(result["returned"]), Is.EqualTo(10));
-            Assert.That(Convert.ToBoolean(result["truncated"]), Is.True);
+            Assert.That(Convert.ToInt32(result["returned"]), Is.EqualTo(12));
+            Assert.That(Convert.ToBoolean(result["truncated"]), Is.False);
 
             var logs = (List<object>)result["logs"];
             var first = (Dictionary<string, object>)logs[0];
@@ -114,6 +137,23 @@ namespace UCP.Bridge.Tests
             Assert.That(first.ContainsKey("messagePreview"), Is.True);
         }
 
+        [Test]
+        public void LogsSearch_FiltersBeforeApplyingCount()
+        {
+            LogsController.RecordTestLog("warning", "Target failed once");
+            for (var index = 0; index < 8; index++)
+                LogsController.RecordTestLog("info", $"Noise {index}");
+
+            var response = _router.Dispatch("logs/search", 1, "{\"pattern\":\"Target\",\"count\":1}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(1));
+            Assert.That(Convert.ToInt32(result["returned"]), Is.EqualTo(1));
+            Assert.That(Convert.ToBoolean(result["truncated"]), Is.False);
+        }
+
         [Test]
         public void LogsSearch_UsesRegexAgainstBufferedHistory()
         {
@@ -174,6 +214,278 @@ namespace UCP.Bridge.Tests
             Assert.That(result["stackTrace"], Is.EqualTo("stack line 1\nstack line 2"));
         }
 
+        [Test]
+        public void ObjectLifecycle_CreateMutateAndDelete_WorksEndToEnd()
+        {
+            var create = _router.Dispatch("object/create", 1, "{\"name\":\"SmokeObject\"}");
+            Assert.That(create.error, Is.Null);
+
+            var createResult = (Dictionary<string, object>)create.result;
+            var instanceId = Convert.ToInt32(createResult["instanceId"]);
+
+            var rename = _router.Dispatch("object/set-name", 1, "{\"instanceId\":" + instanceId + ",\"name\":\"RenamedSmoke\"}");
+            Assert.That(rename.error, Is.Null);
+
+            var deactivate = _router.Dispatch("object/set-active", 1, "{\"instanceId\":" + instanceId + ",\"active\":false}");
+            Assert.That(deactivate.error, Is.Null);
+            var deactivateResult = (Dictionary<string, object>)deactivate.result;
+            Assert.That(Convert.ToBoolean(deactivateResult["active"]), Is.False);
+
+            var activate = _router.Dispatch("object/set-active", 1, "{\"instanceId\":" + instanceId + ",\"active\":true}");
+            Assert.That(activate.error, Is.Null);
+
+            var addComponent = _router.Dispatch("object/add-component", 1, "{\"instanceId\":" + instanceId + ",\"type\":\"BoxCollider\"}");
+            Assert.That(addComponent.error, Is.Null);
+
+            var setPosition = _router.Dispatch(
+                "object/set-property",
+                1,
+                "{\"instanceId\":" + instanceId + ",\"component\":\"Transform\",\"property\":\"m_LocalPosition\",\"value\":[1,2,3]}"
+            );
+            Assert.That(setPosition.error, Is.Null);
+
+            var getPosition = _router.Dispatch(
+                "object/get-property",
+                1,
+                "{\"instanceId\":" + instanceId + ",\"component\":\"Transform\",\"property\":\"m_LocalPosition\"}"
+            );
+            Assert.That(getPosition.error, Is.Null);
+
+            var updated = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+            Assert.That(updated, Is.Not.Null);
+            var localPosition = updated.transform.localPosition;
+            Assert.That(localPosition.x, Is.EqualTo(1f).Within(0.001f));
+            Assert.That(localPosition.y, Is.EqualTo(2f).Within(0.001f));
+            Assert.That(localPosition.z, Is.EqualTo(3f).Within(0.001f));
+
+            var removeComponent = _router.Dispatch("object/remove-component", 1, "{\"instanceId\":" + instanceId + ",\"type\":\"BoxCollider\"}");
+            Assert.That(removeComponent.error, Is.Null);
+
+            var delete = _router.Dispatch("object/delete", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(delete.error, Is.Null);
+            Assert.That(EditorUtility.InstanceIDToObject(instanceId), Is.Null);
+        }
+
+        [Test]
+        public void ObjectSetProperty_AssignsObjectReferenceByAssetPath()
+        {
+            var referencedAsset = ScriptableObject.CreateInstance<SearchRootAsset>();
+            referencedAsset.name = "ReferenceAsset";
+            AssetDatabase.CreateAsset(referencedAsset, TempReferenceAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var go = new GameObject("ReferenceCarrier");
+            var component = go.AddComponent<ReferenceComponent>();
+
+            var response = _router.Dispatch(
+                "object/set-property",
+                1,
+                "{\"instanceId\":" + go.GetInstanceID() + ",\"component\":\"ReferenceComponent\",\"property\":\"referenceAsset\",\"value\":{\"path\":\"" + TempReferenceAssetPath + "\"}}"
+            );
+
+            Assert.That(response.error, Is.Null);
+            Assert.That(component.referenceAsset, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(component.referenceAsset), Is.EqualTo(TempReferenceAssetPath));
+        }
+
+        [Test]
+        public void ObjectSetProperty_RejectsUnknownObjectReference()
+        {
+            var go = new GameObject("ReferenceCarrier");
+            go.AddComponent<ReferenceComponent>();
+
+            var response = _router.Dispatch(
+                "object/set-property",
+                1,
+                "{\"instanceId\":" + go.GetInstanceID() + ",\"component\":\"ReferenceComponent\",\"property\":\"referenceAsset\",\"value\":{\"path\":\"Assets/Missing.asset\"}}"
+            );
+
+            Assert.That(response.error, Is.Not.Null);
+        }
+
+        [Test]
+        public void AssetWriteBatch_UpdatesMultipleFieldsIncludingObjectReference()
+        {
+            var reference = ScriptableObject.CreateInstance<SearchRootAsset>();
+            reference.name = "ReferenceAsset";
+            AssetDatabase.CreateAsset(reference, TempReferenceAssetPath);
+
+            var asset = ScriptableObject.CreateInstance<BatchWritableAsset>();
+            asset.maxPlayers = 2;
+            asset.spawnDelay = 5f;
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var response = _router.Dispatch(
+                "asset/write-batch",
+                1,
+                "{\"path\":\"" + TempAssetPath + "\",\"values\":{\"maxPlayers\":8,\"spawnDelay\":1.5,\"referenceAsset\":{\"path\":\"" + TempReferenceAssetPath + "\"}}}"
+            );
+
+            Assert.That(response.error, Is.Null);
+
+            var reloaded = AssetDatabase.LoadAssetAtPath<BatchWritableAsset>(TempAssetPath);
+            Assert.That(reloaded.maxPlayers, Is.EqualTo(8));
+            Assert.That(reloaded.spawnDelay, Is.EqualTo(1.5f).Within(0.001f));
+            Assert.That(AssetDatabase.GetAssetPath(reloaded.referenceAsset), Is.EqualTo(TempReferenceAssetPath));
+        }
+
+        [Test]
+        public void FileController_WritePatchRead_AndRejectsPathTraversal()
+        {
+            var write = _router.Dispatch("file/write", 1, "{\"path\":\"Assets/UcpControllerSmoke.txt\",\"content\":\"hello smoke\"}");
+            Assert.That(write.error, Is.Null);
+
+            var patch = _router.Dispatch(
+                "file/patch",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmoke.txt\",\"patch\":{\"find\":\"smoke\",\"replace\":\"patched\"}}"
+            );
+            Assert.That(patch.error, Is.Null);
+
+            var read = _router.Dispatch("file/read", 1, "{\"path\":\"Assets/UcpControllerSmoke.txt\"}");
+            Assert.That(read.error, Is.Null);
+            var readResult = (Dictionary<string, object>)read.result;
+            Assert.That(readResult["content"].ToString(), Is.EqualTo("hello patched"));
+
+            LogAssert.Expect(LogType.Error, new Regex("\\[UCP\\] Error handling 'file/read':"));
+            var traversal = _router.Dispatch("file/read", 1, "{\"path\":\"../outside.txt\"}");
+            Assert.That(traversal.error, Is.Not.Null);
+        }
+
+        [Test]
+        public void MaterialController_SetAndGetFloatProperty_RoundTrips()
+        {
+            var shader = Shader.Find("Standard") ?? Shader.Find("Universal Render Pipeline/Lit");
+            Assert.That(shader, Is.Not.Null);
+
+            var propertyName = FindFirstFloatOrRangeProperty(shader);
+            Assert.That(propertyName, Is.Not.Null.And.Not.Empty);
+
+            var material = new Material(shader) { name = "UcpControllerSmokeMat" };
+            AssetDatabase.CreateAsset(material, TempMaterialPath);
+            AssetDatabase.SaveAssets();
+
+            var set = _router.Dispatch(
+                "material/set-property",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmoke.mat\",\"property\":\"" + propertyName + "\",\"value\":0.42}"
+            );
+            Assert.That(set.error, Is.Null);
+
+            var get = _router.Dispatch(
+                "material/get-property",
+                1,
+                "{\"path\":\"Assets/UcpControllerSmoke.mat\",\"property\":\"" + propertyName + "\"}"
+            );
+            Assert.That(get.error, Is.Null);
+
+            var getResult = (Dictionary<string, object>)get.result;
+            var value = Convert.ToSingle(getResult["value"]);
+            Assert.That(value, Is.EqualTo(0.42f).Within(0.001f));
+        }
+
+        [Test]
+        public void PrefabController_CreateStatusOverridesAndUnpack_Works()
+        {
+            var create = _router.Dispatch("object/create", 1, "{\"name\":\"PrefabSource\"}");
+            Assert.That(create.error, Is.Null);
+            var sourceId = Convert.ToInt32(((Dictionary<string, object>)create.result)["instanceId"]);
+
+            var createPrefab = _router.Dispatch(
+                "prefab/create",
+                1,
+                "{\"instanceId\":" + sourceId + ",\"path\":\"Assets/UcpControllerSmoke.prefab\"}"
+            );
+            Assert.That(createPrefab.error, Is.Null);
+
+            var instantiate = _router.Dispatch(
+                "object/instantiate",
+                1,
+                "{\"prefab\":\"Assets/UcpControllerSmoke.prefab\",\"name\":\"PrefabInstance\"}"
+            );
+            Assert.That(instantiate.error, Is.Null);
+            var instanceId = Convert.ToInt32(((Dictionary<string, object>)instantiate.result)["instanceId"]);
+
+            var status = _router.Dispatch("prefab/status", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(status.error, Is.Null);
+            var statusResult = (Dictionary<string, object>)status.result;
+            Assert.That(Convert.ToBoolean(statusResult["isInstance"]), Is.True);
+
+            var mutate = _router.Dispatch(
+                "object/set-property",
+                1,
+                "{\"instanceId\":" + instanceId + ",\"component\":\"Transform\",\"property\":\"m_LocalPosition\",\"value\":[2,0,0]}"
+            );
+            Assert.That(mutate.error, Is.Null);
+
+            var overrides = _router.Dispatch("prefab/overrides", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(overrides.error, Is.Null);
+            var overridesResult = (Dictionary<string, object>)overrides.result;
+            var modifications = (List<object>)overridesResult["propertyModifications"];
+            Assert.That(modifications.Count, Is.GreaterThanOrEqualTo(1));
+
+            var unpack = _router.Dispatch("prefab/unpack", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(unpack.error, Is.Null);
+
+            var unpackedStatus = _router.Dispatch("prefab/status", 1, "{\"instanceId\":" + instanceId + "}");
+            Assert.That(unpackedStatus.error, Is.Null);
+            var unpackedStatusResult = (Dictionary<string, object>)unpackedStatus.result;
+            Assert.That(Convert.ToBoolean(unpackedStatusResult["isInstance"]), Is.False);
+        }
+
+        [Test]
+        public void SettingsAndBuildControllers_RoundTripWithoutSideEffects()
+        {
+            var playerSettings = _router.Dispatch("settings/player", 1, "{}");
+            Assert.That(playerSettings.error, Is.Null);
+            var settingsResult = (Dictionary<string, object>)playerSettings.result;
+            var originalProductName = settingsResult["productName"].ToString();
+
+            var setPlayer = _router.Dispatch(
+                "settings/player-set",
+                1,
+                "{\"key\":\"productName\",\"value\":\"UcpQaProduct\"}"
+            );
+            Assert.That(setPlayer.error, Is.Null);
+
+            var verifyPlayer = _router.Dispatch("settings/player", 1, "{}");
+            Assert.That(verifyPlayer.error, Is.Null);
+            var verifyResult = (Dictionary<string, object>)verifyPlayer.result;
+            Assert.That(verifyResult["productName"].ToString(), Is.EqualTo("UcpQaProduct"));
+
+            var restorePlayer = _router.Dispatch(
+                "settings/player-set",
+                1,
+                "{\"key\":\"productName\",\"value\":\"" + originalProductName + "\"}"
+            );
+            Assert.That(restorePlayer.error, Is.Null);
+
+            var scenes = _router.Dispatch("build/scenes", 1, "{}");
+            Assert.That(scenes.error, Is.Null);
+            var scenesResult = (Dictionary<string, object>)scenes.result;
+            var currentScenes = (List<object>)scenesResult["scenes"];
+            Assert.That(currentScenes.Count, Is.GreaterThanOrEqualTo(1));
+
+            var firstScene = (Dictionary<string, object>)currentScenes[0];
+            var firstScenePath = firstScene["path"].ToString();
+
+            var setScenes = _router.Dispatch(
+                "build/set-scenes",
+                1,
+                "{\"scenes\":[\"" + EscapeForJson(firstScenePath) + "\"]}"
+            );
+            Assert.That(setScenes.error, Is.Null);
+
+            var defines = _router.Dispatch("build/defines", 1, "{}");
+            Assert.That(defines.error, Is.Null);
+            var definesResult = (Dictionary<string, object>)defines.result;
+            var originalDefines = definesResult["defines"].ToString();
+
+            var setDefines = _router.Dispatch("build/set-defines", 1, "{\"defines\":\"" + EscapeForJson(originalDefines) + "\"}");
+            Assert.That(setDefines.error, Is.Null);
+        }
+
         private static void DeleteTempAsset()
         {
             if (AssetDatabase.LoadMainAssetAtPath(TempAssetPath) != null)
@@ -183,6 +495,78 @@ namespace UCP.Bridge.Tests
             }
         }
 
+        private static void DeleteTempReferenceAsset()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempReferenceAssetPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempReferenceAssetPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempPrefab()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempPrefabPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempPrefabPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempMaterial()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempMaterialPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempMaterialPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempTextFile()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempTextPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempTextPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static string FindFirstFloatOrRangeProperty(Shader shader)
+        {
+            for (var index = 0; index < shader.GetPropertyCount(); index++)
+            {
+                var propertyType = shader.GetPropertyType(index);
+                if (propertyType == UnityEngine.Rendering.ShaderPropertyType.Float
+                    || propertyType == UnityEngine.Rendering.ShaderPropertyType.Range)
+                {
+                    return shader.GetPropertyName(index);
+                }
+            }
+
+            return null;
+        }
+
+        private static string EscapeForJson(string value)
+        {
+            return value
+                .Replace("\\", "\\\\")
+                .Replace("\"", "\\\"");
+        }
+
+        private static Dictionary<string, object> FindAssetMatch(List<object> matches, string expectedPath, string expectedName)
+        {
+            foreach (var entry in matches)
+            {
+                var match = (Dictionary<string, object>)entry;
+                var path = match.ContainsKey("path") ? match["path"].ToString() : string.Empty;
+                var name = match.ContainsKey("name") ? match["name"].ToString() : string.Empty;
+                if (path == expectedPath && name == expectedName)
+                    return match;
+            }
+
+            return null;
+        }
+
         private sealed class SearchRootAsset : ScriptableObject
         {
         }
@@ -190,5 +574,17 @@ namespace UCP.Bridge.Tests
         private sealed class SearchNestedAsset : ScriptableObject
         {
         }
+
+        private sealed class BatchWritableAsset : ScriptableObject
+        {
+            public int maxPlayers;
+            public float spawnDelay;
+            public SearchRootAsset referenceAsset;
+        }
+
+        private sealed class ReferenceComponent : MonoBehaviour
+        {
+            public SearchRootAsset referenceAsset;
+        }
     }
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "displayName": "Unity Control Protocol Bridge",
   "description": "WebSocket bridge for programmatic Unity Editor control via CLI and AI agents.",
   "unity": "2021.3",
@@ -21,7 +21,7 @@
     "url": "https://github.com/mflRevan/unity-control-protocol.git"
   },
   "type": "tool",
-  "documentationUrl": "https://github.com/mflRevan/unity-control-protocol/blob/main/PROJECT.md",
+  "documentationUrl": "https://github.com/mflRevan/unity-control-protocol/blob/main/README.md",
   "changelogUrl": "https://github.com/mflRevan/unity-control-protocol/blob/main/unity-package/com.ucp.bridge/CHANGELOG.md",
   "dependencies": {}
 }

package/package.json

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