@mflrevan/ucp 0.6.1 → 0.6.2

package/README.md

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

@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.6.2] - 2026-08-31
+
+### Added
+
+- Added native, scene-object-free `record/start`, `record/stop`, `record/status`, `record/arm`, and
+  `record/signal` RPCs for Game and Scene view video capture.
+- Added aspect-preserving longest-edge sizing and explicit width/height canvases with letterboxing,
+  even-dimension normalization, configurable FPS/bitrate/duration, H.264/MP4 and VP8/WebM encoding,
+  and platform-aware format selection.
+- Added play-enter, play-exit, bounded log-regex, and named-signal triggers. Armed play triggers use
+  `SessionState` to survive domain reloads, and `record/stop` also cancels a pending trigger.
+- Added a `slowdown` parameter to `record/start` and `record/arm`. Frames are still captured at the
+  requested cadence in real time; only the encoder's declared frame rate is divided by the factor, so
+  playback is stretched without duplicating frames or re-encoding. `record/status` reports both
+  `slowdown` and the resulting `playbackFps`. Values outside 1-20 are rejected. This raises effective
+  temporal resolution for consumers that sample a clip at a fixed low rate rather than playing it.
+- Documented that `record/start --view game` resolves `Camera.main`, not the Game view's composited
+  camera stack. Projects rendering through several enabled cameras record only the `MainCamera`-tagged
+  one, and camera depth does not change the selection; `--view scene` captures the Scene view camera,
+  which is unaffected by gameplay.
+
+### Fixed
+
+- Fixed `tests/run` counting an empty root suite as a passed test. When a filter matched nothing,
+  the run finished with a childless root whose result was collected as a leaf, so the summary
+  reported one passed test named after the project. Suite results are now skipped, so a run that
+  executed nothing reports a total of zero.
+- Changed `tests/run` filtering from `Filter.testNames` to `Filter.groupNames`. `testNames` requires
+  an exact fully-qualified match, which silently selected nothing for a class or method name;
+  `groupNames` is matched as a regular expression against each test's full name, so partial names
+  select what a caller expects and fully-qualified names still match.
+- Fixed `object/get-property` double-converting values that `SerializedPropertyToValue` had already
+  shaped for JSON. `GetPropertyValue` resolves a name through `SerializedObject.FindProperty` first
+  and returns a ready `List`/`Dictionary`; `ConvertToJson` then ran over that result, matched none
+  of its cases, and fell through to `value.ToString()`. A `Vector3` field came back as
+  ``"System.Collections.Generic.List`1[System.Object]"`` with
+  ``"type": "List`1"``. Every serialized Vector2/3/4, Quaternion, Color, Rect, Bounds and
+  object-reference field was affected, and float fields reported a `Double` type name.
+  `get-property` now takes its type name from the `SerializedProperty` so it agrees with
+  `get-fields`, converts only values read through the reflection fallback, and `ConvertToJson` is
+  idempotent for already-shaped `IList`/`IDictionary` values.
+
+### Performance
+
+- Frames render through a hidden reusable `RenderTexture` and reusable CPU readback texture into
+  Unity's native `MediaEncoder`; recording creates no scene objects or scripts and avoids per-frame
+  managed texture allocation.
+
+### Reliability
+
+- Added sibling `.partial` output and final rename, explicit overwrite handling, extension/format
+  validation, encoder and temporary-file cleanup on failure, detached safety deadlines, trigger wait
+  deadlines, dropped-frame accounting, and structured completed/failed status metadata.
+- Active encoders finalize during assembly reload or editor shutdown. Play-boundary capture is
+  handled by the persisted `play-enter`/`play-exit` arm flow rather than attempting to retain a
+  native encoder across a domain reload.
+
+### Tests
+
+- Added editor smoke tests for recording RPC registration and idle status, aspect-preserving even
+  dimensions, signal matching, and cancellation of armed recordings.
+
 ## [0.4.1] - 2026-03-21
 
 ### Added

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.6.1";
+        private const string ProtocolVersion = "0.6.2";
 
         private static TcpListener s_listener;
         private static CancellationTokenSource s_cts;
@@ -142,6 +142,9 @@ namespace UCP.Bridge
             // Screenshots
             ScreenshotController.Register(s_router);
 
+            // Lightweight video recording
+            RecordingController.Register(s_router);
+
             // Logs
             LogsController.Register(s_router);
 
@@ -509,6 +512,7 @@ namespace UCP.Bridge
 
         private static void OnLogMessage(string message, string stackTrace, LogType type)
         {
+            RecordingController.NotifyLog(message);
             // Don't forward our own log messages to avoid infinite recursion
             if (message.StartsWith("[UCP]")) return;
 
@@ -575,6 +579,8 @@ namespace UCP.Bridge
 
             Debug.Log("[UCP] Bridge server shutting down");
 
+            RecordingController.Shutdown();
+
             s_cts?.Cancel();
 
             // Stop listener first to release port immediately

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

@@ -77,14 +77,14 @@ namespace UCP.Bridge
             var comp = FindComponent(go, cObj.ToString());
             string propName = propObj.ToString();
 
-            var value = GetPropertyValue(comp, propName);
+            var value = GetPropertyValue(comp, propName, out var typeName);
             return new Dictionary<string, object>
             {
                 ["instanceId"] = instanceId,
                 ["component"] = cObj.ToString(),
                 ["property"] = propName,
-                ["value"] = ConvertToJson(value),
-                ["type"] = value != null ? value.GetType().Name : "null"
+                ["value"] = value,
+                ["type"] = typeName
             };
         }
 
