@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Tools/graphics/bake-start.cs

@@ -0,0 +1,27 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    /// <summary>graphics.bake-start — 异步启动光照烘焙。</summary>
+    public class GraphicsBakeStartTool : IUnityCliTool<GraphicsBakeStartTool.Request, GraphicsBakeStartTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public bool Baking { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.bake-start", Summary = "Start asynchronous lightmap baking.", Description = "Start Lightmapping.BakeAsync. Returns error if a bake is already running.", Group = "graphics",DestructiveHint = true, SideEffects = new[] { "bake" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Start baking", Input = new Request { } } } };
+        public async System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (Lightmapping.isRunning) throw new UnityCliBridge.BridgeCommandException("E_BAKE_ALREADY_RUNNING", "Lightmapping bake is already running.", "Run tools run graphics.bake-status to inspect progress or graphics.bake-cancel to stop it.");
+            ctx.CommitEffect();
+            Lightmapping.BakeAsync();
+            var observed = await ctx.Wait.UntilStable(() => Lightmapping.isRunning, System.TimeSpan.FromMilliseconds(ctx.TimeoutMs), ct: ct);
+            if (!observed) throw new UnityCliBridge.BridgeCommandException("E_BAKE_START_TIMEOUT", "Lightmapping did not enter the baking state before timeout.", "Check Lighting settings and Unity Console, then retry.");
+            var baking = Lightmapping.isRunning;
+            return new Result { Baking = baking, PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.bake-start", Property = "bake", Value = "async" } } };
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/bake-status.cs

@@ -0,0 +1,31 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    /// <summary>graphics.bake-status — 读取光照烘焙状态。</summary>
+    public class GraphicsBakeStatusTool : IUnityCliTool<GraphicsBakeStatusTool.Request, GraphicsBakeStatusTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public bool Baking { get; set; } public double Progress { get; set; } public BakeModeInfo Mode { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.bake-status", Summary = "Read lightmap baking progress and mode.", Description = "Read-only: returns baking state, progress (0-1), and lighting mode.", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Check bake status", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+#if UNITY_2023_2_OR_NEWER
+            var progress = Lightmapping.bakeProgress;
+            var mode = Lightmapping.lightingMode;
+            var modeStr = mode == LightingMode.Baked ? "baked" : mode == LightingMode.Mixed ? "mixed" : mode == LightingMode.Realtime ? "realtime" : mode.ToString();
+#else
+            var progress = Lightmapping.buildProgress;
+            var modeStr = "unknown";
+            var ls = Lightmapping.GetLightingSettingsForScene(SceneManager.GetActiveScene());
+            if (ls != null) modeStr = ls.mixedBakeMode.ToString();
+#endif
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Baking = Lightmapping.isRunning, Progress = progress, Mode = new BakeModeInfo { LightingMode = modeStr, GiWorkflowMode = (long)Lightmapping.giWorkflowMode } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/light-probe-group.cs

@@ -0,0 +1,56 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.light-probe-group — 管理 LightProbeGroup 组件与探针位置。</summary>
+    public class GraphicsLightProbeGroupTool : IUnityCliTool<GraphicsLightProbeGroupTool.Request, GraphicsLightProbeGroupTool.Result>
+    {
+        public sealed class Request { public string Target { get; set; } public bool? Create { get; set; } public string Positions { get; set; } }
+        public sealed class Result { public long ProbeCount { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.light-probe-group", Summary = "Add, configure, or read a LightProbeGroup component on a target.", Description = "Resolve a target GameObject, optionally create a LightProbeGroup, and set probe positions from a space-separated vector array.", Group = "graphics",DestructiveHint = false, SideEffects = new[] { "scene-modify" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read light probe group", Input = new Request { Target = "LightProbes" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var createdObject = string.IsNullOrEmpty(r.Target);
+            if (createdObject && r.Create != true)
+                throw new UnityCliBridge.BridgeCommandException("E_LIGHT_PROBE_GROUP_TARGET_REQUIRED", "graphics.light-probe-group requires target unless create is true.", "Pass a target or set create=true.");
+            var go = createdObject ? null : GameObjectToolSupport.ResolveUniqueTarget(r.Target, "graphics.light-probe-group requires --target or create a new one.");
+            var positions = string.IsNullOrEmpty(r.Positions) ? null : GraphicsToolSupport.ParseVector3Array(r.Positions);
+            var probe = go == null ? null : go.GetComponent<LightProbeGroup>();
+            if (!createdObject && probe == null && r.Create != true)
+                throw new UnityCliBridge.BridgeCommandException("E_LIGHT_PROBE_GROUP_NOT_FOUND", "LightProbeGroup component not found on target: " + GameObjectToolSupport.HierarchyPath(go), "Pass --create to add one or choose a target with LightProbeGroup.");
+            var addComponent = probe == null;
+            var mutates = createdObject || addComponent || positions != null;
+            if (mutates)
+            {
+                ctx.CommitEffect();
+                if (createdObject)
+                {
+                    go = new GameObject("LightProbeGroup");
+                    UnityCliSceneMutation.RegisterCreatedObject(go, "Create LightProbeGroup");
+                }
+                if (addComponent) probe = UnityCliSceneMutation.AddComponent<LightProbeGroup>(go);
+            }
+            var effects = new List<GraphicsPlannedEffect>();
+            if (addComponent) effects.Add(new GraphicsPlannedEffect { Type = "graphics.light-probe-group", Property = "component", Value = "added" });
+            if (positions != null) { UnityCliSceneMutation.RecordObject(probe, "Set light probe positions"); probe.probePositions = positions; effects.Add(new GraphicsPlannedEffect { Type = "graphics.light-probe-group", Property = "probePositions", Value = positions.Length.ToString() }); }
+            if (mutates) { UnityCliSceneMutation.MarkSceneObjectDirty(probe); UnityCliSceneMutation.MarkSceneDirty(go.scene); }
+            var observedObject = GameObjectToolSupport.ResolveUniqueTarget(go.GetInstanceID().ToString(CultureInfo.InvariantCulture), "LightProbeGroup could not be re-resolved after mutation.");
+            var observedProbe = observedObject.GetComponent<LightProbeGroup>();
+            var observedPositions = observedProbe == null ? null : observedProbe.probePositions;
+            if (observedProbe == null || (positions != null && !SamePositions(observedPositions, positions))) throw new UnityCliBridge.BridgeCommandException("E_LIGHT_PROBE_GROUP_STATE_MISMATCH", "LightProbeGroup probe positions did not retain the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { ProbeCount = observedPositions == null ? 0 : observedPositions.Length, PlannedEffects = effects });
+        }
+        private static bool SamePositions(Vector3[] actual, Vector3[] expected)
+        {
+            if (actual == null || actual.Length != expected.Length) return false;
+            for (var index = 0; index < expected.Length; index++) if (actual[index] != expected[index]) return false;
+            return true;
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/pipeline-info.cs

@@ -0,0 +1,19 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.pipeline-info — 读取渲染管线摘要与 QualitySettings(只读)。</summary>
+    public class GraphicsPipelineInfoTool : IUnityCliTool<GraphicsPipelineInfoTool.Request, GraphicsPipelineInfoTool.Result>
+    {
+        public sealed class Request { }
+        public sealed class Result { public GraphicsSummary Graphics { get; set; } public QualitySettingsInfo QualitySettings { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.pipeline-info", Summary = "Read the active render pipeline asset and quality settings.", Description = "Read-only: returns render pipeline summary and current QualitySettings.", Group = "graphics",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read pipeline info", Input = new Request { } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default) => new System.Threading.Tasks.ValueTask<Result>(new Result { Graphics = GraphicsToolSupport.BuildGraphicsSummary(), QualitySettings = GraphicsToolSupport.BuildQualitySettings() });
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/pipeline-quality.cs

@@ -0,0 +1,24 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+namespace UnityCli
+{
+    public class GraphicsPipelineQualityTool : IUnityCliTool<GraphicsPipelineQualityTool.Request, GraphicsPipelineQualityTool.Result>
+    {
+        public sealed class Request { public string QualityLevel { get; set; } }
+        public sealed class Result { public QualitySettingsInfo QualitySettings { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.pipeline-quality", Summary = "Set the active quality level by name or index.", Description = "Set QualitySettings quality level.", Group = "graphics",DestructiveHint = true, SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Select a quality level by name", Input = new Request { QualityLevel = "Medium" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (string.IsNullOrEmpty(r.QualityLevel)) return new System.Threading.Tasks.ValueTask<Result>(new Result { QualitySettings = GraphicsToolSupport.BuildQualitySettings(), PlannedEffects = new List<GraphicsPlannedEffect>() });
+            var level = GraphicsToolSupport.ResolveQualityLevel(r.QualityLevel); // immutable validated plan
+            ctx.CommitEffect();
+            QualitySettings.SetQualityLevel(level, true);
+            AssetDatabase.SaveAssets();
+            if (QualitySettings.GetQualityLevel() != level) throw new UnityCliBridge.BridgeCommandException("E_PIPELINE_QUALITY_STATE_MISMATCH", "Quality level readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { QualitySettings = GraphicsToolSupport.BuildQualitySettings(), PlannedEffects = new List<GraphicsPlannedEffect> { new GraphicsPlannedEffect { Type = "graphics.pipeline-quality", Property = "qualityLevel", Value = level.ToString() } } });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/pipeline-settings.cs

@@ -0,0 +1,46 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.pipeline-settings — 设置 GraphicsSettings.defaultRenderPipeline。</summary>
+    public class GraphicsPipelineSettingsTool : IUnityCliTool<GraphicsPipelineSettingsTool.Request, GraphicsPipelineSettingsTool.Result>
+    {
+        public sealed class Request { public string RenderPipeline { get; set; } }
+        public sealed class Result { public GraphicsSummary Graphics { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.pipeline-settings", Summary = "Set the default render pipeline asset for the project.", Description = "Set GraphicsSettings.defaultRenderPipeline. Pass 'built-in' or 'null' to reset to built-in.", Group = "graphics",DestructiveHint = true, SideEffects = new[] { "settings-write" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Set URP pipeline", Input = new Request { RenderPipeline = "Assets/Settings/URP.asset" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var effects = new List<GraphicsPlannedEffect>();
+            if (string.IsNullOrEmpty(r.RenderPipeline))
+            {
+                return new System.Threading.Tasks.ValueTask<Result>(new Result { Graphics = GraphicsToolSupport.BuildGraphicsSummary(), PlannedEffects = effects });
+            }
+
+            var resetToBuiltIn = string.Equals(r.RenderPipeline, "null", StringComparison.OrdinalIgnoreCase) || string.Equals(r.RenderPipeline, "built-in", StringComparison.OrdinalIgnoreCase);
+            var pipelinePath = resetToBuiltIn ? null : GraphicsToolSupport.NormalizeAssetPathRequired(r.RenderPipeline, ".asset");
+            var pipelineGuid = resetToBuiltIn ? null : AssetDatabase.AssetPathToGUID(pipelinePath);
+            var pipeline = resetToBuiltIn ? null : AssetDatabase.LoadAssetAtPath<RenderPipelineAsset>(pipelinePath);
+            if (!resetToBuiltIn && (pipeline == null || string.IsNullOrEmpty(pipelineGuid)))
+                throw new UnityCliBridge.BridgeCommandException("E_RENDER_PIPELINE_NOT_FOUND", "RenderPipelineAsset not found: " + r.RenderPipeline, "Pass an imported Assets/*.asset RenderPipelineAsset path or use --render-pipeline built-in.");
+
+            ctx.CommitEffect();
+            GraphicsSettings.defaultRenderPipeline = pipeline;
+            AssetDatabase.SaveAssets();
+            if (!resetToBuiltIn) AssetDatabase.ImportAsset(pipelinePath, ImportAssetOptions.ForceUpdate);
+            var reloadedPipeline = resetToBuiltIn ? null : GraphicsToolSupport.ReloadAsset<RenderPipelineAsset>(pipelinePath, pipelineGuid);
+            var observedPipeline = GraphicsSettings.defaultRenderPipeline;
+            if ((resetToBuiltIn && observedPipeline != null) || (!resetToBuiltIn && (reloadedPipeline == null || observedPipeline != reloadedPipeline)))
+                throw new UnityCliBridge.BridgeCommandException("E_RENDER_PIPELINE_STATE_MISMATCH", "GraphicsSettings.defaultRenderPipeline did not match the requested asset after path/GUID reload.", "Check Unity Console diagnostics and retry after the editor is idle.");
+
+            effects.Add(new GraphicsPlannedEffect { Type = "graphics.pipeline-settings", Property = "renderPipeline", Value = resetToBuiltIn ? "built-in" : pipelinePath });
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Graphics = GraphicsToolSupport.BuildGraphicsSummary(), PlannedEffects = effects });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/probe-positions.cs

@@ -0,0 +1,58 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.probe-positions — 读取/写入探针位置(ReflectionProbe 或 LightProbeGroup)。</summary>
+    public class GraphicsProbePositionsTool : IUnityCliTool<GraphicsProbePositionsTool.Request, GraphicsProbePositionsTool.Result>
+    {
+        public sealed class Request { public string Target { get; set; } public string Type { get; set; } public string Positions { get; set; } }
+        public sealed class Result { public string ProbeType { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.probe-positions", Summary = "Read or update probe positions for a ReflectionProbe or LightProbeGroup.", Description = "Resolve a probe component by type (reflection or light), then optionally set positions.", Group = "graphics",DestructiveHint = false, SideEffects = new[] { "scene-modify" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read probe positions", Input = new Request { Target = "Probes" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var probeType = r.Type ?? "reflection";
+            var reflection = string.Equals(probeType, "reflection", System.StringComparison.OrdinalIgnoreCase);
+            var light = string.Equals(probeType, "light", System.StringComparison.OrdinalIgnoreCase);
+            if (!reflection && !light) throw new UnityCliBridge.BridgeCommandException("E_PROBE_TYPE_INVALID", "Unsupported probe type: " + probeType, "Pass reflection or light.");
+            Component component = reflection ? (Component)PhysicsToolSupport.ResolveReflectionProbe(r.Target) : ResolveLightProbeGroup(r.Target);
+            if (component == null) throw new UnityCliBridge.BridgeCommandException("E_PROBE_NOT_FOUND", "Probe component not found: " + r.Target + " (type=" + probeType + ")", "Pass a GameObject name / hierarchy path with a ReflectionProbe or LightProbeGroup component.");
+            var effects = new List<GraphicsPlannedEffect>();
+            if (!string.IsNullOrEmpty(r.Positions))
+            {
+                var positions = GraphicsToolSupport.ParseVector3Array(r.Positions);
+                if (reflection && positions.Length != 1) throw new UnityCliBridge.BridgeCommandException("E_PROBE_POSITIONS_INVALID", "ReflectionProbe requires exactly one position.", "Pass one x,y,z position.");
+                ctx.CommitEffect();
+                UnityCliSceneMutation.RecordObject(component, "Set probe positions");
+                if (component is ReflectionProbe rp) { rp.center = positions.Length > 0 ? positions[0] : rp.center; effects.Add(new GraphicsPlannedEffect { Type = "graphics.probe-positions", Property = "reflectionCenter", Value = positions.Length.ToString() }); }
+                else if (component is LightProbeGroup lpg) { lpg.probePositions = positions; effects.Add(new GraphicsPlannedEffect { Type = "graphics.probe-positions", Property = "lightProbePositions", Value = positions.Length.ToString() }); }
+                UnityCliSceneMutation.MarkSceneObjectDirty(component);
+                UnityCliSceneMutation.MarkSceneDirty(component.gameObject.scene);
+                var observedObject = GameObjectToolSupport.ResolveUniqueTarget(component.gameObject.GetInstanceID().ToString(CultureInfo.InvariantCulture), "Probe target could not be re-resolved after mutation.");
+                var observedComponent = string.Equals(probeType, "reflection", System.StringComparison.OrdinalIgnoreCase) ? (Component)observedObject.GetComponent<ReflectionProbe>() : observedObject.GetComponent<LightProbeGroup>();
+                if (observedComponent == null || (observedComponent is ReflectionProbe observedReflection && (positions.Length == 0 || observedReflection.center != positions[0])) || (observedComponent is LightProbeGroup observedLight && !SamePositions(observedLight.probePositions, positions))) throw new UnityCliBridge.BridgeCommandException("E_PROBE_STATE_MISMATCH", "Probe positions did not retain the request.", "Retry after the editor is idle.");
+                component = observedComponent;
+            }
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { ProbeType = probeType, PlannedEffects = effects });
+        }
+        private static bool SamePositions(Vector3[] actual, Vector3[] expected)
+        {
+            if (actual == null || actual.Length != expected.Length) return false;
+            for (var index = 0; index < expected.Length; index++) if (actual[index] != expected[index]) return false;
+            return true;
+        }
+
+        private static LightProbeGroup ResolveLightProbeGroup(string target)
+        {
+            var groups = UnityEngine.Object.FindObjectsOfType<LightProbeGroup>();
+            if (string.IsNullOrEmpty(target)) return groups.Length > 0 ? groups[0] : null;
+            foreach (var g in groups) if (GameObjectToolSupport.HierarchyPath(g.gameObject) == target || g.gameObject.name == target || g.GetInstanceID().ToString() == target) return g;
+            return null;
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/quality.cs

@@ -0,0 +1,85 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// graphics.quality — 读取/写入 QualitySettings(qualityLevel/vSync/antiAliasing/shadowDistance 等)。
+    /// </summary>
+    public class GraphicsQualityTool : IUnityCliTool<GraphicsQualityTool.Request, GraphicsQualityTool.Result>
+    {
+        public sealed class Request
+        {
+            public string QualityLevel { get; set; }
+            public int? VSyncCount { get; set; }
+            public int? AntiAliasing { get; set; }
+            public float? ShadowDistance { get; set; }
+            public int? MasterTextureLimit { get; set; }
+            public float? LodBias { get; set; }
+            public int? MaximumLODLevel { get; set; }
+            public string AnisotropicFiltering { get; set; }
+            public string Shadows { get; set; }
+            public string ShadowResolution { get; set; }
+            public bool? RealtimeReflectionProbes { get; set; }
+            public bool? SoftParticles { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public GraphicsSummary Graphics { get; set; }
+            public QualitySettingsInfo QualitySettings { get; set; }
+            public List<GraphicsPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "graphics.quality", Summary = "Read and update Unity QualitySettings (quality level, vSync, anti-aliasing, shadows, LOD).",
+            Description = "Read or update QualitySettings. Pass qualityLevel (name or index) and individual settings to update; omit all to read current values.",
+            Group = "graphics",DestructiveHint = true, SideEffects = new[] { "settings-write" },
+            Target = "editor", PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000,
+            Examples = new[] { new ToolExample { Description = "Read quality settings", Input = new Request { } } }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var effects = new List<GraphicsPlannedEffect>();
+            var level = string.IsNullOrEmpty(request.QualityLevel) ? (int?)null : GraphicsToolSupport.ResolveQualityLevel(request.QualityLevel);
+            var anisotropic = string.IsNullOrEmpty(request.AnisotropicFiltering) ? (AnisotropicFiltering?)null : GraphicsToolSupport.ParseEnum<AnisotropicFiltering>(request.AnisotropicFiltering, "anisotropicFiltering");
+            var shadows = string.IsNullOrEmpty(request.Shadows) ? (ShadowQuality?)null : GraphicsToolSupport.ParseEnum<ShadowQuality>(request.Shadows, "shadows");
+            var shadowResolution = string.IsNullOrEmpty(request.ShadowResolution) ? (ShadowResolution?)null : GraphicsToolSupport.ParseEnum<ShadowResolution>(request.ShadowResolution, "shadowResolution");
+            if (request.ShadowDistance.HasValue) GraphicsToolSupport.ParseFinite(request.ShadowDistance.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "shadowDistance", 0f, float.MaxValue);
+            if (request.LodBias.HasValue) GraphicsToolSupport.ParseFinite(request.LodBias.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "lodBias", 0.01f, 100f);
+            if (request.VSyncCount.HasValue && (request.VSyncCount.Value < 0 || request.VSyncCount.Value > 4)) throw new UnityCliBridge.BridgeCommandException("E_QUALITY_RANGE_INVALID", "vSyncCount must be from 0 to 4.", "Pass a vSyncCount from 0 to 4.");
+            if (request.AntiAliasing.HasValue && request.AntiAliasing.Value != 0 && request.AntiAliasing.Value != 2 && request.AntiAliasing.Value != 4 && request.AntiAliasing.Value != 8) throw new UnityCliBridge.BridgeCommandException("E_QUALITY_RANGE_INVALID", "antiAliasing must be 0, 2, 4, or 8.", "Pass a supported antiAliasing value.");
+            if (request.MasterTextureLimit.HasValue && !GraphicsToolSupport.IsValidTextureLod(request.MasterTextureLimit.Value)) throw new UnityCliBridge.BridgeCommandException("E_QUALITY_RANGE_INVALID", "masterTextureLimit must be from 0 to 8.", "Pass a masterTextureLimit from 0 to 8.");
+            if (request.MaximumLODLevel.HasValue && !GraphicsToolSupport.IsValidMaximumLod(request.MaximumLODLevel.Value)) throw new UnityCliBridge.BridgeCommandException("E_QUALITY_RANGE_INVALID", "maximumLODLevel must be from 0 to 100000.", "Pass a non-negative maximumLODLevel.");
+            var hasWrite = level.HasValue || request.VSyncCount.HasValue || request.AntiAliasing.HasValue || request.ShadowDistance.HasValue || request.MasterTextureLimit.HasValue || request.LodBias.HasValue || request.MaximumLODLevel.HasValue || anisotropic.HasValue || shadows.HasValue || shadowResolution.HasValue || request.RealtimeReflectionProbes.HasValue || request.SoftParticles.HasValue;
+            if (hasWrite) ctx.CommitEffect();
+            if (level.HasValue)
+            {
+                QualitySettings.SetQualityLevel(level.Value, true);
+                effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "qualityLevel", Value = level.Value.ToString() });
+            }
+            if (request.VSyncCount.HasValue) { QualitySettings.vSyncCount = request.VSyncCount.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "vSyncCount", Value = request.VSyncCount.Value.ToString() }); }
+            if (request.AntiAliasing.HasValue) { QualitySettings.antiAliasing = request.AntiAliasing.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "antiAliasing", Value = request.AntiAliasing.Value.ToString() }); }
+            if (request.ShadowDistance.HasValue) { QualitySettings.shadowDistance = request.ShadowDistance.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "shadowDistance", Value = request.ShadowDistance.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) }); }
+            if (request.MasterTextureLimit.HasValue) { QualitySettings.globalTextureMipmapLimit = request.MasterTextureLimit.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "masterTextureLimit", Value = request.MasterTextureLimit.Value.ToString() }); }
+            if (request.LodBias.HasValue) { QualitySettings.lodBias = request.LodBias.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "lodBias", Value = request.LodBias.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) }); }
+            if (request.MaximumLODLevel.HasValue) { QualitySettings.maximumLODLevel = request.MaximumLODLevel.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "maximumLODLevel", Value = request.MaximumLODLevel.Value.ToString() }); }
+            if (anisotropic.HasValue) { QualitySettings.anisotropicFiltering = anisotropic.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "anisotropicFiltering", Value = request.AnisotropicFiltering }); }
+            if (shadows.HasValue) { QualitySettings.shadows = shadows.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "shadows", Value = request.Shadows }); }
+            if (shadowResolution.HasValue) { QualitySettings.shadowResolution = shadowResolution.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "shadowResolution", Value = request.ShadowResolution }); }
+            if (request.RealtimeReflectionProbes.HasValue) { QualitySettings.realtimeReflectionProbes = request.RealtimeReflectionProbes.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "realtimeReflectionProbes", Value = request.RealtimeReflectionProbes.Value.ToString().ToLowerInvariant() }); }
+            if (request.SoftParticles.HasValue) { QualitySettings.softParticles = request.SoftParticles.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.quality", Property = "softParticles", Value = request.SoftParticles.Value.ToString().ToLowerInvariant() }); }
+            if (effects.Count > 0) AssetDatabase.SaveAssets();
+            var observed = GraphicsToolSupport.BuildQualitySettings();
+            if ((level.HasValue && observed.CurrentLevel != level.Value) || (request.VSyncCount.HasValue && observed.VSyncCount != request.VSyncCount.Value) || (request.AntiAliasing.HasValue && observed.AntiAliasing != request.AntiAliasing.Value) || (request.ShadowDistance.HasValue && !Mathf.Approximately((float)observed.ShadowDistance, request.ShadowDistance.Value)) || (request.MasterTextureLimit.HasValue && observed.MasterTextureLimit != request.MasterTextureLimit.Value) || (request.LodBias.HasValue && !Mathf.Approximately((float)observed.LodBias, request.LodBias.Value)) || (request.MaximumLODLevel.HasValue && observed.MaximumLODLevel != request.MaximumLODLevel.Value) || (anisotropic.HasValue && observed.AnisotropicFiltering != anisotropic.Value.ToString()) || (shadows.HasValue && observed.Shadows != shadows.Value.ToString()) || (shadowResolution.HasValue && observed.ShadowResolution != shadowResolution.Value.ToString()) || (request.RealtimeReflectionProbes.HasValue && observed.RealtimeReflectionProbes != request.RealtimeReflectionProbes.Value) || (request.SoftParticles.HasValue && observed.SoftParticles != request.SoftParticles.Value)) throw new UnityCliBridge.BridgeCommandException("E_QUALITY_STATE_MISMATCH", "Quality settings readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Graphics = GraphicsToolSupport.BuildGraphicsSummary(), QualitySettings = observed, PlannedEffects = effects });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/reflection-probe.cs

@@ -0,0 +1,73 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>graphics.reflection-probe — 管理 ReflectionProbe 组件。</summary>
+    public class GraphicsReflectionProbeTool : IUnityCliTool<GraphicsReflectionProbeTool.Request, GraphicsReflectionProbeTool.Result>
+    {
+        public sealed class Request { public string Target { get; set; } public bool? Create { get; set; } public string Mode { get; set; } public int? Resolution { get; set; } public int? Bounces { get; set; } public bool? Hdr { get; set; } public string BoxSize { get; set; } public string BoxOffset { get; set; } }
+        public sealed class Result { public ReflectionProbeInfo Probe { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.reflection-probe", Summary = "Add, configure, or read a ReflectionProbe component on a target.", Description = "Resolve a target GameObject, optionally create a ReflectionProbe, and configure mode/resolution/bounces/hdr/boxSize/boxOffset.", Group = "graphics",DestructiveHint = false, SideEffects = new[] { "scene-modify" }, Target = "editor", PlayModeSupport = "supported", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Read reflection probe", Input = new Request { Target = "ReflectionProbe" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var createdObject = string.IsNullOrEmpty(r.Target);
+            if (createdObject && r.Create != true)
+                throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_TARGET_REQUIRED", "graphics.reflection-probe requires target unless create is true.", "Pass a target or set create=true.");
+            var go = createdObject ? null : GameObjectToolSupport.ResolveUniqueTarget(r.Target, "graphics.reflection-probe requires --target or create a new one.");
+            var mode = default(UnityEngine.Rendering.ReflectionProbeMode);
+            var hasMode = !string.IsNullOrEmpty(r.Mode);
+            if (hasMode && (!Enum.TryParse<UnityEngine.Rendering.ReflectionProbeMode>(r.Mode, true, out mode) || !Enum.IsDefined(typeof(UnityEngine.Rendering.ReflectionProbeMode), mode)))
+                throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_MODE_INVALID", "Unsupported ReflectionProbe mode: " + r.Mode, "Pass a valid ReflectionProbeMode enum value.");
+            if (r.Resolution.HasValue && (r.Resolution.Value < 16 || r.Resolution.Value > 8192 || (r.Resolution.Value & (r.Resolution.Value - 1)) != 0)) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_RESOLUTION_INVALID", "ReflectionProbe resolution must be a power of two from 16 to 8192.", "Pass 16, 32, 64, ..., or 8192.");
+            if (r.Bounces.HasValue && (r.Bounces.Value < 0 || r.Bounces.Value > 100)) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_BOUNCES_INVALID", "ReflectionProbe bounces must be from 0 to 100.", "Pass a non-negative supported bounce count.");
+            var boxSize = string.IsNullOrEmpty(r.BoxSize) ? (Vector3?)null : GameObjectToolSupport.ParseVector3(r.BoxSize);
+            var boxOffset = string.IsNullOrEmpty(r.BoxOffset) ? (Vector3?)null : GameObjectToolSupport.ParseVector3(r.BoxOffset);
+            var probe = go == null ? null : go.GetComponent<ReflectionProbe>();
+            if (!createdObject && probe == null && r.Create != true)
+                throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_NOT_FOUND", "ReflectionProbe component not found on target: " + GameObjectToolSupport.HierarchyPath(go), "Pass --create to add one or choose a target with ReflectionProbe.");
+            var addComponent = probe == null;
+            var mutates = createdObject || addComponent || hasMode || r.Resolution.HasValue || r.Bounces.HasValue || r.Hdr.HasValue || boxSize.HasValue || boxOffset.HasValue;
+            if (mutates)
+            {
+                ctx.CommitEffect();
+                if (createdObject)
+                {
+                    go = new GameObject("ReflectionProbe");
+                    UnityCliSceneMutation.RegisterCreatedObject(go, "Create ReflectionProbe");
+                }
+                if (addComponent) probe = UnityCliSceneMutation.AddComponent<ReflectionProbe>(go);
+            }
+            var effects = new List<GraphicsPlannedEffect>();
+            if (addComponent) effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "component", Value = "added" });
+            if (mutates) UnityCliSceneMutation.RecordObject(probe, "Configure ReflectionProbe");
+            if (hasMode) { probe.mode = mode; effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "mode", Value = probe.mode.ToString() }); }
+            if (r.Resolution.HasValue) { probe.resolution = r.Resolution.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "resolution", Value = probe.resolution.ToString() }); }
+            if (r.Bounces.HasValue) { SetBounces(probe, r.Bounces.Value); effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "bounces", Value = r.Bounces.Value.ToString() }); }
+            if (r.Hdr.HasValue) { probe.hdr = r.Hdr.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "hdr", Value = probe.hdr.ToString().ToLowerInvariant() }); }
+            if (boxSize.HasValue) { probe.size = boxSize.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "boxSize", Value = probe.size.ToString() }); }
+            if (boxOffset.HasValue) { probe.center = boxOffset.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.reflection-probe", Property = "boxOffset", Value = probe.center.ToString() }); }
+            if (mutates) { UnityCliSceneMutation.MarkSceneObjectDirty(probe); UnityCliSceneMutation.MarkSceneDirty(go.scene); }
+            var observedObject = GameObjectToolSupport.ResolveUniqueTarget(go.GetInstanceID().ToString(CultureInfo.InvariantCulture), "ReflectionProbe could not be re-resolved after mutation.");
+            var observedProbe = observedObject.GetComponent<ReflectionProbe>();
+            if (observedProbe == null) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_STATE_MISMATCH", "ReflectionProbe could not be read after mutation.", "Retry after the editor is idle.");
+            var observed = GraphicsToolSupport.BuildReflectionProbeInfo(observedProbe);
+            if ((hasMode && observedProbe.mode != mode) || (r.Resolution.HasValue && observedProbe.resolution != r.Resolution.Value) || (r.Bounces.HasValue && observed.Bounces != r.Bounces.Value) || (r.Hdr.HasValue && observedProbe.hdr != r.Hdr.Value) || (boxSize.HasValue && observedProbe.size != boxSize.Value) || (boxOffset.HasValue && observedProbe.center != boxOffset.Value)) throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_PROBE_STATE_MISMATCH", "ReflectionProbe readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Probe = observed, PlannedEffects = effects });
+        }
+        private static void SetBounces(ReflectionProbe p, int v)
+        {
+#if UNITY_2023_2_OR_NEWER
+            p.bounces = v;
+#else
+            RenderSettings.reflectionBounces = v;
+#endif
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/scene-debug.cs

@@ -0,0 +1,37 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+namespace UnityCli
+{
+    public class GraphicsSceneDebugTool : IUnityCliTool<GraphicsSceneDebugTool.Request, GraphicsSceneDebugTool.Result>
+    {
+        public sealed class Request { public string ShadingMode { get; set; } public string DrawMode { get; set; } }
+        public sealed class Result { public bool SceneViewAvailable { get; set; } public string CurrentDrawMode { get; set; } public List<GraphicsPlannedEffect> PlannedEffects { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "graphics.scene-debug", Summary = "Set the SceneView shading or draw mode for debugging.", Description = "Change the current Editor SceneView camera mode.", Group = "graphics",SideEffects = new[] { "scene-view-state" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000, Examples = new[] { new ToolExample { Description = "Show SceneView wireframe", Input = new Request { DrawMode = "Wireframe" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request r, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var view = SceneView.lastActiveSceneView;
+            if (view == null) return new System.Threading.Tasks.ValueTask<Result>(new Result { SceneViewAvailable = false, PlannedEffects = new List<GraphicsPlannedEffect>() });
+            DrawCameraMode? shading = string.IsNullOrEmpty(r.ShadingMode) ? (DrawCameraMode?)null : GraphicsToolSupport.ParseEnum<DrawCameraMode>(r.ShadingMode, "shadingMode");
+            DrawCameraMode? draw = string.IsNullOrEmpty(r.DrawMode) ? (DrawCameraMode?)null : GraphicsToolSupport.ParseEnum<DrawCameraMode>(r.DrawMode, "drawMode");
+            if (!shading.HasValue && !draw.HasValue) return new System.Threading.Tasks.ValueTask<Result>(new Result { SceneViewAvailable = true, CurrentDrawMode = view.cameraMode.name, PlannedEffects = new List<GraphicsPlannedEffect>() });
+            var expected = draw ?? shading.Value;
+#if UNITY_2023_2_OR_NEWER
+            ctx.CommitEffect();
+            view.cameraMode = SceneView.GetBuiltinCameraMode(expected);
+#else
+            ctx.CommitEffect();
+            view.cameraMode = SceneView.GetBuiltinCameraMode(expected);
+#endif
+            view.Repaint();
+            var observed = SceneView.lastActiveSceneView;
+            if (observed == null || observed.cameraMode.drawMode != expected) throw new UnityCliBridge.BridgeCommandException("E_SCENE_DEBUG_STATE_MISMATCH", "SceneView draw mode readback did not match the request.", "Retry when a SceneView is active.");
+            var effects = new List<GraphicsPlannedEffect>();
+            if (shading.HasValue) effects.Add(new GraphicsPlannedEffect { Type = "graphics.scene-debug", Property = "shadingMode", Value = shading.Value.ToString() });
+            if (draw.HasValue) effects.Add(new GraphicsPlannedEffect { Type = "graphics.scene-debug", Property = "drawMode", Value = draw.Value.ToString() });
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { SceneViewAvailable = true, CurrentDrawMode = observed.cameraMode.name, PlannedEffects = effects });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/graphics/settings.cs

@@ -0,0 +1,104 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// graphics.settings — 读取/写入 QualitySettings + GraphicsSettings.defaultRenderPipeline。
+    /// </summary>
+    public class GraphicsSettingsTool : IUnityCliTool<GraphicsSettingsTool.Request, GraphicsSettingsTool.Result>
+    {
+        public sealed class Request
+        {
+            public int? AntiAliasing { get; set; }
+            public float? ShadowDistance { get; set; }
+            public int? VSyncCount { get; set; }
+            public int? MasterTextureLimit { get; set; }
+            public float? LodBias { get; set; }
+            public int? MaximumLODLevel { get; set; }
+            public string RenderPipeline { get; set; }
+            public string Property { get; set; }
+            public string Value { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public GraphicsSummary Graphics { get; set; }
+            public QualitySettingsInfo QualitySettings { get; set; }
+            public List<GraphicsPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "graphics.settings", Summary = "Read and update graphics settings including render pipeline asset and quality fields.",
+            Description = "Read or update QualitySettings fields and GraphicsSettings.defaultRenderPipeline. renderPipeline='built-in' or 'null' resets to built-in.",
+            Group = "graphics", DestructiveHint = true, SideEffects = new[] { "settings-write" },
+            Target = "editor", PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000,
+            Examples = new[] { new ToolExample { Description = "Read graphics settings", Input = new Request { } } }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var effects = new List<GraphicsPlannedEffect>();
+            var hasWrite = request.AntiAliasing.HasValue || request.ShadowDistance.HasValue || request.VSyncCount.HasValue || request.MasterTextureLimit.HasValue || request.LodBias.HasValue || request.MaximumLODLevel.HasValue || !string.IsNullOrEmpty(request.RenderPipeline) || (!string.IsNullOrEmpty(request.Property) && !string.IsNullOrEmpty(request.Value));
+            if (request.ShadowDistance.HasValue) GraphicsToolSupport.ParseFinite(request.ShadowDistance.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "shadowDistance", 0f, float.MaxValue);
+            if (request.LodBias.HasValue) GraphicsToolSupport.ParseFinite(request.LodBias.Value.ToString(System.Globalization.CultureInfo.InvariantCulture), "lodBias", 0.01f, 100f);
+            if (request.VSyncCount.HasValue && (request.VSyncCount.Value < 0 || request.VSyncCount.Value > 4)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_INPUT_INVALID", "vSyncCount must be from 0 to 4.", "Pass a vSyncCount from 0 to 4.");
+            if (request.AntiAliasing.HasValue && request.AntiAliasing.Value != 0 && request.AntiAliasing.Value != 2 && request.AntiAliasing.Value != 4 && request.AntiAliasing.Value != 8) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_INPUT_INVALID", "antiAliasing must be 0, 2, 4, or 8.", "Pass a supported antiAliasing value.");
+            if (request.MasterTextureLimit.HasValue && !GraphicsToolSupport.IsValidTextureLod(request.MasterTextureLimit.Value)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_INPUT_INVALID", "masterTextureLimit must be from 0 to 8.", "Pass a masterTextureLimit from 0 to 8.");
+            if (request.MaximumLODLevel.HasValue && !GraphicsToolSupport.IsValidMaximumLod(request.MaximumLODLevel.Value)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_INPUT_INVALID", "maximumLODLevel must be from 0 to 100000.", "Pass a non-negative maximumLODLevel.");
+            RenderPipelineAsset requestedPipeline = null; var resetPipeline = false; string requestedPipelinePath = null; string requestedPipelineGuid = null;
+            if (!string.IsNullOrEmpty(request.RenderPipeline)) { resetPipeline = string.Equals(request.RenderPipeline, "null", System.StringComparison.OrdinalIgnoreCase) || string.Equals(request.RenderPipeline, "built-in", System.StringComparison.OrdinalIgnoreCase); if (!resetPipeline) { requestedPipelinePath = GraphicsToolSupport.NormalizeAssetPathRequired(request.RenderPipeline, ".asset"); requestedPipeline = AssetDatabase.LoadAssetAtPath<RenderPipelineAsset>(requestedPipelinePath); if (requestedPipeline == null) throw new UnityCliBridge.BridgeCommandException("E_RENDER_PIPELINE_NOT_FOUND", "RenderPipelineAsset not found: " + request.RenderPipeline, "Pass an existing Assets/*.asset RenderPipelineAsset path."); requestedPipelineGuid = AssetDatabase.AssetPathToGUID(requestedPipelinePath); if (string.IsNullOrEmpty(requestedPipelineGuid)) throw new UnityCliBridge.BridgeCommandException("E_RENDER_PIPELINE_NOT_FOUND", "RenderPipelineAsset has no stable GUID: " + request.RenderPipeline, "Pass an imported Assets/*.asset RenderPipelineAsset path."); } }
+            if (!string.IsNullOrEmpty(request.Property) || !string.IsNullOrEmpty(request.Value)) { if (string.IsNullOrEmpty(request.Property) || string.IsNullOrEmpty(request.Value)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_INPUT_INVALID", "property and value must be provided together.", "Use a supported setting member and value."); if (request.Property != "vSyncCount" && request.Property != "antiAliasing" && request.Property != "shadowDistance" && request.Property != "masterTextureLimit" && request.Property != "lodBias" && request.Property != "maximumLODLevel") throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_UNSUPPORTED", "Unsupported graphics setting: " + request.Property, "Use named graphics setting flags."); if (request.Property == "shadowDistance") GraphicsToolSupport.ParseFinite(request.Value, request.Property, 0f, float.MaxValue); else if (request.Property == "lodBias") GraphicsToolSupport.ParseFinite(request.Value, request.Property, 0.01f, 100f); else { int parsed; if (!int.TryParse(request.Value, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out parsed) || (request.Property == "vSyncCount" && (parsed < 0 || parsed > 4)) || (request.Property == "antiAliasing" && parsed != 0 && parsed != 2 && parsed != 4 && parsed != 8) || (request.Property == "masterTextureLimit" && !GraphicsToolSupport.IsValidTextureLod(parsed)) || (request.Property == "maximumLODLevel" && !GraphicsToolSupport.IsValidMaximumLod(parsed))) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_INPUT_INVALID", "Invalid value: " + request.Value, "Pass a value within the supported range."); } }
+            if (hasWrite) ctx.CommitEffect();
+            if (request.AntiAliasing.HasValue) { QualitySettings.antiAliasing = request.AntiAliasing.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "antiAliasing", Value = request.AntiAliasing.Value.ToString() }); }
+            if (request.ShadowDistance.HasValue) { QualitySettings.shadowDistance = request.ShadowDistance.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "shadowDistance", Value = request.ShadowDistance.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) }); }
+            if (request.VSyncCount.HasValue) { QualitySettings.vSyncCount = request.VSyncCount.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "vSyncCount", Value = request.VSyncCount.Value.ToString() }); }
+            if (request.MasterTextureLimit.HasValue) { QualitySettings.globalTextureMipmapLimit = request.MasterTextureLimit.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "masterTextureLimit", Value = request.MasterTextureLimit.Value.ToString() }); }
+            if (request.LodBias.HasValue) { QualitySettings.lodBias = request.LodBias.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "lodBias", Value = request.LodBias.Value.ToString(System.Globalization.CultureInfo.InvariantCulture) }); }
+            if (request.MaximumLODLevel.HasValue) { QualitySettings.maximumLODLevel = request.MaximumLODLevel.Value; effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "maximumLODLevel", Value = request.MaximumLODLevel.Value.ToString() }); }
+            if (!string.IsNullOrEmpty(request.RenderPipeline))
+            {
+                GraphicsSettings.defaultRenderPipeline = resetPipeline ? null : requestedPipeline;
+                effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = "renderPipeline", Value = request.RenderPipeline });
+            }
+            if (!string.IsNullOrEmpty(request.Property) && !string.IsNullOrEmpty(request.Value))
+            {
+                ApplyGenericGraphicsSetting(request.Property, request.Value, effects);
+            }
+            if (effects.Count > 0) AssetDatabase.SaveAssets();
+            RenderPipelineAsset observedPipeline = null;
+            if (!string.IsNullOrEmpty(request.RenderPipeline) && !resetPipeline) observedPipeline = GraphicsToolSupport.ReloadAsset<RenderPipelineAsset>(requestedPipelinePath, requestedPipelineGuid);
+            var observed = GraphicsToolSupport.BuildQualitySettings();
+            if ((request.AntiAliasing.HasValue && observed.AntiAliasing != request.AntiAliasing.Value) || (request.VSyncCount.HasValue && observed.VSyncCount != request.VSyncCount.Value) || (request.ShadowDistance.HasValue && !Mathf.Approximately((float)observed.ShadowDistance, request.ShadowDistance.Value)) || (request.MasterTextureLimit.HasValue && observed.MasterTextureLimit != request.MasterTextureLimit.Value) || (request.LodBias.HasValue && !Mathf.Approximately((float)observed.LodBias, request.LodBias.Value)) || (request.MaximumLODLevel.HasValue && observed.MaximumLODLevel != request.MaximumLODLevel.Value) || (!string.IsNullOrEmpty(request.Property) && !GenericSettingMatches(observed, request.Property, request.Value)) || (!string.IsNullOrEmpty(request.RenderPipeline) && GraphicsSettings.defaultRenderPipeline != observedPipeline)) throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTINGS_STATE_MISMATCH", "Graphics settings readback did not match the request.", "Retry after the editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { Graphics = GraphicsToolSupport.BuildGraphicsSummary(), QualitySettings = observed, PlannedEffects = effects });
+        }
+
+        private static bool GenericSettingMatches(QualitySettingsInfo observed, string property, string value)
+        {
+            if (property == "vSyncCount") return observed.VSyncCount == int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            if (property == "antiAliasing") return observed.AntiAliasing == int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            if (property == "shadowDistance") return Mathf.Approximately((float)observed.ShadowDistance, GameObjectToolSupport.ParseFloat(value, property));
+            if (property == "masterTextureLimit") return observed.MasterTextureLimit == int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            if (property == "lodBias") return Mathf.Approximately((float)observed.LodBias, GameObjectToolSupport.ParseFloat(value, property));
+            return property == "maximumLODLevel" && observed.MaximumLODLevel == int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+        }
+
+        private static void ApplyGenericGraphicsSetting(string property, string value, List<GraphicsPlannedEffect> effects)
+        {
+            if (property == "vSyncCount") QualitySettings.vSyncCount = int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            else if (property == "antiAliasing") QualitySettings.antiAliasing = int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            else if (property == "shadowDistance") QualitySettings.shadowDistance = GameObjectToolSupport.ParseFloat(value, property);
+            else if (property == "masterTextureLimit") QualitySettings.globalTextureMipmapLimit = int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            else if (property == "lodBias") QualitySettings.lodBias = GameObjectToolSupport.ParseFloat(value, property);
+            else if (property == "maximumLODLevel") QualitySettings.maximumLODLevel = int.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
+            else throw new UnityCliBridge.BridgeCommandException("E_GRAPHICS_SETTING_UNSUPPORTED", "Unsupported graphics setting: " + property, "Use named flags such as --anti-aliasing, --shadow-distance or --render-pipeline.");
+            effects.Add(new GraphicsPlannedEffect { Type = "graphics.settings", Property = property, Value = value });
+        }
+    }
+}
+#endif