@mflrevan/ucp 0.5.0 → 0.5.1

package/README.md

@@ -1,6 +1,6 @@
 # @mflrevan/ucp
 
-Version `0.5.0` of the Unity Control Protocol CLI.
+Version `0.5.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.
 

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

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

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Text.RegularExpressions;
 using UnityEditor;
 using UnityEngine;
 
@@ -28,6 +29,7 @@ namespace UCP.Bridge
             string typeFilter = null;
             string nameFilter = null;
             string pathFilter = null;
+            bool useRegex = false;
             int maxResults = 100;
 
             if (p != null)
@@ -38,13 +40,28 @@ namespace UCP.Bridge
                     nameFilter = nObj.ToString();
                 if (p.TryGetValue("path", out var pObj) && pObj != null)
                     pathFilter = pObj.ToString();
+                if (p.TryGetValue("regex", out var regexObj) && regexObj != null)
+                    useRegex = Convert.ToBoolean(regexObj);
                 if (p.TryGetValue("maxResults", out var mObj))
                     maxResults = Convert.ToInt32(mObj);
             }
 
+            Regex nameRegex = null;
+            if (useRegex && !string.IsNullOrEmpty(nameFilter))
+            {
+                try
+                {
+                    nameRegex = new Regex(nameFilter, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+                }
+                catch (ArgumentException ex)
+                {
+                    throw new ArgumentException($"Invalid regex for name filter: {ex.Message}");
+                }
+            }
+
             // Build search filter
             string filter = "";
-            if (!string.IsNullOrEmpty(nameFilter))
+            if (!useRegex && !string.IsNullOrEmpty(nameFilter))
                 filter += nameFilter + " ";
             if (!string.IsNullOrEmpty(typeFilter))
                 filter += $"t:{GetSearchTypeFilter(typeFilter)}";
@@ -64,7 +81,7 @@ namespace UCP.Bridge
             for (int i = 0; i < guids.Length; i++)
             {
                 string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
-                foreach (var asset in GetMatchingAssets(assetPath, typeFilter, nameFilter))
+                foreach (var asset in GetMatchingAssets(assetPath, typeFilter, nameFilter, nameRegex))
                 {
                     totalMatches++;
                     if (results.Count >= maxResults)
@@ -354,6 +371,7 @@ namespace UCP.Bridge
                 throw new ArgumentException("Missing 'moves' parameter");
 
             var continueOnError = TryGetOptionalBool(parameters, "continueOnError");
+            var dryRun = TryGetOptionalBool(parameters, "dryRun");
             var requests = ParseMoveRequests(movesObject);
             var results = new List<object>();
             var errors = new List<object>();
@@ -361,15 +379,14 @@ namespace UCP.Bridge
             var stopped = false;
             var anyChanged = false;
 
-            AssetDatabase.StartAssetEditing();
-            try
+            if (dryRun)
             {
                 for (var index = 0; index < requests.Count; index++)
                 {
                     var request = requests[index];
                     try
                     {
-                        var moveResult = MoveAssetInternal(request.SourcePath, request.Destination, false);
+                        var moveResult = PreviewMoveInternal(request.SourcePath, request.Destination);
                         results.Add(AddMoveIndex(moveResult, index));
                         if (GetBool(moveResult, "changed"))
                         {
@@ -395,12 +412,75 @@ namespace UCP.Bridge
                     }
                 }
             }
-            finally
+            else
             {
-                AssetDatabase.StopAssetEditing();
+                var preparedMoves = new List<PreparedMove>();
+                for (var index = 0; index < requests.Count; index++)
+                {
+                    var request = requests[index];
+                    try
+                    {
+                        var preparedMove = PrepareMove(request.SourcePath, request.Destination, true);
+                        preparedMoves.Add(new PreparedMove(index, request.SourcePath, preparedMove));
+                    }
+                    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;
+                        }
+                    }
+                }
+
+                AssetDatabase.StartAssetEditing();
+                try
+                {
+                    foreach (var preparedMove in preparedMoves)
+                    {
+                        try
+                        {
+                            var moveResult = MovePreparedAsset(preparedMove.SourcePath, preparedMove.Move, false);
+                            results.Add(AddMoveIndex(moveResult, preparedMove.Index));
+                            if (GetBool(moveResult, "changed"))
+                            {
+                                movedCount++;
+                                anyChanged = true;
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            errors.Add(new Dictionary<string, object>
+                            {
+                                ["index"] = preparedMove.Index,
+                                ["sourcePath"] = preparedMove.SourcePath,
+                                ["destinationPath"] = preparedMove.Move.ResolvedDestination,
+                                ["message"] = ex.Message
+                            });
+
+                            if (!continueOnError)
+                            {
+                                stopped = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                finally
+                {
+                    AssetDatabase.StopAssetEditing();
+                }
             }
 
-            if (anyChanged)
+            if (!dryRun && anyChanged)
             {
                 AssetDatabase.SaveAssets();
                 AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
@@ -412,6 +492,7 @@ namespace UCP.Bridge
                 ["requested"] = requests.Count,
                 ["moved"] = movedCount,
                 ["failed"] = errors.Count,
+                ["dryRun"] = dryRun,
                 ["stopped"] = stopped,
                 ["results"] = results,
                 ["errors"] = errors
@@ -431,10 +512,19 @@ namespace UCP.Bridge
             }
         }
 
-        private static IEnumerable<UnityEngine.Object> GetMatchingAssets(string assetPath, string typeFilter, string nameFilter)
+        private static IEnumerable<UnityEngine.Object> GetMatchingAssets(
+            string assetPath,
+            string typeFilter,
+            string nameFilter,
+            Regex nameRegex)
         {
             UnityEngine.Object[] candidates;
-            if (string.IsNullOrEmpty(typeFilter) && string.IsNullOrEmpty(nameFilter))
+            if (string.IsNullOrEmpty(typeFilter) && string.IsNullOrEmpty(nameFilter) && nameRegex == null)
+            {
+                var mainAsset = AssetDatabase.LoadMainAssetAtPath(assetPath);
+                candidates = mainAsset != null ? new[] { mainAsset } : Array.Empty<UnityEngine.Object>();
+            }
+            else if (assetPath.EndsWith(".unity", StringComparison.OrdinalIgnoreCase))
             {
                 var mainAsset = AssetDatabase.LoadMainAssetAtPath(assetPath);
                 candidates = mainAsset != null ? new[] { mainAsset } : Array.Empty<UnityEngine.Object>();
@@ -447,17 +537,24 @@ namespace UCP.Bridge
             foreach (var candidate in candidates)
             {
                 if (candidate == null) continue;
-                if (!MatchesName(candidate, assetPath, nameFilter)) continue;
+                if (!MatchesName(candidate, assetPath, nameFilter, nameRegex)) continue;
                 if (!MatchesType(candidate, assetPath, typeFilter)) continue;
                 yield return candidate;
             }
         }
 
-        private static bool MatchesName(UnityEngine.Object asset, string assetPath, string nameFilter)
+        private static bool MatchesName(UnityEngine.Object asset, string assetPath, string nameFilter, Regex nameRegex)
         {
-            if (string.IsNullOrEmpty(nameFilter))
+            if (string.IsNullOrEmpty(nameFilter) && nameRegex == null)
                 return true;
 
+            if (nameRegex != null)
+            {
+                var fileStem = System.IO.Path.GetFileNameWithoutExtension(assetPath);
+                return nameRegex.IsMatch(asset.name)
+                    || (!string.IsNullOrEmpty(fileStem) && nameRegex.IsMatch(fileStem));
+            }
+
             return asset.name.Contains(nameFilter, StringComparison.OrdinalIgnoreCase)
                 || System.IO.Path.GetFileNameWithoutExtension(assetPath).Contains(nameFilter, StringComparison.OrdinalIgnoreCase);
         }
@@ -507,30 +604,29 @@ namespace UCP.Bridge
 
         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);
-            }
+            var move = PrepareMove(sourcePath, destination, true);
+            return MovePreparedAsset(NormalizeMovePath(sourcePath), move, finalize);
+        }
 
-            if (AssetDatabase.AssetPathExists(resolvedDestination) || AssetDatabase.IsValidFolder(resolvedDestination))
-                throw new ArgumentException($"Destination already exists: {resolvedDestination}");
+        private static Dictionary<string, object> PreviewMoveInternal(string sourcePath, string destination)
+        {
+            var normalizedSource = NormalizeMovePath(sourcePath);
+            var move = PrepareMove(normalizedSource, destination, false);
+            return DescribeMovedAsset(normalizedSource, move.ResolvedDestination, move.Changed, move.Identity);
+        }
 
-            EnsureParentFoldersExist(resolvedDestination);
+        private static ValidatedMove PrepareMove(string sourcePath, string destination, bool ensureParentFolders)
+        {
+            var normalizedSource = NormalizeMovePath(sourcePath);
+            var move = ValidateMoveRequest(normalizedSource, destination);
+            if (ensureParentFolders)
+                EnsureParentFoldersExist(move.ResolvedDestination);
+            return move;
+        }
 
-            var moveError = AssetDatabase.MoveAsset(normalizedSource, resolvedDestination);
+        private static Dictionary<string, object> MovePreparedAsset(string normalizedSource, ValidatedMove move, bool finalize)
+        {
+            var moveError = AssetDatabase.MoveAsset(normalizedSource, move.ResolvedDestination);
             if (!string.IsNullOrEmpty(moveError))
                 throw new InvalidOperationException(moveError);
 
@@ -540,7 +636,7 @@ namespace UCP.Bridge
                 AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             }
 
-            return DescribeMovedAsset(normalizedSource, resolvedDestination, true, identity);
+            return DescribeMovedAsset(normalizedSource, move.ResolvedDestination, true, move.Identity);
         }
 
         private static Dictionary<string, object> DescribeMovedAsset(
@@ -648,6 +744,29 @@ namespace UCP.Bridge
             return path?.Trim().Replace('\\', '/');
         }
 
+        private static ValidatedMove ValidateMoveRequest(string normalizedSource, string destination)
+        {
+            var isFolder = AssetDatabase.IsValidFolder(normalizedSource);
+            if (!isFolder && !AssetDatabase.AssetPathExists(normalizedSource))
+                throw new ArgumentException(BuildAssetNotFoundMessage(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 new ValidatedMove(identity, resolvedDestination, false);
+
+            if (AssetDatabase.AssetPathExists(resolvedDestination) || AssetDatabase.IsValidFolder(resolvedDestination))
+                throw new ArgumentException($"Destination already exists: {resolvedDestination}");
+
+            return new ValidatedMove(identity, resolvedDestination, true);
+        }
+
         private static bool IsMovableAssetPath(string path)
         {
             return !string.IsNullOrEmpty(path)
@@ -655,6 +774,60 @@ namespace UCP.Bridge
                     || path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase));
         }
 
+        private static string BuildAssetNotFoundMessage(string normalizedSource)
+        {
+            var message = $"Asset not found: {normalizedSource}.";
+            var suggestions = FindSimilarAssetPaths(normalizedSource, 3);
+            if (suggestions.Count > 0)
+                message += " Did you mean: " + string.Join(", ", suggestions) + "?";
+            message += " If the asset was created or renamed outside Unity, refresh or reimport so AssetDatabase can pick up the latest path.";
+            return message;
+        }
+
+        private static List<string> FindSimilarAssetPaths(string normalizedSource, int maxSuggestions)
+        {
+            var targetName = Path.GetFileNameWithoutExtension(normalizedSource) ?? normalizedSource;
+            var targetFileName = Path.GetFileName(normalizedSource) ?? normalizedSource;
+            var targetExtension = Path.GetExtension(normalizedSource) ?? string.Empty;
+            var matches = new List<(string path, int score)>();
+
+            foreach (var candidate in AssetDatabase.GetAllAssetPaths())
+            {
+                if (!candidate.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                var score = 0;
+                if (candidate.IndexOf(targetName, StringComparison.OrdinalIgnoreCase) >= 0)
+                    score += 3;
+                if (string.Equals(Path.GetFileName(candidate), targetFileName, StringComparison.OrdinalIgnoreCase))
+                    score += 4;
+                if (string.Equals(Path.GetExtension(candidate), targetExtension, StringComparison.OrdinalIgnoreCase))
+                    score += 1;
+                if (score > 0)
+                    matches.Add((candidate, score));
+            }
+
+            matches.Sort((left, right) =>
+            {
+                var scoreCompare = right.score.CompareTo(left.score);
+                return scoreCompare != 0
+                    ? scoreCompare
+                    : string.Compare(left.path, right.path, StringComparison.OrdinalIgnoreCase);
+            });
+
+            var suggestions = new List<string>();
+            foreach (var match in matches)
+            {
+                if (suggestions.Contains(match.path))
+                    continue;
+                suggestions.Add(match.path);
+                if (suggestions.Count >= maxSuggestions)
+                    break;
+            }
+
+            return suggestions;
+        }
+
         private static Dictionary<string, object> ParseParameters(string paramsJson)
         {
             return MiniJson.Deserialize(paramsJson) as Dictionary<string, object>
@@ -750,6 +923,20 @@ namespace UCP.Bridge
             public string Destination { get; }
         }
 
+        private readonly struct PreparedMove
+        {
+            public PreparedMove(int index, string sourcePath, ValidatedMove move)
+            {
+                Index = index;
+                SourcePath = sourcePath;
+                Move = move;
+            }
+
+            public int Index { get; }
+            public string SourcePath { get; }
+            public ValidatedMove Move { get; }
+        }
+
         private readonly struct AssetIdentity
         {
             public AssetIdentity(string guid, string name, string type, bool isFolder)
@@ -766,5 +953,19 @@ namespace UCP.Bridge
             public bool IsFolder { get; }
         }
 
+        private readonly struct ValidatedMove
+        {
+            public ValidatedMove(AssetIdentity identity, string resolvedDestination, bool changed)
+            {
+                Identity = identity;
+                ResolvedDestination = resolvedDestination;
+                Changed = changed;
+            }
+
+            public AssetIdentity Identity { get; }
+            public string ResolvedDestination { get; }
+            public bool Changed { get; }
+        }
+
     }
 }

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

@@ -80,6 +80,47 @@ namespace UCP.Bridge
             return CreateReimportResult(requestedPath, assetPath, true, false, null);
         }
 
+        public static Dictionary<string, object> ReimportRecursive(string requestedPath, bool forceSynchronous = true)
+        {
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException("Missing 'path' parameter");
+            if (!IsProjectAssetPath(assetPath))
+                throw new ArgumentException($"Path is not under Assets/ or Packages/: {requestedPath}");
+
+            if (!AssetDatabase.IsValidFolder(assetPath))
+                return Reimport(requestedPath, forceSynchronous);
+
+            var options = ImportAssetOptions.ForceUpdate;
+            if (forceSynchronous)
+                options |= ImportAssetOptions.ForceSynchronousImport;
+
+            var guidResults = AssetDatabase.FindAssets(string.Empty, new[] { assetPath });
+            var importedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var guid in guidResults)
+            {
+                var childPath = AssetDatabase.GUIDToAssetPath(guid);
+                if (string.IsNullOrEmpty(childPath) || AssetDatabase.IsValidFolder(childPath))
+                    continue;
+
+                AssetDatabase.ImportAsset(childPath, options);
+                importedPaths.Add(childPath);
+                RecordReimport(childPath);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["requestedPath"] = requestedPath,
+                ["assetPath"] = assetPath,
+                ["recursive"] = true,
+                ["requested"] = importedPaths.Count,
+                ["reimported"] = importedPaths.Count,
+                ["skipped"] = 0,
+                ["paths"] = new List<object>(importedPaths)
+            };
+        }
+
         public static Dictionary<string, object> SaveImporterSettings(string requestedPath, AssetImporter importer, bool noReimport)
         {
             if (importer == null)

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

@@ -18,7 +18,10 @@ namespace UCP.Bridge
         {
             var parameters = ParseParameters(paramsJson);
             var requestedPath = RequirePath(parameters);
-            return AssetImportSupport.Reimport(requestedPath);
+            var recursive = TryGetOptionalBool(parameters, "recursive");
+            return recursive
+                ? AssetImportSupport.ReimportRecursive(requestedPath)
+                : AssetImportSupport.Reimport(requestedPath);
         }
 
         private static object HandleRead(string paramsJson)

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

@@ -45,6 +45,27 @@ namespace UCP.Bridge
             return RecordLog(level, message, stackTrace);
         }
 
+        public static long GetLatestId()
+        {
+            lock (s_historyLock)
+            {
+                return s_history.Count == 0 ? 0 : s_history[s_history.Count - 1].Id;
+            }
+        }
+
+        public static Dictionary<string, object> BuildStatusSummary(long afterId = 0)
+        {
+            lock (s_historyLock)
+            {
+                var ordered = s_history
+                    .Where(entry => entry.Id > afterId)
+                    .OrderBy(entry => entry.Id)
+                    .ToList();
+
+                return BuildStatusResult(ordered, afterId);
+            }
+        }
+
         private static object HandleTail(string paramsJson)
         {
             var query = ParseQuery(paramsJson, includePattern: false);
@@ -77,82 +98,12 @@ namespace UCP.Bridge
 
         private static object HandleStatus(string paramsJson)
         {
-            lock (s_historyLock)
-            {
-                var ordered = s_history.OrderBy(entry => entry.Id).ToList();
-                var byLevel = new Dictionary<string, object>
-                {
-                    ["info"] = ordered.Count(entry => entry.Level == "info"),
-                    ["warning"] = ordered.Count(entry => entry.Level == "warning"),
-                    ["error"] = ordered.Count(entry => entry.Level == "error"),
-                    ["exception"] = ordered.Count(entry => entry.Level == "exception")
-                };
-
-                var grouped = ordered
-                    .GroupBy(entry => $"{entry.Level}|{Fingerprint(entry.Message)}")
-                    .Select(group =>
-                    {
-                        var first = group.First();
-                        var last = group.Last();
-                        return new Dictionary<string, object>
-                        {
-                            ["level"] = first.Level,
-                            ["fingerprint"] = Fingerprint(first.Message),
-                            ["sampleMessage"] = Preview(first.Message, MaxPreviewLength),
-                            ["count"] = group.Count(),
-                            ["firstTimestamp"] = first.Timestamp,
-                            ["lastTimestamp"] = last.Timestamp,
-                            ["latestId"] = last.Id
-                        };
-                    })
-                    .OrderByDescending(entry => Convert.ToInt32(entry["count"]))
-                    .ThenBy(entry => entry["sampleMessage"].ToString())
-                    .ToList();
-
-                var result = new Dictionary<string, object>
-                {
-                    ["total"] = ordered.Count,
-                    ["byLevel"] = byLevel,
-                    ["uniqueCount"] = grouped.Count,
-                    ["topCategories"] = grouped.Take(8).Cast<object>().ToList()
-                };
-
-                if (ordered.Count > 0)
-                {
-                    var first = ordered.First();
-                    var last = ordered.Last();
-                    result["firstTimestamp"] = first.Timestamp;
-                    result["lastTimestamp"] = last.Timestamp;
-                    result["historyWindowSeconds"] = Math.Max(0d, (last.TimestampUtc - first.TimestampUtc).TotalSeconds);
-                    result["latestId"] = last.Id;
-                }
-
-                var playSession = PlayModeController.GetSessionSnapshot();
-                result["play"] = SerializePlaySession(playSession);
-
-                if (playSession.LastEnteredPlayAtUtc.HasValue)
-                {
-                    var sessionEnd = playSession.Playing
-                        ? DateTime.UtcNow
-                        : (playSession.LastExitedPlayAtUtc ?? DateTime.UtcNow);
-                    var sessionLogs = ordered
-                        .Where(entry => entry.TimestampUtc >= playSession.LastEnteredPlayAtUtc.Value
-                            && entry.TimestampUtc <= sessionEnd)
-                        .ToList();
-
-                    result["lastPlayWindow"] = new Dictionary<string, object>
-                    {
-                        ["startedAt"] = playSession.LastEnteredPlayAtUtc.Value.ToString("o"),
-                        ["endedAt"] = sessionEnd.ToString("o"),
-                        ["durationSeconds"] = Math.Max(0d, (sessionEnd - playSession.LastEnteredPlayAtUtc.Value).TotalSeconds),
-                        ["total"] = sessionLogs.Count,
-                        ["warnings"] = sessionLogs.Count(entry => entry.Level == "warning"),
-                        ["errors"] = sessionLogs.Count(entry => entry.Level == "error" || entry.Level == "exception")
-                    };
-                }
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            long afterId = 0;
+            if (p != null && p.TryGetValue("afterId", out var afterIdObj) && afterIdObj != null)
+                afterId = Math.Max(0, Convert.ToInt64(afterIdObj));
 
-                return result;
-            }
+            return BuildStatusSummary(afterId);
         }
 
         private static Dictionary<string, object> RecordLog(string level, string message, string stackTrace)
@@ -257,6 +208,83 @@ namespace UCP.Bridge
             };
         }
 
+        private static Dictionary<string, object> BuildStatusResult(List<LogRecord> ordered, long afterId)
+        {
+            var byLevel = new Dictionary<string, object>
+            {
+                ["info"] = ordered.Count(entry => entry.Level == "info"),
+                ["warning"] = ordered.Count(entry => entry.Level == "warning"),
+                ["error"] = ordered.Count(entry => entry.Level == "error"),
+                ["exception"] = ordered.Count(entry => entry.Level == "exception")
+            };
+
+            var grouped = ordered
+                .GroupBy(entry => $"{entry.Level}|{Fingerprint(entry.Message)}")
+                .Select(group =>
+                {
+                    var first = group.First();
+                    var last = group.Last();
+                    return new Dictionary<string, object>
+                    {
+                        ["level"] = first.Level,
+                        ["fingerprint"] = Fingerprint(first.Message),
+                        ["sampleMessage"] = Preview(first.Message, MaxPreviewLength),
+                        ["count"] = group.Count(),
+                        ["firstTimestamp"] = first.Timestamp,
+                        ["lastTimestamp"] = last.Timestamp,
+                        ["latestId"] = last.Id
+                    };
+                })
+                .OrderByDescending(entry => Convert.ToInt32(entry["count"]))
+                .ThenBy(entry => entry["sampleMessage"].ToString())
+                .ToList();
+
+            var result = new Dictionary<string, object>
+            {
+                ["afterId"] = afterId,
+                ["total"] = ordered.Count,
+                ["byLevel"] = byLevel,
+                ["uniqueCount"] = grouped.Count,
+                ["topCategories"] = grouped.Take(8).Cast<object>().ToList()
+            };
+
+            if (ordered.Count > 0)
+            {
+                var first = ordered.First();
+                var last = ordered.Last();
+                result["firstTimestamp"] = first.Timestamp;
+                result["lastTimestamp"] = last.Timestamp;
+                result["historyWindowSeconds"] = Math.Max(0d, (last.TimestampUtc - first.TimestampUtc).TotalSeconds);
+                result["latestId"] = last.Id;
+            }
+
+            var playSession = PlayModeController.GetSessionSnapshot();
+            result["play"] = SerializePlaySession(playSession);
+
+            if (playSession.LastEnteredPlayAtUtc.HasValue)
+            {
+                var sessionEnd = playSession.Playing
+                    ? DateTime.UtcNow
+                    : (playSession.LastExitedPlayAtUtc ?? DateTime.UtcNow);
+                var sessionLogs = ordered
+                    .Where(entry => entry.TimestampUtc >= playSession.LastEnteredPlayAtUtc.Value
+                        && entry.TimestampUtc <= sessionEnd)
+                    .ToList();
+
+                result["lastPlayWindow"] = new Dictionary<string, object>
+                {
+                    ["startedAt"] = playSession.LastEnteredPlayAtUtc.Value.ToString("o"),
+                    ["endedAt"] = sessionEnd.ToString("o"),
+                    ["durationSeconds"] = Math.Max(0d, (sessionEnd - playSession.LastEnteredPlayAtUtc.Value).TotalSeconds),
+                    ["total"] = sessionLogs.Count,
+                    ["warnings"] = sessionLogs.Count(entry => entry.Level == "warning"),
+                    ["errors"] = sessionLogs.Count(entry => entry.Level == "error" || entry.Level == "exception")
+                };
+            }
+
+            return result;
+        }
+
         private static Dictionary<string, object> SerializeSummary(LogRecord entry)
         {
             return new Dictionary<string, object>

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

@@ -44,20 +44,26 @@ namespace UCP.Bridge
                 throw new System.ArgumentException("Missing 'path' parameter");
 
             var path = pathObj.ToString();
+            var additive = GetBoolParam(p, "additive", false);
             var saveDirtyScenes = GetBoolParam(p, "saveDirtyScenes", true);
             var discardUntitled = GetBoolParam(p, "discardUntitled", true);
 
             if (EditorApplication.isPlaying)
             {
-                SceneManager.LoadScene(path);
+                SceneManager.LoadScene(path, additive ? LoadSceneMode.Additive : LoadSceneMode.Single);
             }
             else
             {
                 SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
-                EditorSceneManager.OpenScene(path, OpenSceneMode.Single);
+                EditorSceneManager.OpenScene(path, additive ? OpenSceneMode.Additive : OpenSceneMode.Single);
             }
 
-            return new { status = "ok", loaded = path };
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["loaded"] = path,
+                ["additive"] = additive
+            };
         }
 
         private static bool GetBoolParam(Dictionary<string, object> parameters, string key, bool defaultValue)

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

@@ -11,6 +11,7 @@ namespace UCP.Bridge
     {
         private static TestRunnerApi s_api;
         private static TestResultCollector s_collector;
+        private const string ConsoleGuardName = "UCP.Bridge.Tests.ConsoleLogGuard";
 
         public static void Register(CommandRouter router)
         {
@@ -42,7 +43,8 @@ namespace UCP.Bridge
             if (s_collector != null)
                 s_api.UnregisterCallbacks(s_collector);
 
-            s_collector = new TestResultCollector();
+            var logCursor = LogsController.GetLatestId();
+            s_collector = new TestResultCollector(logCursor);
             s_api.RegisterCallbacks(s_collector);
 
             var executionSettings = new ExecutionSettings
@@ -130,11 +132,13 @@ namespace UCP.Bridge
         private class TestResultCollector : ICallbacks
         {
             private readonly List<object> _results = new();
+            private readonly long _logCursor;
             private int _passed, _failed, _skipped;
             private double _startTime;
 
-            public TestResultCollector()
+            public TestResultCollector(long logCursor)
             {
+                _logCursor = logCursor;
                 _startTime = EditorApplication.timeSinceStartup;
             }
 
@@ -147,6 +151,21 @@ namespace UCP.Bridge
                 _failed = 0;
                 _skipped = 0;
                 CollectLeafResults(result);
+                var logSummary = LogsController.BuildStatusSummary(_logCursor);
+                var consoleWarnings = GetLevelCount(logSummary, "warning");
+                var consoleErrors = GetLevelCount(logSummary, "error") + GetLevelCount(logSummary, "exception");
+
+                if (consoleErrors > 0)
+                {
+                    _failed++;
+                    _results.Add(new Dictionary<string, object>
+                    {
+                        ["name"] = ConsoleGuardName,
+                        ["status"] = "failed",
+                        ["duration"] = 0.0,
+                        ["message"] = BuildConsoleGuardMessage(consoleErrors, consoleWarnings, logSummary)
+                    });
+                }
 
                 var duration = EditorApplication.timeSinceStartup - _startTime;
 
@@ -156,13 +175,17 @@ namespace UCP.Bridge
                     ["passed"] = _passed,
                     ["failed"] = _failed,
                     ["skipped"] = _skipped,
-                    ["duration"] = (double)duration
+                    ["duration"] = (double)duration,
+                    ["consoleClean"] = consoleErrors == 0,
+                    ["consoleWarnings"] = consoleWarnings,
+                    ["consoleErrors"] = consoleErrors
                 };
 
                 BridgeServer.BroadcastNotification("tests/result", new Dictionary<string, object>
                 {
                     ["summary"] = summary,
-                    ["tests"] = _results
+                    ["tests"] = _results,
+                    ["logs"] = logSummary
                 });
 
                 if (s_api != null)
@@ -235,6 +258,59 @@ namespace UCP.Bridge
 
                 return result.Name;
             }
+
+            private static int GetLevelCount(Dictionary<string, object> logSummary, string level)
+            {
+                if (!logSummary.TryGetValue("byLevel", out var byLevelObj)
+                    || byLevelObj is not Dictionary<string, object> byLevel
+                    || !byLevel.TryGetValue(level, out var value))
+                {
+                    return 0;
+                }
+
+                return Convert.ToInt32(value);
+            }
+
+            private static string BuildConsoleGuardMessage(
+                int consoleErrors,
+                int consoleWarnings,
+                Dictionary<string, object> logSummary)
+            {
+                var message = $"Unity emitted {consoleErrors} error/exception log(s) during the test run";
+                if (consoleWarnings > 0)
+                    message += $" and {consoleWarnings} warning log(s)";
+
+                if (!logSummary.TryGetValue("topCategories", out var categoriesObj)
+                    || categoriesObj is not List<object> categories
+                    || categories.Count == 0)
+                {
+                    return message + ".";
+                }
+
+                var parts = new List<string>();
+                foreach (var categoryObj in categories)
+                {
+                    if (categoryObj is not Dictionary<string, object> category)
+                        continue;
+
+                    var count = category.TryGetValue("count", out var countObj)
+                        ? Convert.ToInt32(countObj)
+                        : 0;
+                    var sample = category.TryGetValue("sampleMessage", out var sampleObj)
+                        ? sampleObj?.ToString() ?? string.Empty
+                        : string.Empty;
+                    if (count <= 0 || string.IsNullOrEmpty(sample))
+                        continue;
+
+                    parts.Add($"{count}x {sample}");
+                    if (parts.Count >= 3)
+                        break;
+                }
+
+                return parts.Count == 0
+                    ? message + "."
+                    : $"{message}. Top categories: {string.Join(" | ", parts)}";
+            }
         }
     }
 }

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

@@ -22,11 +22,14 @@ namespace UCP.Bridge.Tests
         private const string TempScriptPath = "Assets/UcpControllerSmokeComponent.cs";
         private const string TempTexturePath = "Assets/UcpImporterSmoke.png";
         private const string TempScenePath = "Assets/UcpControllerMoveScene.unity";
+        private const string TempSceneBPath = "Assets/UcpControllerSceneB.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 TempReimportFolderPath = "Assets/UcpRecursiveReimport";
+        private const string TempReimportTexturePath = "Assets/UcpRecursiveReimport/UcpRecursiveA.png";
         private const string TempProfilerExportPath = "ProfilerCaptures\\smoke-export.json";
         private const string TempLocalPackageFolder = "TempUcpLocalPackage";
         private const string TempLocalPackageName = "com.ucp.temp.local";
@@ -40,6 +43,8 @@ namespace UCP.Bridge.Tests
             SnapshotController.Register(_router);
             AssetController.Register(_router);
             ImporterController.Register(_router);
+            PlayModeController.Register(_router);
+            ReferenceController.Register(_router);
             LogsController.Register(_router);
             HierarchyController.Register(_router);
             ProfilerController.Register(_router);
@@ -60,7 +65,9 @@ namespace UCP.Bridge.Tests
             DeleteTempScriptFile();
             DeleteTempTextureAsset();
             DeleteTempScene();
+            DeleteTempSceneB();
             DeleteTempMovedFolder();
+            DeleteTempReimportFolder();
             DeleteTempProfilerExport();
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
@@ -83,7 +90,9 @@ namespace UCP.Bridge.Tests
             DeleteTempScriptFile();
             DeleteTempTextureAsset();
             DeleteTempScene();
+            DeleteTempSceneB();
             DeleteTempMovedFolder();
+            DeleteTempReimportFolder();
             DeleteTempProfilerExport();
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
@@ -246,6 +255,64 @@ namespace UCP.Bridge.Tests
             Assert.That(Convert.ToBoolean(match["isSubAsset"]), Is.True);
         }
 
+        [Test]
+        public void AssetSearch_SupportsRegexNameFiltering()
+        {
+            const string RegexAssetPath = "Assets/SCN_101.asset";
+
+            try
+            {
+                var sceneAsset = ScriptableObject.CreateInstance<SearchRootAsset>();
+                sceneAsset.name = "SCN_101";
+                AssetDatabase.CreateAsset(sceneAsset, RegexAssetPath);
+                AssetDatabase.SaveAssets();
+
+                var response = _router.Dispatch(
+                    "asset/search",
+                    1,
+                    "{\"name\":\"^SCN_[0-9]+$\",\"regex\":true,\"path\":\"Assets\",\"maxResults\":10}");
+
+                Assert.That(response.error, Is.Null);
+
+                var result = (Dictionary<string, object>)response.result;
+                var matches = (List<object>)result["results"];
+                var match = FindAssetMatchByPath(matches, RegexAssetPath);
+                Assert.That(match, Is.Not.Null);
+            }
+            finally
+            {
+                if (AssetDatabase.AssetPathExists(RegexAssetPath))
+                {
+                    AssetDatabase.DeleteAsset(RegexAssetPath);
+                    AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+                }
+            }
+        }
+
+        [Test]
+        public void AssetSearch_DoesNotEmitSceneReadObjectThreadedErrors()
+        {
+            EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
+            EditorSceneManager.SaveScene(UnityEngine.SceneManagement.SceneManager.GetActiveScene(), TempScenePath);
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            LogsController.ClearHistoryForTests();
+
+            var response = _router.Dispatch(
+                "asset/search",
+                1,
+                "{\"name\":\"UcpControllerMoveScene\",\"path\":\"Assets\",\"maxResults\":10}");
+
+            Assert.That(response.error, Is.Null);
+
+            var status = _router.Dispatch("logs/status", 1, "{}");
+            Assert.That(status.error, Is.Null);
+
+            var result = (Dictionary<string, object>)status.result;
+            var byLevel = (Dictionary<string, object>)result["byLevel"];
+            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(0));
+            Assert.That(Convert.ToInt32(byLevel["exception"]), Is.EqualTo(0));
+        }
+
         [Test]
         public void LogsTail_ReturnsRequestedBufferedCount()
         {
@@ -344,6 +411,30 @@ namespace UCP.Bridge.Tests
             Assert.That(result["stackTrace"], Is.EqualTo("stack line 1\nstack line 2"));
         }
 
+        [Test]
+        public void LogsStatus_CanScopeToNewEntriesAfterCursor()
+        {
+            var first = LogsController.RecordTestLog("info", "Before");
+            LogsController.RecordTestLog("warning", "After warning");
+            LogsController.RecordTestLog("error", "After error");
+
+            var response = _router.Dispatch(
+                "logs/status",
+                1,
+                "{\"afterId\":" + Convert.ToInt64(first["id"]) + "}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt64(result["afterId"]), Is.EqualTo(Convert.ToInt64(first["id"])));
+            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(2));
+
+            var byLevel = (Dictionary<string, object>)result["byLevel"];
+            Assert.That(Convert.ToInt32(byLevel["info"]), Is.EqualTo(0));
+            Assert.That(Convert.ToInt32(byLevel["warning"]), Is.EqualTo(1));
+            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(1));
+        }
+
         [Test]
         public void ObjectLifecycle_CreateMutateAndDelete_WorksEndToEnd()
         {
@@ -556,6 +647,28 @@ namespace UCP.Bridge.Tests
             Assert.That(AssetDatabase.GetAssetPath(movedAsset.referenceAsset), Is.EqualTo(TempMovedReferenceAssetPath));
         }
 
+        [Test]
+        public void AssetBulkMove_DryRunDoesNotMutateProject()
+        {
+            var asset = ScriptableObject.CreateInstance<SearchRootAsset>();
+            asset.name = "DryRunAsset";
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var response = _router.Dispatch(
+                "asset/bulk-move",
+                1,
+                "{\"dryRun\":true,\"moves\":[{\"from\":\"" + TempAssetPath + "\",\"to\":\"" + TempMovedAssetPath + "\"}]}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["dryRun"]), Is.True);
+            Assert.That(Convert.ToInt32(result["moved"]), Is.EqualTo(1));
+            Assert.That(AssetDatabase.LoadAssetAtPath<SearchRootAsset>(TempAssetPath), Is.Not.Null);
+            Assert.That(AssetDatabase.LoadAssetAtPath<SearchRootAsset>(TempMovedAssetPath), Is.Null);
+        }
+
         [Test]
         public void AssetMove_PreservesSceneMaterialReference()
         {
@@ -758,6 +871,53 @@ namespace UCP.Bridge.Tests
             Assert.That(importer.isReadable, Is.True);
         }
 
+        [Test]
+        public void ImporterController_ReimportRecursive_ReimportsFolderContents()
+        {
+            CreateTempRecursiveTextureAsset(Color.magenta);
+            AssetImportSupport.ClearTestState();
+
+            var response = _router.Dispatch(
+                "asset/reimport",
+                1,
+                "{\"path\":\"" + TempReimportFolderPath + "\",\"recursive\":true}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["recursive"]), Is.True);
+            Assert.That(Convert.ToInt32(result["requested"]), Is.GreaterThanOrEqualTo(1));
+            Assert.That(Convert.ToInt32(result["reimported"]), Is.GreaterThanOrEqualTo(1));
+            Assert.That(AssetImportSupport.LastReimportedPathForTests, Is.EqualTo(TempReimportTexturePath));
+        }
+
+        [Test]
+        public void SceneController_Load_AdditiveKeepsExistingSceneLoaded()
+        {
+            var firstScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("SceneAObject");
+            Assert.That(EditorSceneManager.SaveScene(firstScene, TempScenePath), Is.True);
+
+            var secondScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("SceneBObject");
+            Assert.That(EditorSceneManager.SaveScene(secondScene, TempSceneBPath), Is.True);
+
+            EditorSceneManager.OpenScene(TempScenePath, OpenSceneMode.Single);
+
+            var response = _router.Dispatch(
+                "scene/load",
+                1,
+                "{\"path\":\"" + TempSceneBPath + "\",\"additive\":true,\"saveDirtyScenes\":true,\"discardUntitled\":true}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["additive"]), Is.True);
+            Assert.That(UnityEngine.SceneManagement.SceneManager.sceneCount, Is.EqualTo(2));
+            Assert.That(UnityEngine.SceneManagement.SceneManager.GetSceneByPath(TempScenePath).isLoaded, Is.True);
+            Assert.That(UnityEngine.SceneManagement.SceneManager.GetSceneByPath(TempSceneBPath).isLoaded, Is.True);
+        }
+
         [Test]
         public void PackagesController_DependencySetInfoAndRemove_LocalFilePackage()
         {
@@ -1092,6 +1252,15 @@ namespace UCP.Bridge.Tests
             }
         }
 
+        private static void DeleteTempSceneB()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempSceneBPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempSceneBPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
         private static void DeleteTempMovedFolder()
         {
             if (AssetDatabase.IsValidFolder(TempMovedFolderPath))
@@ -1101,6 +1270,15 @@ namespace UCP.Bridge.Tests
             }
         }
 
+        private static void DeleteTempReimportFolder()
+        {
+            if (AssetDatabase.IsValidFolder(TempReimportFolderPath))
+            {
+                AssetDatabase.DeleteAsset(TempReimportFolderPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
         private static void DeleteTempProfilerExport()
         {
             var fullPath = ResolveProjectRelativePath(TempProfilerExportPath);
@@ -1180,6 +1358,24 @@ namespace UCP.Bridge.Tests
                 ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
         }
 
+        private static void CreateTempRecursiveTextureAsset(Color color)
+        {
+            DeleteTempReimportFolder();
+            Directory.CreateDirectory(ResolveProjectRelativePath(TempReimportFolderPath));
+
+            var texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
+            texture.SetPixels(new[] { color, color, color, color });
+            texture.Apply();
+
+            var bytes = texture.EncodeToPNG();
+            UnityEngine.Object.DestroyImmediate(texture);
+
+            File.WriteAllBytes(ResolveProjectRelativePath(TempReimportTexturePath), bytes);
+            AssetDatabase.ImportAsset(
+                TempReimportTexturePath,
+                ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+        }
+
         private static string ResolveProjectRelativePath(string assetPath)
         {
             var projectRoot = Path.GetDirectoryName(Application.dataPath);
@@ -1228,6 +1424,19 @@ namespace UCP.Bridge.Tests
             return null;
         }
 
+        private static Dictionary<string, object> FindAssetMatchByPath(List<object> matches, string expectedPath)
+        {
+            foreach (var entry in matches)
+            {
+                var match = (Dictionary<string, object>)entry;
+                var path = match.ContainsKey("path") ? match["path"].ToString() : string.Empty;
+                if (path == expectedPath)
+                    return match;
+            }
+
+            return null;
+        }
+
         private sealed class SearchRootAsset : ScriptableObject
         {
         }

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

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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,11 +1,11 @@
 {
   "name": "@mflrevan/ucp",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Unity Control Protocol - CLI for programmatic Unity Editor control",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mflRevan/unity-control-protocol.git"
+    "url": "git+https://github.com/mflRevan/unity-control-protocol.git"
   },
   "bin": {
     "ucp": "bin/ucp.js"