@@ -277,7 +277,7 @@ namespace UCP.Bridge
             }
         }
 
-        private static object GetPropertyValue(Component comp, string propertyName)
+        private static object GetPropertyValue(Component comp, string propertyName, out string typeName)
         {
             var so = new SerializedObject(comp);
             try
@@ -285,22 +285,35 @@ namespace UCP.Bridge
                 so.Update();
                 var prop = so.FindProperty(propertyName);
                 if (prop != null)
+                {
+                    // Already JSON-shaped -- reporting its type from the SerializedProperty keeps
+                    // `get-property` and `get-fields` describing the same field the same way.
+                    typeName = prop.propertyType.ToString();
                     return SerializedPropertyToValue(prop);
+                }
             }
             finally
             {
                 so.Dispose();
             }
 
-            // Fallback to reflection
+            // Fallback to reflection for names Unity does not serialize (e.g. Transform.position).
             var type = comp.GetType();
             var fi = type.GetField(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             if (fi != null)
-                return fi.GetValue(comp);
+            {
+                var raw = fi.GetValue(comp);
+                typeName = raw != null ? raw.GetType().Name : fi.FieldType.Name;
+                return ConvertToJson(raw);
+            }
 
             var pi = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
             if (pi != null && pi.CanRead)
-                return pi.GetValue(comp);
+            {
+                var raw = pi.GetValue(comp);
+                typeName = raw != null ? raw.GetType().Name : pi.PropertyType.Name;
+                return ConvertToJson(raw);
+            }
 
             throw new ArgumentException($"Property '{propertyName}' not found on {type.Name}");
         }
@@ -488,6 +501,9 @@ namespace UCP.Bridge
                 return new List<object> { (double)c.r, (double)c.g, (double)c.b, (double)c.a };
             if (value is UnityEngine.Object uObj)
                 return ObjectReferenceResolver.Serialize(uObj);
+            // Values that are already JSON-shaped pass through untouched.
+            if (value is IList || value is IDictionary)
+                return value;
             return value.ToString();
         }
 

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

