@alpsckr/unitycli 0.4.2 → 0.4.4

package/unitypkg/Tests/Editor/UnityCliContinuationIntegrationTests.cs

@@ -0,0 +1,292 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli.Tests
+{
+    public sealed class UnityCliContinuationIntegrationTests
+    {
+        private const string PrefabFolder = "Assets/UnityCliTests";
+        private const string PrefabPath = PrefabFolder + "/issue-042-continuation.prefab";
+
+        [TearDown]
+        public void TearDown()
+        {
+            FrameDebuggerReflection.ResetTestOverrides();
+            var stage = PrefabStageUtility.GetCurrentPrefabStage();
+            if (stage != null && string.Equals(PrefabToolSupport.StageAssetPath(stage), PrefabPath, StringComparison.OrdinalIgnoreCase))
+            {
+                PrefabToolSupport.SavePrefabStage(stage);
+                PrefabToolSupport.ClosePrefabStage();
+            }
+            AssetDatabase.DeleteAsset(PrefabPath);
+            if (AssetDatabase.IsValidFolder(PrefabFolder) && AssetDatabase.FindAssets(string.Empty, new[] { PrefabFolder }).Length == 0)
+                AssetDatabase.DeleteAsset(PrefabFolder);
+        }
+
+        [Test]
+        public void FrameDebuggerPagesEntireControlledCaptureAndRejectsChangedDeletedOrUnknownPositions()
+        {
+            const int eventCount = 1203;
+            var capture = "capture-a";
+            var currentCount = eventCount;
+            FrameDebuggerReflection.AvailableOverrideForTests = true;
+            FrameDebuggerReflection.EnabledOverrideForTests = () => true;
+            FrameDebuggerReflection.EventCountOverrideForTests = () => currentCount;
+            FrameDebuggerReflection.EventNameOverrideForTests = index => "event-" + index.ToString("D4", CultureInfo.InvariantCulture);
+            FrameDebuggerReflection.EventDataOverrideForTests = index => null;
+            FrameDebuggerReflection.GenerationOverrideForTests = () => capture;
+
+            var tool = new ProfilerFrameDebuggerEventsTool();
+            var indices = new List<long>();
+            string cursor = null;
+            string firstCursor = null;
+            string generation = null;
+            var pageCount = 0;
+            do
+            {
+                var page = tool.ExecuteAsync(
+                    new ProfilerFrameDebuggerEventsTool.Request { PageSize = 500, Cursor = cursor },
+                    Context("issue-042-frame-" + pageCount.ToString(CultureInfo.InvariantCulture))).GetAwaiter().GetResult();
+                pageCount++;
+                Assert.That(page.TotalEvents, Is.EqualTo(eventCount));
+                Assert.That(page.PageInfo.Cursor, Is.EqualTo(cursor));
+                Assert.That(page.PageInfo.ReturnedCount, Is.EqualTo(page.Events.Count));
+                Assert.That(page.Budget.ScannedRecords, Is.LessThanOrEqualTo(500));
+                Assert.That(page.Budget.Nodes, Is.LessThanOrEqualTo(500));
+                if (generation == null) generation = page.PageInfo.Generation;
+                else Assert.That(page.PageInfo.Generation, Is.EqualTo(generation));
+                indices.AddRange(page.Events.Select(item => item.Index));
+                cursor = page.PageInfo.NextCursor;
+                if (firstCursor == null) firstCursor = cursor;
+            } while (cursor != null);
+
+            CollectionAssert.AreEqual(Enumerable.Range(0, eventCount).Select(index => (long)index).ToArray(), indices.ToArray());
+            Assert.That(pageCount, Is.EqualTo(3));
+            Assert.That(indices.Distinct().Count(), Is.EqualTo(eventCount));
+
+            capture = "capture-b";
+            AssertStale(tool, firstCursor, "issue-042-frame-generation");
+            capture = "capture-a";
+            currentCount--;
+            AssertStale(tool, firstCursor, "issue-042-frame-deleted");
+            currentCount = eventCount;
+            var unknown = UnityCliContinuationToken.Create("profiler.frame-debugger.events", generation, "unknown");
+            AssertStale(tool, unknown, "issue-042-frame-unknown");
+        }
+
+        [Test]
+        public void FrameDebuggerHonorsDeadlineAndCancellationBeforePublishingPartialEvents()
+        {
+            var clock = new ManualClock();
+            FrameDebuggerReflection.AvailableOverrideForTests = true;
+            FrameDebuggerReflection.EventCountOverrideForTests = () => 10;
+            FrameDebuggerReflection.GenerationOverrideForTests = () => "capture-deadline";
+            FrameDebuggerReflection.EventNameOverrideForTests = index =>
+            {
+                clock.Advance(2);
+                return "event-" + index.ToString(CultureInfo.InvariantCulture);
+            };
+            FrameDebuggerReflection.EventDataOverrideForTests = index => null;
+            var budget = new UnityCliRequestBudget(
+                new UnityCliReadBudgetInput { MaxMainThreadMilliseconds = 1 },
+                30000,
+                CancellationToken.None,
+                clock);
+            var deadline = Assert.Throws<UnityCliRequestBudgetExceededException>(() => ProfilerFrameDebuggerEventsTool.ReadPage(
+                new ProfilerFrameDebuggerEventsTool.Request { PageSize = 5 }, budget));
+            Assert.That(deadline.Dimension, Is.EqualTo("mainThreadMilliseconds"));
+
+            var cancellation = new CancellationTokenSource();
+            cancellation.Cancel();
+            Assert.Throws<OperationCanceledException>(() => new ProfilerFrameDebuggerEventsTool().ExecuteAsync(
+                new ProfilerFrameDebuggerEventsTool.Request { PageSize = 5 },
+                Context("issue-042-frame-cancel", cancellation.Token)).GetAwaiter().GetResult());
+        }
+
+        [Test]
+        public void ConcurrentFramePagesUseIndependentBudgetsAndRetainNoSnapshotState()
+        {
+            FrameDebuggerReflection.AvailableOverrideForTests = true;
+            FrameDebuggerReflection.EventCountOverrideForTests = () => 64;
+            FrameDebuggerReflection.EventNameOverrideForTests = index => "event-" + index.ToString(CultureInfo.InvariantCulture);
+            FrameDebuggerReflection.EventDataOverrideForTests = index => null;
+            FrameDebuggerReflection.GenerationOverrideForTests = () => "capture-concurrent";
+            var pages = new ProfilerFrameDebuggerEventsTool.Result[8];
+
+            Parallel.For(0, pages.Length, index =>
+            {
+                var budget = new UnityCliRequestBudget(null, 30000, CancellationToken.None);
+                pages[index] = ProfilerFrameDebuggerEventsTool.ReadPage(
+                    new ProfilerFrameDebuggerEventsTool.Request { PageSize = 7 }, budget);
+            });
+
+            Assert.That(pages.All(page => page.Events.Count == 7), Is.True);
+            Assert.That(pages.All(page => page.Events.Select(item => item.Index).SequenceEqual(Enumerable.Range(0, 7).Select(value => (long)value))), Is.True);
+            Assert.That(pages.Select(page => page.PageInfo.NextCursor).Distinct().Count(), Is.EqualTo(1));
+            Assert.That(pages.All(page => page.Budget.ScannedRecords == 7 && page.Budget.Nodes == 7), Is.True);
+        }
+
+        [Test]
+        public void PrefabStagePagesWithoutDuplicatesAndRejectsGenerationOrDeletedBoundary()
+        {
+            CreatePrefabFixture(17);
+            Assert.That(PrefabToolSupport.OpenPrefabStage(PrefabPath), Is.True);
+            var stage = PrefabStageUtility.GetCurrentPrefabStage();
+            Assert.That(stage, Is.Not.Null);
+            Assert.That(stage.prefabContentsRoot, Is.Not.Null);
+
+            var tool = new GameObjectFindTool();
+            var ids = new List<long>();
+            string cursor = null;
+            string firstCursor = null;
+            do
+            {
+                var page = tool.ExecuteAsync(new GameObjectFindTool.Request
+                {
+                    SearchTerm = "issue-042-match",
+                    SearchMethod = "by_name",
+                    IncludeInactive = true,
+                    PreferPrefabStage = true,
+                    PageSize = 4,
+                    Cursor = cursor
+                }, Context("issue-042-prefab-page")).GetAwaiter().GetResult();
+                Assert.That(page.PrefabStageOpen, Is.True);
+                Assert.That(page.PageInfo.Cursor, Is.EqualTo(cursor));
+                ids.AddRange(page.Items.Select(item => item.Id));
+                cursor = page.PageInfo.NextCursor;
+                if (firstCursor == null) firstCursor = cursor;
+            } while (cursor != null);
+
+            Assert.That(ids.Count, Is.EqualTo(17));
+            Assert.That(ids.Distinct().Count(), Is.EqualTo(17));
+
+            UnityCliReadGeneration.InvalidateHierarchy();
+            AssertGoFindStale(tool, firstCursor, "issue-042-prefab-generation");
+
+            var fresh = tool.ExecuteAsync(new GameObjectFindTool.Request
+            {
+                SearchTerm = "issue-042-match",
+                SearchMethod = "by_name",
+                IncludeInactive = true,
+                PreferPrefabStage = true,
+                PageSize = 1
+            }, Context("issue-042-prefab-deleted-first")).GetAwaiter().GetResult();
+            string position;
+            Assert.That(UnityCliContinuationToken.TryParse(
+                fresh.PageInfo.NextCursor, "go.find", fresh.PageInfo.Generation, out position), Is.True);
+            var separator = position.IndexOf(':');
+            int instanceId;
+            Assert.That(separator, Is.GreaterThan(0));
+            Assert.That(int.TryParse(position.Substring(separator + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out instanceId), Is.True);
+            var deletedBoundary = EditorUtility.InstanceIDToObject(instanceId);
+            Assert.That(deletedBoundary, Is.Not.Null);
+            UnityEngine.Object.DestroyImmediate(deletedBoundary);
+            AssertGoFindStale(tool, fresh.PageInfo.NextCursor, "issue-042-prefab-deleted");
+        }
+
+        [Test]
+        public void ExactIdSelectorDoesNotScanLargeSceneAndUnknownIdsReturnEmpty()
+        {
+            var scene = EditorSceneManager.NewPreviewScene();
+            try
+            {
+                GameObject target = null;
+                for (var index = 0; index < 1000; index++)
+                {
+                    var value = new GameObject("issue-042-exact-" + index.ToString("D4", CultureInfo.InvariantCulture));
+                    SceneManager.MoveGameObjectToScene(value, scene);
+                    if (index == 777) target = value;
+                }
+                var tool = new GameObjectFindTool();
+                var found = tool.ExecuteAsync(new GameObjectFindTool.Request
+                {
+                    SearchTerm = target.GetInstanceID().ToString(CultureInfo.InvariantCulture),
+                    SearchMethod = "by_id",
+                    IncludeInactive = true,
+                    Budget = new UnityCliReadBudgetInput { MaxScannedRecords = 1 }
+                }, Context("issue-042-exact-found")).GetAwaiter().GetResult();
+                Assert.That(found.ReturnedCount, Is.EqualTo(1));
+                Assert.That(found.Items.Single().Id, Is.EqualTo(target.GetInstanceID()));
+                Assert.That(found.Budget.ScannedRecords, Is.Zero);
+
+                var missing = tool.ExecuteAsync(new GameObjectFindTool.Request
+                {
+                    SearchTerm = int.MaxValue.ToString(CultureInfo.InvariantCulture),
+                    SearchMethod = "by_id",
+                    IncludeInactive = true,
+                    Budget = new UnityCliReadBudgetInput { MaxScannedRecords = 1 }
+                }, Context("issue-042-exact-missing")).GetAwaiter().GetResult();
+                Assert.That(missing.ReturnedCount, Is.Zero);
+                Assert.That(missing.PageInfo.Complete, Is.True);
+                Assert.That(missing.Budget.ScannedRecords, Is.Zero);
+            }
+            finally
+            {
+                Assert.That(EditorSceneManager.ClosePreviewScene(scene), Is.True);
+            }
+        }
+
+        private static void AssertStale(ProfilerFrameDebuggerEventsTool tool, string cursor, string requestId)
+        {
+            var exception = Assert.Throws<UnityCliBridge.BridgeCommandException>(() => tool.ExecuteAsync(
+                new ProfilerFrameDebuggerEventsTool.Request { PageSize = 500, Cursor = cursor }, Context(requestId)).GetAwaiter().GetResult());
+            Assert.That(exception.Code, Is.EqualTo("E_CONTINUATION_STALE"));
+        }
+
+        private static void AssertGoFindStale(GameObjectFindTool tool, string cursor, string requestId)
+        {
+            var exception = Assert.Throws<UnityCliBridge.BridgeCommandException>(() => tool.ExecuteAsync(new GameObjectFindTool.Request
+            {
+                SearchTerm = "issue-042-match",
+                SearchMethod = "by_name",
+                IncludeInactive = true,
+                PreferPrefabStage = true,
+                PageSize = 4,
+                Cursor = cursor
+            }, Context(requestId)).GetAwaiter().GetResult());
+            Assert.That(exception.Code, Is.EqualTo("E_CONTINUATION_STALE"));
+        }
+
+        private static UnityCliProjectToolContext Context(string requestId, CancellationToken cancellationToken = default)
+        {
+            return new UnityCliProjectToolContext { RequestId = requestId, TimeoutMs = 30000, CancellationToken = cancellationToken };
+        }
+
+        private static void CreatePrefabFixture(int childCount)
+        {
+            if (!AssetDatabase.IsValidFolder(PrefabFolder)) AssetDatabase.CreateFolder("Assets", "UnityCliTests");
+            AssetDatabase.DeleteAsset(PrefabPath);
+            var root = new GameObject("issue-042-prefab-root");
+            try
+            {
+                for (var index = 0; index < childCount; index++)
+                {
+                    var child = new GameObject("issue-042-match");
+                    child.transform.SetParent(root.transform, false);
+                    child.SetActive(index % 3 != 0);
+                }
+                Assert.That(PrefabUtility.SaveAsPrefabAsset(root, PrefabPath), Is.Not.Null);
+                AssetDatabase.SaveAssets();
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(root);
+            }
+        }
+
+        private sealed class ManualClock : IUnityCliMonotonicClock
+        {
+            public long ElapsedMilliseconds { get; private set; }
+            internal void Advance(long milliseconds) { ElapsedMilliseconds += milliseconds; }
+        }
+    }
+}

package/unitypkg/Tests/Editor/UnityCliDiagnosticBoundaryTests.cs

@@ -0,0 +1,120 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace UnityCli.Tests
+{
+    public sealed class UnityCliDiagnosticBoundaryTests
+    {
+        private static readonly Type BridgeType = Type.GetType("UnityCli.UnityCliBridge, UnityCli.Editor", true);
+
+        [Test]
+        public void DoctorCatalogHandlerReadsThePublishedSnapshotWithoutAnotherConstruction()
+        {
+            var constructionCounter = Field("projectToolCatalogConstructionCount");
+            var reader = BridgeType.GetProperty("ProjectToolCatalogSnapshotReader", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null, null);
+            var snapshot = reader.GetType().GetMethod("Read", BindingFlags.Public | BindingFlags.Instance).Invoke(reader, null);
+            var expectedToolCount = Convert.ToInt64(snapshot.GetType().GetProperty("ToolCount").GetValue(snapshot, null));
+            var registry = Method("CreateCommandRegistry").Invoke(null, null);
+            var requestType = Type.GetType("UnityCli.Protocol.BridgeRequest, UnityCli.Editor", true);
+            var request = Activator.CreateInstance(requestType);
+            requestType.GetProperty("Command").SetValue(request, "internal.doctor.catalog", null);
+            requestType.GetProperty("RequestId").SetValue(request, "doctor-catalog-owner", null);
+            requestType.GetProperty("Input").SetValue(request, new Dictionary<string, object>(), null);
+
+            var before = Convert.ToInt64(constructionCounter.GetValue(null));
+            var pending = (ValueTask<object>)registry.GetType().GetMethod("ExecuteAsync").Invoke(registry, new[] { request, (object)CancellationToken.None });
+            var result = (IDictionary<string, object>)pending.AsTask().GetAwaiter().GetResult();
+            var after = Convert.ToInt64(constructionCounter.GetValue(null));
+
+            Assert.That(after, Is.EqualTo(before));
+            Assert.That(result["identity"], Is.EqualTo("unity-cli-immutable-domain-catalog"));
+            Assert.That(Convert.ToInt64(result["toolCount"]), Is.EqualTo(expectedToolCount));
+            Assert.That(result["providerCounts"], Is.InstanceOf<IDictionary<string, object>>());
+            Assert.That(result["publicationDiagnostics"], Is.InstanceOf<IDictionary<string, object>>());
+            var serialized = UnityCli.UnityCliSerializer.Serialize(result);
+            Assert.That(Encoding.UTF8.GetByteCount(serialized), Is.LessThanOrEqualTo(64 * 1024));
+            Assert.That(serialized, Does.Not.Contain("fingerprint").IgnoreCase);
+            Assert.That(serialized, Does.Not.Contain("rePinValue"));
+        }
+
+        [Test]
+        public void ProjectToolNamesUseProfileAwareGrammarAndOneUtf8Budget()
+        {
+            var validator = Type.GetType("UnityCli.UnityCliToolName, UnityCli.Editor", true);
+            var validate = validator.GetMethod("Validate", BindingFlags.NonPublic | BindingFlags.Static);
+            Assert.DoesNotThrow(() => validate.Invoke(null, new object[] { "scene.hierarchy", "native" }));
+            Assert.DoesNotThrow(() => validate.Invoke(null, new object[] { new string('a', 128), "native" }));
+            Assert.DoesNotThrow(() => validate.Invoke(null, new object[] { "UnityPipeline_hotfix_container_inspect", "official-attribute" }));
+            Assert.DoesNotThrow(() => validate.Invoke(null, new object[] { "UnityPipeline_project_reload_data", "official-attribute" }));
+
+            AssertInvalidName(validate, "UnityPipeline_project_reload_data", "native");
+            AssertInvalidName(validate, "project_reload_data", "official-attribute");
+            AssertInvalidName(validate, "Scene.Data", "native");
+            AssertInvalidName(validate, "scene..data", "native");
+            AssertInvalidName(validate, "scene.数据", "native");
+            AssertInvalidName(validate, new string('a', 129), "native");
+            AssertInvalidName(validate, "scene.hierarchy\n", "native");
+            AssertInvalidName(validate, "scene.hierarchy\r\n", "native");
+            AssertInvalidName(validate, "scene.hierarchy ", "native");
+            AssertInvalidName(validate, "UnityPipeline_project_reload_data\n", "official-attribute");
+            AssertInvalidName(validate, "UnityPipeline_project_reload_data\r\n", "official-attribute");
+            AssertInvalidName(validate, "UnityPipeline_project_reload_data\t", "official-attribute");
+        }
+
+        [Test]
+        public void CodeExecBridgeEnvelopeUsesTerminalCauseBeyondEightLevels()
+        {
+            const string terminalMessage = "terminal-actionable-cause";
+            Exception exception = new InvalidOperationException(terminalMessage);
+            for (var index = 0; index < 12; index++) exception = new TargetInvocationException("wrapper-" + index, exception);
+
+            var result = Method("ExceptionFailure").Invoke(null, new object[]
+            {
+                "E_CODE_RUNTIME_EXCEPTION", string.Empty, exception, string.Empty, string.Empty,
+                "Inspect the bounded runtime exception cause chain and affected business state."
+            });
+            var envelope = (string)Method("SerializeCodeExecutionResult").Invoke(null, new[] { "code-exec-deep-cause", result });
+            var serializer = Type.GetType("UnityCli.UnityCliSerializer, UnityCli.Editor", true);
+            var root = (IDictionary<string, object>)serializer.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static).Invoke(null, new object[] { envelope });
+            var error = (IDictionary<string, object>)root["error"];
+            var details = (IDictionary<string, object>)error["details"];
+            var causes = (IList)details["causes"];
+            var terminal = (IDictionary<string, object>)causes[causes.Count - 1];
+
+            Assert.That(error["code"], Is.EqualTo("E_CODE_RUNTIME_EXCEPTION"));
+            Assert.That(error["message"], Is.EqualTo(terminalMessage));
+            Assert.That(details["message"], Is.EqualTo(terminalMessage));
+            Assert.That(details["exceptionType"], Is.EqualTo(typeof(InvalidOperationException).FullName));
+            Assert.That(details["causeChainTruncated"], Is.EqualTo(true));
+            Assert.That(causes.Count, Is.EqualTo(8));
+            Assert.That(terminal["depth"], Is.EqualTo(12L));
+            Assert.That(terminal["message"], Is.EqualTo(terminalMessage));
+            Assert.That(Encoding.UTF8.GetByteCount(envelope), Is.LessThanOrEqualTo(1536 * 1024));
+        }
+
+        private static void AssertInvalidName(MethodInfo validate, string name, string contractProfile)
+        {
+            var exception = Assert.Throws<TargetInvocationException>(() => validate.Invoke(null, new object[] { name, contractProfile }));
+            Assert.That(exception.InnerException, Is.TypeOf<InvalidOperationException>());
+            Assert.That(exception.InnerException.Message, Is.EqualTo("Tool name must use the registered Tool syntax and fit 128 UTF-8 bytes."));
+        }
+
+        private static FieldInfo Field(string name)
+        {
+            return BridgeType.GetField(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingFieldException(name);
+        }
+
+        private static MethodInfo Method(string name)
+        {
+            return BridgeType.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingMethodException(name);
+        }
+    }
+}
+#endif

package/unitypkg/Tests/Editor/UnityCliDurableStatusTests.cs

@@ -0,0 +1,84 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace UnityCli.Tests
+{
+    public sealed class UnityCliDurableStatusTests
+    {
+        private string _scope;
+        private string _runningRequestId;
+        private string _terminalRequestId;
+        private static readonly string Digest = new string('a', 64);
+
+        [SetUp]
+        public void SetUp()
+        {
+            // terminal identity在Editor session内有意持久化，增量重复执行必须使用新identity。
+            var runId = Guid.NewGuid().ToString("N");
+            _scope = "durable-status-test-" + runId;
+            _runningRequestId = "durable-status-running-root-" + runId;
+            _terminalRequestId = "durable-status-terminal-root-" + runId;
+            UnityCliActiveOperation.Clear(_scope);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            UnityCliActiveOperation.Clear(_scope);
+        }
+
+        [Test]
+        public void ReadScope_ReturnsRunningPhaseWithoutDigest()
+        {
+            UnityCliActiveOperation.Save(_scope, new Dictionary<string, object>
+            {
+                { "requestId", _runningRequestId }, { "requestDigest", Digest }, { "phase", "effect_started" }
+            });
+
+            var result = (Dictionary<string, object>)UnityCliBridge.UnityCliDurableStatusCoordinator.ReadScope(_scope, _runningRequestId);
+
+            Assert.That(result["requestId"], Is.EqualTo(_runningRequestId));
+            Assert.That(result["state"], Is.EqualTo("running"));
+            Assert.That(result["phase"], Is.EqualTo("effect_started"));
+            Assert.That(result.ContainsKey("requestDigest"), Is.False);
+            Assert.That(result.ContainsKey("terminalEnvelope"), Is.False);
+        }
+
+        [Test]
+        public void ReadScope_ReturnsFirstTerminalWithoutReplayingEffect()
+        {
+            var terminal = new Dictionary<string, object>
+            {
+                { "ok", true }, { "requestId", _terminalRequestId }, { "data", new Dictionary<string, object> { { "value", 1L } } }
+            };
+            var first = UnityCliActiveOperation.StoreTerminalFirst(_scope, _terminalRequestId, Digest, null, "test.run", terminal);
+
+            var result = (Dictionary<string, object>)UnityCliBridge.UnityCliDurableStatusCoordinator.ReadScope(_scope, _terminalRequestId);
+            Assert.That(UnityCliActiveOperation.TryGetTerminalByRequestId(_scope, _terminalRequestId, out var internalDigest, out var statusDomain, out var selected), Is.True);
+
+            Assert.That(result["state"], Is.EqualTo("completed"));
+            Assert.That(result["terminalEnvelope"], Is.EqualTo(first));
+            Assert.That(internalDigest, Is.EqualTo(Digest));
+            Assert.That(statusDomain, Is.EqualTo("test.run"));
+            Assert.That(selected, Is.EqualTo(first));
+            Assert.That(result.ContainsKey("requestDigest"), Is.False);
+        }
+
+        [Test]
+        public void SafeStatusAllowlist_ContainsEveryDomainCommand()
+        {
+            var commands = new[]
+            {
+                "internal.asset.refresh.public-status", "internal.build.player.public-status",
+                "internal.editor.play-mode.public-status", "internal.package.install.public-status",
+                "internal.package.remove.public-status", "internal.test.run.public-status"
+            };
+            foreach (var command in commands)
+                Assert.That(UnityCliBridgeQueuePolicy.IsSafeStatusCommand(command), Is.True, command);
+            Assert.That(UnityCliBridgeQueuePolicy.IsSafeStatusCommand("internal.operation.public-status"), Is.False);
+        }
+    }
+}
+#endif

package/unitypkg/Tests/Editor/UnityCliExceptionProjectionTests.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using NUnit.Framework;
+
+namespace UnityCli.Tests
+{
+    public sealed class UnityCliExceptionProjectionTests
+    {
+        [Test]
+        public void NestedReflectionAndNUnitFailureUsesDeepestActionableCause()
+        {
+            var assertion = new AssertionException("Expected health check to pass, but it failed.");
+            var wrapper = new InvalidOperationException("NUnit invocation failed.", assertion);
+            var reflection = new TargetInvocationException("Reflected method failed.", wrapper);
+
+            var result = UnityCliExceptionProjection.Project(reflection);
+
+            Assert.That(result.PublicMessage, Is.EqualTo(assertion.Message));
+            Assert.That(result.DeepestExceptionType, Is.EqualTo(typeof(AssertionException).FullName));
+            Assert.That(result.Causes, Has.Count.EqualTo(3));
+            Assert.That(result.Causes[0]["exceptionType"], Is.EqualTo(typeof(TargetInvocationException).FullName));
+            Assert.That(result.Causes[2]["message"], Is.EqualTo(assertion.Message));
+            Assert.That(result.Truncated, Is.False);
+        }
+
+        [Test]
+        public void CauseChainStopsAtCyclesAndStaysDepthAndByteBounded()
+        {
+            Exception deep = new Exception(new string('z', 100000));
+            for (var index = 0; index < UnityCliExceptionProjection.MaxCauseDepth + 4; index++)
+                deep = new InvalidOperationException(new string((char)('a' + index), 100000), deep);
+            var deepResult = UnityCliExceptionProjection.Project(deep);
+            Assert.That(deepResult.Causes, Has.Count.EqualTo(UnityCliExceptionProjection.MaxCauseDepth));
+            Assert.That(deepResult.CauseTextBytes, Is.LessThanOrEqualTo(UnityCliExceptionProjection.MaxCauseTextBytes));
+            Assert.That(deepResult.CauseTraversalCount, Is.EqualTo(UnityCliExceptionProjection.MaxCauseDepth + 5));
+            Assert.That(deepResult.PublicMessage, Is.EqualTo(new string('z', 4096)));
+            Assert.That(deepResult.DeepestMessage, Is.EqualTo(new string('z', 4096)));
+            Assert.That(deepResult.Causes[UnityCliExceptionProjection.MaxCauseDepth - 1]["depth"], Is.EqualTo((long)(UnityCliExceptionProjection.MaxCauseDepth + 4)));
+            Assert.That(deepResult.Causes[UnityCliExceptionProjection.MaxCauseDepth - 1]["message"], Is.EqualTo(new string('z', 4096)));
+            Assert.That(deepResult.Truncated, Is.True);
+
+            var first = new InvalidOperationException("first");
+            var second = new Exception("second");
+            var next = new Dictionary<Exception, Exception>
+            {
+                { first, second },
+                { second, first }
+            };
+            var cycleResult = UnityCliExceptionProjection.Project(first, value => next[value]);
+            Assert.That(cycleResult.Causes, Has.Count.EqualTo(2));
+            Assert.That(cycleResult.Truncated, Is.True);
+            Assert.That(cycleResult.PublicMessage, Is.EqualTo("second"));
+            Assert.That(cycleResult.CauseTraversalCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TraversalWorkRemainsHardBoundedBeyondThePublishedCauseDepth()
+        {
+            Exception deep = new Exception("terminal-beyond-traversal-budget");
+            for (var index = 0; index < UnityCliExceptionProjection.MaxCauseTraversal + 20; index++)
+                deep = new InvalidOperationException("wrapper-" + index, deep);
+
+            var result = UnityCliExceptionProjection.Project(deep);
+
+            Assert.That(result.CauseTraversalCount, Is.EqualTo(UnityCliExceptionProjection.MaxCauseTraversal));
+            Assert.That(result.Causes, Has.Count.EqualTo(UnityCliExceptionProjection.MaxCauseDepth));
+            Assert.That(result.CauseTextBytes, Is.LessThanOrEqualTo(UnityCliExceptionProjection.MaxCauseTextBytes));
+            Assert.That(result.Truncated, Is.True);
+        }
+    }
+}