@@ -0,0 +1,724 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEditor.Media;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// Lightweight editor video capture for agent workflows. Frames are rendered without scene
+    /// objects, read back into a reusable texture, and written directly through Unity's native encoder.
+    /// </summary>
+    public static class RecordingController
+    {
+        private const string ArmedSessionKey = "UCP.Recording.Armed";
+        private static MediaEncoder s_encoder;
+        private static RenderTexture s_target;
+        private static Texture2D s_readback;
+        private static RecordingSettings s_settings;
+        private static Dictionary<string, object> s_lastResult;
+        private static string s_state = "idle";
+        private static string s_path;
+        private static string s_tempPath;
+        private static string s_error;
+        private static double s_startedAt;
+        private static double s_stopAt;
+        private static double s_hardStopAt;
+        private static double s_nextCaptureAt;
+        private static int s_frameCount;
+        private static int s_droppedFrames;
+        private static bool s_stopRequested;
+        private static ArmedRecording s_armed;
+
+        static RecordingController()
+        {
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+            AssemblyReloadEvents.beforeAssemblyReload += Shutdown;
+            EditorApplication.quitting += Shutdown;
+            RestoreArmedRecording();
+        }
+
+        public static void Register(CommandRouter router)
+        {
+            router.Register("record/start", HandleStart);
+            router.Register("record/stop", HandleStop);
+            router.Register("record/status", _ => BuildStatus());
+            router.Register("record/arm", HandleArm);
+            router.Register("record/signal", HandleSignal);
+        }
+
+        public static void Signal(string name)
+        {
+            if (s_armed == null || !s_armed.MatchesSignal(name)) return;
+            StartArmedRecording();
+        }
+
+        public static void NotifyLog(string message)
+        {
+            if (s_armed == null || s_armed.LogRegex == null) return;
+            try
+            {
+                if (s_armed.LogRegex.IsMatch(message ?? string.Empty)) StartArmedRecording();
+            }
+            catch (RegexMatchTimeoutException)
+            {
+                FailArm("Log trigger regex timed out");
+            }
+        }
+
+        public static void Shutdown()
+        {
+            if (s_encoder == null) return;
+            try { FinalizeRecording(); }
+            catch { DisposeResources(); }
+        }
+
+        internal static void ResetForTests()
+        {
+            Shutdown();
+            ClearArm();
+            s_lastResult = null;
+            s_state = "idle";
+            s_error = null;
+        }
+
+        internal static (int width, int height) ResolveDimensionsForTests(
+            float aspect, int maxEdge, int? width, int? height)
+        {
+            return ResolveDimensions(aspect, maxEdge, width, height);
+        }
+
+        private static object HandleStart(string paramsJson)
+        {
+            if (s_encoder != null || s_state == "finalizing")
+                throw new InvalidOperationException("A recording is already active. Use `ucp record status` or `ucp record stop`.");
+
+            ClearArm();
+            var settings = ParseSettings(paramsJson);
+            StartRecording(settings);
+            return BuildStatus();
+        }
+
+        private static object HandleStop(string paramsJson)
+        {
+            if (s_armed != null)
+            {
+                ClearArm();
+                s_state = "idle";
+                s_error = null;
+                s_settings = null;
+                s_path = null;
+                s_tempPath = null;
+                return BuildStatus();
+            }
+            if (s_encoder == null)
+                return BuildStatus();
+
+            s_stopRequested = true;
+            s_state = "finalizing";
+            FinalizeRecording();
+            return BuildStatus();
+        }
+
+        private static object HandleArm(string paramsJson)
+        {
+            if (s_encoder != null || s_state == "finalizing")
+                throw new InvalidOperationException("Cannot arm while a recording is active");
+
+            var parameters = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (parameters == null || !TryString(parameters, "trigger", out var trigger))
+                throw new ArgumentException("Missing 'trigger' parameter");
+
+            var settings = ParseSettings(paramsJson);
+            var timeout = ReadDouble(parameters, "timeout", 60d);
+            s_settings = settings;
+            s_lastResult = null;
+            s_path = null;
+            s_tempPath = null;
+            s_frameCount = 0;
+            s_droppedFrames = 0;
+            s_armed = ArmedRecording.Create(trigger, settings,
+                timeout > 0d ? EditorApplication.timeSinceStartup + timeout : 0d);
+            PersistArm();
+            s_state = "armed";
+            s_error = null;
+            SubscribeTick();
+            return BuildStatus();
+        }
+
+        private static object HandleSignal(string paramsJson)
+        {
+            var parameters = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (parameters == null || !TryString(parameters, "name", out var name))
+                throw new ArgumentException("Missing 'name' parameter");
+            var matched = s_armed != null && s_armed.MatchesSignal(name);
+            Signal(name);
+            var result = BuildStatus();
+            result["matched"] = matched;
+            result["signal"] = name;
+            return result;
+        }
+
+        private static void StartRecording(RecordingSettings settings)
+        {
+            var camera = ResolveCamera(settings.View);
+            var sourceAspect = ResolveSourceAspect(camera);
+            var dimensions = ResolveDimensions(sourceAspect, settings.MaxEdge, settings.Width, settings.Height);
+            settings.Width = dimensions.width;
+            settings.Height = dimensions.height;
+            settings.SourceAspect = sourceAspect;
+
+            ResolveOutputPaths(settings, out s_path, out s_tempPath);
+            var parent = Path.GetDirectoryName(s_path);
+            if (!string.IsNullOrEmpty(parent)) Directory.CreateDirectory(parent);
+            if (File.Exists(s_path) && !settings.Overwrite)
+                throw new IOException($"Recording output already exists: {s_path}. Pass --overwrite to replace it.");
+            if (File.Exists(s_tempPath)) File.Delete(s_tempPath);
+
+            try
+            {
+                s_encoder = CreateEncoder(s_tempPath, settings);
+                s_target = new RenderTexture(settings.Width.Value, settings.Height.Value, 24,
+                    RenderTextureFormat.ARGB32)
+                {
+                    antiAliasing = 1,
+                    name = "__ucp_recording_target",
+                    hideFlags = HideFlags.HideAndDontSave
+                };
+                s_target.Create();
+                s_readback = new Texture2D(settings.Width.Value, settings.Height.Value,
+                    TextureFormat.RGBA32, false)
+                {
+                    name = "__ucp_recording_readback",
+                    hideFlags = HideFlags.HideAndDontSave
+                };
+            }
+            catch
+            {
+                try { s_encoder?.Dispose(); } catch { }
+                s_encoder = null;
+                DisposeResources();
+                TryDeleteTempFile();
+                throw;
+            }
+
+            s_settings = settings;
+            s_startedAt = EditorApplication.timeSinceStartup;
+            s_stopAt = settings.Duration > 0d ? s_startedAt + settings.Duration : 0d;
+            s_hardStopAt = settings.MaxDuration > 0d ? s_startedAt + settings.MaxDuration : 0d;
+            s_nextCaptureAt = s_startedAt;
+            s_frameCount = 0;
+            s_droppedFrames = 0;
+            s_stopRequested = false;
+            s_error = null;
+            s_state = "recording";
+            s_lastResult = null;
+            SubscribeTick();
+        }
+
+        private static MediaEncoder CreateEncoder(string path, RecordingSettings settings)
+        {
+            // Capture cadence stays real time; only the declared playback rate changes. No frames
+            // are duplicated and nothing is re-encoded -- the container simply spaces the captured
+            // frames further apart, which is what raises effective temporal resolution for a
+            // consumer that samples the file at a fixed rate.
+            var frameRate = new MediaRational(settings.Fps);
+            if (settings.Slowdown > 1.0000001d)
+            {
+                frameRate.numerator = Mathf.RoundToInt(settings.Fps * 1000f);
+                frameRate.denominator = Mathf.RoundToInt((float)settings.Slowdown * 1000f);
+            }
+            var bitrate = (uint)(settings.BitrateKbps * 1000);
+            VideoTrackEncoderAttributes attributes;
+            if (settings.Format == "webm")
+            {
+                attributes = new VideoTrackEncoderAttributes(new VP8EncoderAttributes
+                {
+                    keyframeDistance = (uint)(settings.Fps * 2)
+                });
+            }
+            else
+            {
+                attributes = new VideoTrackEncoderAttributes(new H264EncoderAttributes
+                {
+                    gopSize = (uint)(settings.Fps * 2),
+                    numConsecutiveBFrames = 0,
+                    profile = VideoEncodingProfile.H264Baseline
+                });
+            }
+            attributes.frameRate = frameRate;
+            attributes.width = (uint)settings.Width.Value;
+            attributes.height = (uint)settings.Height.Value;
+            attributes.includeAlpha = false;
+            attributes.targetBitRate = bitrate;
+            attributes.bitRateMode = VideoBitrateMode.Medium;
+            return new MediaEncoder(path, attributes);
+        }
+
+        private static void Tick()
+        {
+            var now = EditorApplication.timeSinceStartup;
+            if (s_armed != null)
+            {
+                if (s_armed.Deadline > 0d && now >= s_armed.Deadline)
+                    FailArm("Recording trigger timed out");
+                return;
+            }
+            if (s_encoder == null) { UnsubscribeTick(); return; }
+
+            if ((s_stopAt > 0d && now >= s_stopAt) || (s_hardStopAt > 0d && now >= s_hardStopAt))
+            {
+                s_stopRequested = true;
+                s_state = "finalizing";
+                FinalizeRecording();
+                return;
+            }
+            if (s_stopRequested || now < s_nextCaptureAt) return;
+
+            try
+            {
+                var frameInterval = 1d / s_settings.Fps;
+                if (now - s_nextCaptureAt >= frameInterval)
+                {
+                    var missed = (int)((now - s_nextCaptureAt) / frameInterval);
+                    s_droppedFrames += missed;
+                    s_nextCaptureAt += missed * frameInterval;
+                }
+                RenderFrame();
+                s_nextCaptureAt += frameInterval;
+                EncodeSynchronous();
+            }
+            catch (Exception ex)
+            {
+                FailRecording(ex.Message);
+            }
+        }
+
+        private static void RenderFrame()
+        {
+            var camera = ResolveCamera(s_settings.View);
+            var previousTarget = camera.targetTexture;
+            var previousRect = camera.rect;
+            var previousAspect = camera.aspect;
+            var previousActive = RenderTexture.active;
+            try
+            {
+                RenderTexture.active = s_target;
+                GL.Clear(true, true, Color.black);
+                camera.targetTexture = s_target;
+                camera.aspect = s_settings.SourceAspect;
+                camera.rect = ContainRect(s_settings.SourceAspect,
+                    (float)s_settings.Width.Value / s_settings.Height.Value);
+                camera.Render();
+            }
+            finally
+            {
+                camera.targetTexture = previousTarget;
+                camera.rect = previousRect;
+                camera.aspect = previousAspect;
+                RenderTexture.active = previousActive;
+            }
+        }
+
+        private static void EncodeSynchronous()
+        {
+            var previousActive = RenderTexture.active;
+            try
+            {
+                RenderTexture.active = s_target;
+                s_readback.ReadPixels(new Rect(0, 0, s_readback.width, s_readback.height), 0, 0);
+                s_readback.Apply(false, false);
+                if (!s_encoder.AddFrame(s_readback)) throw new IOException("Native video encoder rejected a frame");
+                s_frameCount++;
+            }
+            finally
+            {
+                RenderTexture.active = previousActive;
+            }
+        }
+
+        private static void FinalizeRecording()
+        {
+            if (s_encoder == null) return;
+            s_state = "finalizing";
+            var elapsed = Math.Max(0d, EditorApplication.timeSinceStartup - s_startedAt);
+            try
+            {
+                var encoder = s_encoder;
+                s_encoder = null;
+                encoder.Dispose();
+                if (File.Exists(s_path))
+                {
+                    if (!s_settings.Overwrite) throw new IOException($"Recording output already exists: {s_path}");
+                    File.Delete(s_path);
+                }
+                File.Move(s_tempPath, s_path);
+                var size = new FileInfo(s_path).Length;
+                s_state = "completed";
+                s_lastResult = Result("completed", elapsed, size);
+            }
+            catch (Exception ex)
+            {
+                s_error = ex.Message;
+                s_state = "failed";
+                s_lastResult = Result("failed", elapsed, 0);
+                TryDeleteTempFile();
+            }
+            finally
+            {
+                DisposeResources();
+                UnsubscribeTick();
+            }
+        }
+
+        private static void FailRecording(string message)
+        {
+            s_error = message;
+            s_state = "failed";
+            try { s_encoder?.Dispose(); } catch { }
+            s_encoder = null;
+            s_lastResult = Result("failed", Math.Max(0d, EditorApplication.timeSinceStartup - s_startedAt), 0);
+            DisposeResources();
+            TryDeleteTempFile();
+            UnsubscribeTick();
+        }
+
+        private static void DisposeResources()
+        {
+            if (s_target != null)
+            {
+                s_target.Release();
+                UnityEngine.Object.DestroyImmediate(s_target);
+            }
+            s_target = null;
+            if (s_readback != null) UnityEngine.Object.DestroyImmediate(s_readback);
+            s_readback = null;
+            s_stopRequested = false;
+        }
+
+        private static void TryDeleteTempFile()
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(s_tempPath) && File.Exists(s_tempPath)) File.Delete(s_tempPath);
+            }
+            catch { }
+        }
+
+        private static Dictionary<string, object> BuildStatus()
+        {
+            if (s_lastResult != null && s_encoder == null && s_armed == null)
+                return new Dictionary<string, object>(s_lastResult);
+            var result = Result(s_state,
+                s_encoder != null ? Math.Max(0d, EditorApplication.timeSinceStartup - s_startedAt) : 0d,
+                0);
+            if (s_armed != null) result["trigger"] = s_armed.Trigger;
+            return result;
+        }
+
+        private static Dictionary<string, object> Result(string state, double elapsed, long size)
+        {
+            var result = new Dictionary<string, object>
+            {
+                ["state"] = state,
+                ["path"] = s_path ?? string.Empty,
+                ["durationSeconds"] = elapsed,
+                ["frames"] = s_frameCount,
+                ["droppedFrames"] = s_droppedFrames,
+                ["size"] = size
+            };
+            if (s_settings != null)
+            {
+                result["view"] = s_settings.View;
+                result["width"] = s_settings.Width ?? 0;
+                result["height"] = s_settings.Height ?? 0;
+                result["fps"] = s_settings.Fps;
+                // Capture cadence and playback rate diverge whenever slowdown is in play, and a
+                // caller needs both: `fps` is what was sampled, `playbackFps` is what the file
+                // declares.
+                result["slowdown"] = s_settings.Slowdown;
+                result["playbackFps"] = s_settings.Slowdown > 0d
+                    ? s_settings.Fps / s_settings.Slowdown
+                    : (double)s_settings.Fps;
+                result["format"] = s_settings.Format;
+                if (s_settings.Format != "auto")
+                    result["codec"] = s_settings.Format == "webm" ? "vp8" : "h264";
+            }
+            if (!string.IsNullOrEmpty(s_error)) result["error"] = s_error;
+            return result;
+        }
+
+        private static RecordingSettings ParseSettings(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>
+                ?? new Dictionary<string, object>();
+            var settings = new RecordingSettings
+            {
+                View = ReadString(p, "view", "game").ToLowerInvariant(),
+                MaxEdge = Mathf.Clamp(ReadInt(p, "maxEdge", 960), 64, 4096),
+                Width = ReadNullableInt(p, "width"),
+                Height = ReadNullableInt(p, "height"),
+                Fps = Mathf.Clamp(ReadInt(p, "fps", 15), 1, 60),
+                Format = ReadString(p, "format", "auto").ToLowerInvariant(),
+                BitrateKbps = Mathf.Clamp(ReadInt(p, "bitrateKbps", 2000), 128, 50000),
+                Overwrite = ReadBool(p, "overwrite", false),
+                Path = ReadString(p, "path", null),
+                Duration = ReadDouble(p, "duration", 0d),
+                MaxDuration = ReadDouble(p, "maxDuration", 60d),
+                Slowdown = ReadDouble(p, "slowdown", 1d)
+            };
+            if (settings.View != "game" && settings.View != "scene")
+                throw new ArgumentException("View must be 'game' or 'scene'");
+            if (settings.Format != "auto" && settings.Format != "mp4" && settings.Format != "webm")
+                throw new ArgumentException("Format must be 'auto', 'mp4', or 'webm'");
+            if (double.IsNaN(settings.Duration) || double.IsInfinity(settings.Duration) || settings.Duration < 0d)
+                throw new ArgumentException("Duration must be zero or greater");
+            if (double.IsNaN(settings.MaxDuration) || double.IsInfinity(settings.MaxDuration) || settings.MaxDuration < 0d)
+                throw new ArgumentException("Max duration must be zero or greater");
+            if (double.IsNaN(settings.Slowdown) || double.IsInfinity(settings.Slowdown)
+                || settings.Slowdown < 1d || settings.Slowdown > 20d)
+                throw new ArgumentException("Slowdown must be between 1 and 20");
+            if (settings.Width.HasValue) settings.Width = MakeEven(Mathf.Clamp(settings.Width.Value, 64, 4096));
+            if (settings.Height.HasValue) settings.Height = MakeEven(Mathf.Clamp(settings.Height.Value, 64, 4096));
+            return settings;
+        }
+
+        private static void ResolveOutputPaths(RecordingSettings settings, out string path, out string tempPath)
+        {
+            var format = settings.Format;
+            var requestedExtension = string.IsNullOrEmpty(settings.Path) ? string.Empty
+                : Path.GetExtension(settings.Path).ToLowerInvariant();
+            if (format == "auto")
+            {
+                if (requestedExtension == ".webm") format = "webm";
+                else if (requestedExtension == ".mp4") format = "mp4";
+                else format = Application.platform == RuntimePlatform.LinuxEditor ? "webm" : "mp4";
+            }
+            var extension = format == "webm" ? ".webm" : ".mp4";
+            if (!string.IsNullOrEmpty(requestedExtension) && requestedExtension != extension)
+                throw new ArgumentException($"Output extension '{requestedExtension}' does not match --format {format}");
+            settings.Format = format;
+            var projectRoot = Path.GetDirectoryName(Application.dataPath);
+            var rawPath = string.IsNullOrEmpty(settings.Path)
+                ? Path.Combine(projectRoot, ".ucp", "recordings", $"recording-{DateTime.UtcNow:yyyyMMdd-HHmmss-fff}{extension}")
+                : settings.Path;
+            if (string.IsNullOrEmpty(Path.GetExtension(rawPath))) rawPath += extension;
+            path = Path.GetFullPath(Path.IsPathRooted(rawPath) ? rawPath : Path.Combine(projectRoot, rawPath));
+            tempPath = Path.Combine(Path.GetDirectoryName(path),
+                Path.GetFileNameWithoutExtension(path) + ".partial" + extension);
+        }
+
+        private static Camera ResolveCamera(string view)
+        {
+            if (view == "scene")
+            {
+                var sceneView = SceneView.lastActiveSceneView;
+                if (sceneView == null || sceneView.camera == null)
+                    throw new InvalidOperationException("No active Scene view is available to record");
+                return sceneView.camera;
+            }
+            var camera = Camera.main;
+#if UNITY_2023_1_OR_NEWER
+            if (camera == null) camera = UnityEngine.Object.FindAnyObjectByType<Camera>();
+#else
+            if (camera == null) camera = UnityEngine.Object.FindObjectOfType<Camera>();
+#endif
+            if (camera == null) throw new InvalidOperationException("No camera is available for Game view recording");
+            return camera;
+        }
+
+        private static float ResolveSourceAspect(Camera camera)
+        {
+            if (camera.pixelWidth > 0 && camera.pixelHeight > 0)
+                return (float)camera.pixelWidth / camera.pixelHeight;
+            return camera.aspect > 0f ? camera.aspect : 16f / 9f;
+        }
+
+        private static (int width, int height) ResolveDimensions(float aspect, int maxEdge, int? width, int? height)
+        {
+            aspect = Mathf.Clamp(aspect, 0.1f, 10f);
+            if (width.HasValue && height.HasValue) return (MakeEven(width.Value), MakeEven(height.Value));
+            if (width.HasValue) return (MakeEven(width.Value), MakeEven(Mathf.RoundToInt(width.Value / aspect)));
+            if (height.HasValue) return (MakeEven(Mathf.RoundToInt(height.Value * aspect)), MakeEven(height.Value));
+            maxEdge = Mathf.Clamp(maxEdge, 64, 4096);
+            return aspect >= 1f
+                ? (MakeEven(maxEdge), MakeEven(Mathf.RoundToInt(maxEdge / aspect)))
+                : (MakeEven(Mathf.RoundToInt(maxEdge * aspect)), MakeEven(maxEdge));
+        }
+
+        private static Rect ContainRect(float sourceAspect, float outputAspect)
+        {
+            if (Mathf.Approximately(sourceAspect, outputAspect)) return new Rect(0f, 0f, 1f, 1f);
+            if (sourceAspect > outputAspect)
+            {
+                var height = outputAspect / sourceAspect;
+                return new Rect(0f, (1f - height) * 0.5f, 1f, height);
+            }
+            var width = sourceAspect / outputAspect;
+            return new Rect((1f - width) * 0.5f, 0f, width, 1f);
+        }
+
+        private static void OnPlayModeStateChanged(PlayModeStateChange state)
+        {
+            if (s_armed == null) return;
+            if (s_armed.Trigger == "play-exit" && state == PlayModeStateChange.EnteredPlayMode)
+            {
+                s_armed.ObservedPlayMode = true;
+                PersistArm();
+            }
+            if ((s_armed.Trigger == "play-enter" && state == PlayModeStateChange.EnteredPlayMode)
+                || (s_armed.Trigger == "play-exit" && s_armed.ObservedPlayMode
+                    && state == PlayModeStateChange.EnteredEditMode))
+                StartArmedRecording();
+        }
+
+        private static void StartArmedRecording()
+        {
+            if (s_armed == null) return;
+            var armed = s_armed;
+            ClearArm();
+            try { StartRecording(armed.Settings); }
+            catch (Exception ex) { s_state = "failed"; s_error = ex.Message; }
+        }
+
+        private static void RestoreArmedRecording()
+        {
+            var json = SessionState.GetString(ArmedSessionKey, string.Empty);
+            if (string.IsNullOrEmpty(json)) return;
+            try
+            {
+                var data = MiniJson.Deserialize(json) as Dictionary<string, object>;
+                s_armed = ArmedRecording.Deserialize(data);
+                s_state = "armed";
+                SubscribeTick();
+                if (s_armed.Trigger == "play-enter" && EditorApplication.isPlaying)
+                    EditorApplication.delayCall += StartArmedRecording;
+                else if (s_armed.Trigger == "play-exit" && EditorApplication.isPlaying)
+                {
+                    s_armed.ObservedPlayMode = true;
+                    PersistArm();
+                }
+                else if (s_armed.Trigger == "play-exit" && s_armed.ObservedPlayMode
+                    && !EditorApplication.isPlayingOrWillChangePlaymode)
+                    EditorApplication.delayCall += StartArmedRecording;
+            }
+            catch { SessionState.EraseString(ArmedSessionKey); }
+        }
+
+        private static void PersistArm()
+        {
+            if (s_armed != null)
+                SessionState.SetString(ArmedSessionKey, MiniJson.Serialize(s_armed.Serialize()));
+        }
+
+        private static void FailArm(string message)
+        {
+            ClearArm();
+            s_state = "failed";
+            s_error = message;
+        }
+
+        private static void ClearArm()
+        {
+            s_armed = null;
+            SessionState.EraseString(ArmedSessionKey);
+            if (s_encoder == null) UnsubscribeTick();
+        }
+
+        private static void SubscribeTick()
+        {
+            EditorApplication.update -= Tick;
+            EditorApplication.update += Tick;
+        }
+
+        private static void UnsubscribeTick() => EditorApplication.update -= Tick;
+        private static int MakeEven(int value) => Mathf.Max(64, value & ~1);
+        private static int ReadInt(Dictionary<string, object> p, string key, int fallback) =>
+            p.TryGetValue(key, out var value) && value != null ? Convert.ToInt32(value) : fallback;
+        private static int? ReadNullableInt(Dictionary<string, object> p, string key) =>
+            p.TryGetValue(key, out var value) && value != null ? Convert.ToInt32(value) : (int?)null;
+        private static double ReadDouble(Dictionary<string, object> p, string key, double fallback) =>
+            p.TryGetValue(key, out var value) && value != null ? Convert.ToDouble(value) : fallback;
+        private static bool ReadBool(Dictionary<string, object> p, string key, bool fallback) =>
+            p.TryGetValue(key, out var value) && value is bool boolean ? boolean : fallback;
+        private static string ReadString(Dictionary<string, object> p, string key, string fallback) =>
+            p.TryGetValue(key, out var value) && value != null ? value.ToString() : fallback;
+        private static bool TryString(Dictionary<string, object> p, string key, out string value)
+        {
+            value = ReadString(p, key, null);
+            return !string.IsNullOrWhiteSpace(value);
+        }
+
+        private sealed class RecordingSettings
+        {
+            public string View;
+            public int MaxEdge;
+            public int? Width;
+            public int? Height;
+            public int Fps;
+            public string Format;
+            public int BitrateKbps;
+            public bool Overwrite;
+            public string Path;
+            public double Duration;
+            public double MaxDuration;
+            public double Slowdown;
+            public float SourceAspect;
+
+            public Dictionary<string, object> Serialize() => new Dictionary<string, object>
+            {
+                ["view"] = View, ["maxEdge"] = MaxEdge, ["width"] = Width, ["height"] = Height,
+                ["fps"] = Fps, ["format"] = Format, ["bitrateKbps"] = BitrateKbps,
+                ["overwrite"] = Overwrite, ["path"] = Path, ["duration"] = Duration,
+                ["maxDuration"] = MaxDuration, ["slowdown"] = Slowdown,
+                ["playbackFps"] = Slowdown > 0d ? Fps / Slowdown : (double)Fps
+            };
+        }
+
+        private sealed class ArmedRecording
+        {
+            public string Trigger;
+            public RecordingSettings Settings;
+            public double Deadline;
+            public Regex LogRegex;
+            public bool ObservedPlayMode;
+
+            public static ArmedRecording Create(string trigger, RecordingSettings settings, double deadline)
+            {
+                var armed = new ArmedRecording
+                {
+                    Trigger = trigger,
+                    Settings = settings,
+                    Deadline = deadline,
+                    ObservedPlayMode = trigger == "play-exit" && EditorApplication.isPlaying
+                };
+                if (trigger.StartsWith("log:", StringComparison.Ordinal))
+                    armed.LogRegex = new Regex(trigger.Substring(4), RegexOptions.IgnoreCase | RegexOptions.CultureInvariant,
+                        TimeSpan.FromMilliseconds(100));
+                else if (trigger != "play-enter" && trigger != "play-exit"
+                    && !trigger.StartsWith("signal:", StringComparison.Ordinal))
+                    throw new ArgumentException("Trigger must be play-enter, play-exit, log:<regex>, or signal:<name>");
+                return armed;
+            }
+
+            public bool MatchesSignal(string name) => Trigger == "signal:" + name;
+            public Dictionary<string, object> Serialize() => new Dictionary<string, object>
+            {
+                ["trigger"] = Trigger, ["deadline"] = Deadline, ["settings"] = Settings.Serialize(),
+                ["observedPlayMode"] = ObservedPlayMode
+            };
+            public static ArmedRecording Deserialize(Dictionary<string, object> data)
+            {
+                var settingsData = data["settings"] as Dictionary<string, object>;
+                var settings = ParseSettings(MiniJson.Serialize(settingsData));
+                var armed = Create(data["trigger"].ToString(), settings, Convert.ToDouble(data["deadline"]));
+                armed.ObservedPlayMode = data.TryGetValue("observedPlayMode", out var observed)
+                    && observed is bool value && value;
+                return armed;
+            }
+        }
+    }
+}

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

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

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

@@ -54,7 +54,10 @@ namespace UCP.Bridge
 
             if (!string.IsNullOrEmpty(filter))
             {
-                executionSettings.filters[0].testNames = new[] { filter };
+                // groupNames is regex-matched against each test's full name, so a bare class or
+                // method name selects what a caller expects. testNames requires an exact
+                // fully-qualified match, which silently selected nothing for "ControllerSmokeTests".
+                executionSettings.filters[0].groupNames = new[] { filter };
             }
 
             var shouldWaitForPlayModeExit =
@@ -208,6 +211,12 @@ namespace UCP.Bridge
                     return;
                 }
 
+                // A filter that matches nothing still yields a root suite -- childless, and named
+                // after the project. Counting it as a leaf reported "1 passed" for a run that
+                // executed no tests, so a typo'd filter looked like a green suite.
+                if (result.Test != null && result.Test.IsSuite)
+                    return;
+
                 string status;
                 switch (result.TestStatus)
                 {

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

@@ -46,6 +46,7 @@ namespace UCP.Bridge.Tests
             PlayModeController.Register(_router);
             ReferenceController.Register(_router);
             LogsController.Register(_router);
+            RecordingController.Register(_router);
             HierarchyController.Register(_router);
             ProfilerController.Register(_router);
             PropertyController.Register(_router);
@@ -72,6 +73,7 @@ namespace UCP.Bridge.Tests
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
             LogsController.ClearHistoryForTests();
+            RecordingController.ResetForTests();
             AssetImportSupport.ClearTestState();
             Profiler.enabled = false;
             Profiler.enableBinaryLog = false;
@@ -97,6 +99,7 @@ namespace UCP.Bridge.Tests
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
             LogsController.ClearHistoryForTests();
+            RecordingController.ResetForTests();
             AssetImportSupport.ClearTestState();
             Profiler.enabled = false;
             Profiler.enableBinaryLog = false;
@@ -123,6 +126,115 @@ namespace UCP.Bridge.Tests
             Assert.That(Convert.ToBoolean(capabilities["sessionControl"]), Is.True);
         }
 
+        [Test]
+        public void RecordingController_RegistersLifecycleMethodsAndReportsIdle()
+        {
+            Assert.That(_router.HasMethod("record/start"), Is.True);
+            Assert.That(_router.HasMethod("record/stop"), Is.True);
+            Assert.That(_router.HasMethod("record/status"), Is.True);
+            Assert.That(_router.HasMethod("record/arm"), Is.True);
+            Assert.That(_router.HasMethod("record/signal"), Is.True);
+
+            var response = _router.Dispatch("record/status", 1, "{}");
+            Assert.That(response.error, Is.Null);
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(result["state"], Is.EqualTo("idle"));
+        }
+
+        [Test]
+        public void RecordingController_ResolvesEvenAspectPreservingDimensions()
+        {
+            Assert.That(RecordingController.ResolveDimensionsForTests(16f / 9f, 960, null, null),
+                Is.EqualTo((960, 540)));
+            Assert.That(RecordingController.ResolveDimensionsForTests(9f / 16f, 960, null, null),
+                Is.EqualTo((540, 960)));
+            Assert.That(RecordingController.ResolveDimensionsForTests(4f / 3f, 960, 640, null),
+                Is.EqualTo((640, 480)));
+            Assert.That(RecordingController.ResolveDimensionsForTests(4f / 3f, 960, null, 600),
+                Is.EqualTo((800, 600)));
+        }
+
+        [Test]
+        public void RecordingController_ArmsAndMatchesNamedSignal()
+        {
+            var response = _router.Dispatch(
+                "record/arm",
+                1,
+                "{\"trigger\":\"signal:not-this-one\",\"duration\":1,\"timeout\":5}");
+            Assert.That(response.error, Is.Null);
+
+            var signal = _router.Dispatch("record/signal", 2, "{\"name\":\"different\"}");
+            Assert.That(signal.error, Is.Null);
+            var result = (Dictionary<string, object>)signal.result;
+            Assert.That(Convert.ToBoolean(result["matched"]), Is.False);
+            Assert.That(result["state"], Is.EqualTo("armed"));
+
+            var stop = _router.Dispatch("record/stop", 3, "{}");
+            Assert.That(stop.error, Is.Null);
+            var stopped = (Dictionary<string, object>)stop.result;
+            Assert.That(stopped["state"], Is.EqualTo("idle"));
+        }
+
+        [Test]
+        public void GetProperty_ReturnsCompositeValuesRatherThanTypeNames()
+        {
+            // Regression: when SerializedObject.FindProperty resolves a name, the value it returns
+            // is already JSON-shaped. That result used to be converted a second time, match no
+            // case, and fall through to value.ToString() -- so a Vector3 arrived as
+            // "System.Collections.Generic.List`1[System.Object]". Querying the serialized name
+            // (m_LocalPosition) is what forces the FindProperty path; the public alias (position)
+            // has no serialized entry and takes the reflection fallback instead, which is why that
+            // one never looked broken.
+            var go = new GameObject("UcpPropertyProbe");
+            try
+            {
+                go.transform.localPosition = new Vector3(1.5f, 2.5f, 3.5f);
+                var id = go.GetInstanceID();
+
+                var serialized = _router.Dispatch("object/get-property", 1, "{\"instanceId\":ID,\"component\":\"Transform\",\"property\":\"m_LocalPosition\"}".Replace("ID", id.ToString()));
+                Assert.That(serialized.error, Is.Null);
+                var serializedResult = (Dictionary<string, object>)serialized.result;
+                var localPosition = serializedResult["value"] as IList;
+                Assert.That(localPosition, Is.Not.Null,
+                    "a serialized Vector3 must come back as an array, not a stringified type name");
+                Assert.That(localPosition.Count, Is.EqualTo(3));
+                Assert.That(Convert.ToDouble(localPosition[0]), Is.EqualTo(1.5d).Within(1e-4));
+                Assert.That(Convert.ToDouble(localPosition[2]), Is.EqualTo(3.5d).Within(1e-4));
+                Assert.That(serializedResult["type"], Is.EqualTo("Vector3"),
+                    "type must describe the field, not the container it was shaped into");
+
+                // Reflection fallback: no serialized entry named "position".
+                var reflected = _router.Dispatch("object/get-property", 2, "{\"instanceId\":ID,\"component\":\"Transform\",\"property\":\"position\"}".Replace("ID", id.ToString()));
+                Assert.That(reflected.error, Is.Null);
+                var reflectedResult = (Dictionary<string, object>)reflected.result;
+                Assert.That(reflectedResult["value"] as IList, Is.Not.Null);
+                Assert.That(reflectedResult["type"], Is.EqualTo("Vector3"));
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(go);
+            }
+        }
+
+        [Test]
+        public void RecordingController_ValidatesSlowdownRange()
+        {
+            // --slowdown exists to raise effective temporal resolution for models that sample a
+            // clip at a fixed low rate, so an out-of-range factor must fail loudly rather than
+            // silently producing a file whose playback rate is meaningless.
+            var tooLarge = _router.Dispatch("record/arm", 1, "{\"trigger\":\"signal:sd\",\"duration\":1,\"timeout\":5,\"slowdown\":40}");
+            Assert.That(tooLarge.error, Is.Not.Null, "a slowdown above the supported range must be rejected");
+
+            var accepted = _router.Dispatch("record/arm", 2, "{\"trigger\":\"signal:sd\",\"duration\":1,\"timeout\":5,\"slowdown\":6}");
+            Assert.That(accepted.error, Is.Null);
+            var armed = (Dictionary<string, object>)accepted.result;
+            Assert.That(armed["state"], Is.EqualTo("armed"));
+
+            var stop = _router.Dispatch("record/stop", 3, "{}");
+            Assert.That(stop.error, Is.Null);
+            Assert.That(((Dictionary<string, object>)stop.result)["state"], Is.EqualTo("idle"));
+        }
+
         [Test]
         public void ProfilerSessionStartStop_TogglesProfilerState()
         {
@@ -1647,4 +1759,5 @@ namespace UCP.Bridge.Tests
             public SearchRootAsset referenceAsset;
         }
     }
+
 }

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

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

package/package.json

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