@atelierai/uco 1.0.0

package/dist/generated/tools.js

@@ -0,0 +1,4299 @@
+// AUTO-GENERATED by uco codegen — do not edit by hand.
+// Regenerate with: `npm run gen --silent -- <unity-project-path>`
+// or programmatically via src/codegen/{fetch,emit}.ts.
+//
+// Source: GET /api/tools from a Unity-MCP server (IvanMurzak/Unity-MCP).
+// Each tool becomes a top-level commander subcommand whose flags
+// mirror its inputSchema.properties — required → .requiredOption(),
+// optional → .option(), with smart coercion for Vector3 / GameObjectRef
+// shorthand, enums via .choices(), and JSON for nested objects/arrays.
+import { Option } from 'commander';
+import { runCommand } from '../util/cli-context.js';
+import { addToolCallControlOptions, toolCallOptionsFromCli } from '../util/call-control.js';
+import { coerceVec3, coerceGameObjectRef, coerceInteger, coerceNumber, coerceBoolean, coerceJson } from '../codegen/coerce.js';
+import { resolveTextInput } from '../util/input.js';
+export const GENERATED_TOOL_NAMES = [
+    "assets-copy",
+    "assets-create-folder",
+    "assets-delete",
+    "assets-find",
+    "assets-find-built-in",
+    "assets-get-data",
+    "assets-material-create",
+    "assets-modify",
+    "assets-move",
+    "assets-prefab-close",
+    "assets-prefab-create",
+    "assets-prefab-instantiate",
+    "assets-prefab-open",
+    "assets-prefab-save",
+    "assets-refresh",
+    "assets-shader-get-data",
+    "assets-shader-list-all",
+    "batch-execute",
+    "build-job-cancel",
+    "build-job-get",
+    "build-job-list",
+    "build-player",
+    "build-scene-add",
+    "build-scene-list",
+    "build-scene-remove",
+    "build-switch-platform",
+    "camera-cm-set-default-blend",
+    "camera-cm-vcam-configure",
+    "camera-cm-vcam-priority",
+    "camera-configure",
+    "camera-get-data",
+    "camera-list-all",
+    "console-clear-logs",
+    "console-get-logs",
+    "docs-get-manual",
+    "docs-get-package",
+    "docs-get-script-reference",
+    "docs-lookup",
+    "editor-application-get-state",
+    "editor-application-set-state",
+    "editor-execute-menu-item",
+    "editor-operation-cancel",
+    "editor-operation-get",
+    "editor-operation-list",
+    "editor-selection-get",
+    "editor-selection-set",
+    "frame-debugger-disable",
+    "frame-debugger-enable",
+    "frame-debugger-get-events",
+    "gameobject-component-add",
+    "gameobject-component-destroy",
+    "gameobject-component-get",
+    "gameobject-component-list-all",
+    "gameobject-component-modify",
+    "gameobject-create",
+    "gameobject-destroy",
+    "gameobject-duplicate",
+    "gameobject-find",
+    "gameobject-modify",
+    "gameobject-set-parent",
+    "graphics-lightbake-cancel",
+    "graphics-lightbake-clear",
+    "graphics-lightbake-start",
+    "graphics-lightbake-status",
+    "graphics-rendering-stats",
+    "graphics-urp-asset-get",
+    "graphics-urp-asset-set",
+    "graphics-urp-renderer-feature-add",
+    "graphics-urp-renderer-feature-configure",
+    "graphics-urp-renderer-feature-list",
+    "graphics-urp-renderer-feature-remove",
+    "graphics-volume-add-override",
+    "graphics-volume-create",
+    "graphics-volume-list",
+    "graphics-volume-remove-override",
+    "graphics-volume-set-field",
+    "instance-get-current",
+    "instance-list-all",
+    "object-get-data",
+    "object-modify",
+    "package-add",
+    "package-list",
+    "package-remove",
+    "package-search",
+    "physics-collision-matrix-get",
+    "physics-collision-matrix-set",
+    "physics-force-apply",
+    "physics-joint-add",
+    "physics-joint-configure",
+    "physics-joint-remove",
+    "physics-linecast",
+    "physics-material-assign",
+    "physics-material-configure",
+    "physics-material-create",
+    "physics-overlap",
+    "physics-raycast",
+    "physics-raycast-all",
+    "physics-rigidbody-configure",
+    "physics-rigidbody-get",
+    "physics-settings-get",
+    "physics-settings-set",
+    "physics-shapecast",
+    "physics-simulate-step",
+    "physics-validate",
+    "profiler-get-counters",
+    "profiler-get-frame-timing",
+    "profiler-get-object-memory",
+    "profiler-memory-snapshot-compare",
+    "profiler-memory-snapshot-list",
+    "profiler-memory-snapshot-take",
+    "profiler-set-areas",
+    "profiler-start",
+    "profiler-status",
+    "profiler-stop",
+    "reflection-method-call",
+    "reflection-method-find",
+    "scene-create",
+    "scene-get-data",
+    "scene-list-opened",
+    "scene-open",
+    "scene-save",
+    "scene-set-active",
+    "scene-unload",
+    "screenshot-camera",
+    "screenshot-game-view",
+    "screenshot-isolated",
+    "screenshot-scene-view",
+    "script-apply-edits",
+    "script-delete",
+    "script-execute",
+    "script-find-in-file",
+    "script-get-sha",
+    "script-read",
+    "script-update-or-create",
+    "script-validate",
+    "tests-job-cancel",
+    "tests-job-get",
+    "tests-job-list",
+    "tests-run",
+    "texture-create-checker",
+    "texture-create-gradient",
+    "texture-create-noise",
+    "texture-create-solid",
+    "texture-read",
+    "tool-set-enabled-state",
+    "tools-list-groups",
+    "tools-set-group-enabled",
+    "type-get-json-schema",
+    "ui-document-attach",
+    "ui-document-detach",
+    "ui-element-query",
+    "ui-uss-create",
+    "ui-uss-modify",
+    "ui-uss-read",
+    "ui-uxml-create",
+    "ui-uxml-modify",
+    "ui-uxml-read",
+    "unity-tool-list",
+    "vfx-graph-configure",
+    "vfx-particle-configure",
+    "vfx-particle-control",
+    "vfx-particle-get",
+    "vfx-trail-configure",
+];
+/** Tools the server has marked disabled in its config at codegen time. */
+export const DEFAULT_DISABLED_TOOLS = [
+    "assets-copy",
+    "assets-create-folder",
+    "assets-delete",
+    "assets-move",
+    "console-clear-logs",
+    "editor-application-get-state",
+    "editor-application-set-state",
+    "editor-execute-menu-item",
+    "editor-selection-get",
+    "editor-selection-set",
+    "frame-debugger-disable",
+    "frame-debugger-enable",
+    "frame-debugger-get-events",
+    "instance-get-current",
+    "instance-list-all",
+    "package-add",
+    "package-list",
+    "package-remove",
+    "package-search",
+    "profiler-get-counters",
+    "profiler-get-frame-timing",
+    "profiler-get-object-memory",
+    "profiler-memory-snapshot-compare",
+    "profiler-memory-snapshot-list",
+    "profiler-memory-snapshot-take",
+    "profiler-set-areas",
+    "profiler-start",
+    "profiler-status",
+    "profiler-stop",
+    "screenshot-camera",
+    "screenshot-game-view",
+    "screenshot-scene-view",
+    "script-apply-edits",
+    "script-delete",
+    "script-get-sha",
+    "script-read",
+    "script-update-or-create",
+    "tool-set-enabled-state",
+];
+export function registerGeneratedTools(program) {
+    // Assets / Copy
+    {
+        const cmd = program
+            .command("assets-copy")
+            .description("Copy assets at given paths and store them at new paths. Does AssetDatabase.Refresh() at the end. Use 'assets-find' tool to find assets before copying.");
+        cmd.addOption(new Option("--destinationPaths <json>", "The paths to store the copied assets.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--sourcePaths <json>", "The paths of the assets to copy.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["destinationPaths"] !== undefined)
+                    args["destinationPaths"] = opts["destinationPaths"];
+                if (opts["sourcePaths"] !== undefined)
+                    args["sourcePaths"] = opts["sourcePaths"];
+                return ctx.transport.callTool("assets-copy", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Create Folder
+    {
+        const cmd = program
+            .command("assets-create-folder")
+            .description("Creates a new folder in the specified parent folder. The parent folder string must start with the 'Assets' folder, and all folders within the parent folder string must already exist. For example, when specifying 'Assets/ParentFolder1/ParentFolder2/', the new folder will be created in 'ParentFolder2' only if ParentFolder1 and ParentFolder2 already exist. Use it to organize scripts and assets in the project. Does AssetDatabase.Refresh() at the end. Returns the GUID of the newly created folder, if successful.");
+        cmd.addOption(new Option("--inputs <json>", "The paths for the folders to create.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["inputs"] !== undefined)
+                    args["inputs"] = opts["inputs"];
+                return ctx.transport.callTool("assets-create-folder", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Delete
+    {
+        const cmd = program
+            .command("assets-delete")
+            .description("Delete the assets at paths from the project. Does AssetDatabase.Refresh() at the end. Use 'assets-find' tool to find assets before deleting.");
+        cmd.addOption(new Option("--paths <json>", "The paths of the assets").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                return ctx.transport.callTool("assets-delete", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Find
+    {
+        const cmd = program
+            .command("assets-find")
+            .description("Search the asset database using the search filter string. Allows you to search for Assets. The string argument can provide names, labels or types (classnames).");
+        cmd.addOption(new Option("--filter <string>", "The filter string can contain search data. Could be empty. Name: Filter assets by their filename (without extension). Words separated by whitespace are treated as separate name searches. Labels (l:): Assets can have labels attached to them. Use 'l:' before each label. Types (t:): Find assets based on explicitly identified types. Use 't:' keyword. Available types: AnimationClip, AudioClip, AudioMixer, ComputeShader, Font, GUISkin, Material, Mesh, Model, PhysicMaterial, Prefab, Scene, Script, Shader, Sprite, Texture, VideoClip, VisualEffectAsset, VisualEffectSubgraph. AssetBundles (b:): Find assets which are part of an Asset bundle. Area (a:): Find assets in a specific area. Valid values are 'all', 'assets', and 'packages'. Globbing (glob:): Use globbing to match specific rules. Note: Searching is case insensitive."));
+        cmd.addOption(new Option("--maxResults <int>", "Maximum number of assets to return. If the number of found assets exceeds this limit, the result will be truncated.").argParser(coerceInteger));
+        cmd.addOption(new Option("--searchInFolders <json>", "The folders where the search will start. If null, the search will be performed in all folders.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["filter"] !== undefined)
+                    args["filter"] = opts["filter"];
+                if (opts["maxResults"] !== undefined)
+                    args["maxResults"] = opts["maxResults"];
+                if (opts["searchInFolders"] !== undefined)
+                    args["searchInFolders"] = opts["searchInFolders"];
+                return ctx.transport.callTool("assets-find", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Find (Built-in)
+    {
+        const cmd = program
+            .command("assets-find-built-in")
+            .description("Search the built-in assets of the Unity Editor located in the built-in resources: Resources/unity_builtin_extra. Doesn't support GUIDs since built-in assets do not have them.");
+        cmd.addOption(new Option("--maxResults <int>", "Maximum number of assets to return. If the number of found assets exceeds this limit, the result will be truncated.").argParser(coerceInteger));
+        cmd.addOption(new Option("--name <string>", "The name of the asset to filter by."));
+        cmd.addOption(new Option("--type <string>", "The type of the asset to filter by."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["maxResults"] !== undefined)
+                    args["maxResults"] = opts["maxResults"];
+                if (opts["name"] !== undefined)
+                    args["name"] = opts["name"];
+                if (opts["type"] !== undefined)
+                    args["type"] = opts["type"];
+                return ctx.transport.callTool("assets-find-built-in", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Get Data
+    {
+        const cmd = program
+            .command("assets-get-data")
+            .description("Get asset data from the asset file in the Unity project. It includes all serializable fields and properties of the asset. Use 'assets-find' tool to find asset before using this tool. Path-scoped reads (token-saving): supply 'paths' (a list of paths) to read only the listed fields/elements via Reflector.TryReadAt, or 'viewQuery' (a ViewQuery) to navigate to a subtree and/or filter by name regex / max depth / type via Reflector.View. These two parameters are mutually exclusive — supply at most one. When neither is supplied the full asset is serialized as before (backwards compatible). Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--assetRef <json>", "Reference to UnityEngine.Object asset instance. It could be Material, ScriptableObject, Prefab, and any other Asset. Anything located in the Assets and Packages folders.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--paths <json>", "Optional. List of paths to read individually via Reflector.TryReadAt. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Mutually exclusive with 'viewQuery'.").argParser(coerceJson));
+        cmd.addOption(new Option("--viewQuery <json>", "Optional. View-query filter routed through Reflector.View — combines a starting Path, a case-insensitive NamePattern regex, MaxDepth, and an optional TypeFilter. Mutually exclusive with 'paths'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["assetRef"] !== undefined)
+                    args["assetRef"] = opts["assetRef"];
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                if (opts["viewQuery"] !== undefined)
+                    args["viewQuery"] = opts["viewQuery"];
+                return ctx.transport.callTool("assets-get-data", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Create Material
+    {
+        const cmd = program
+            .command("assets-material-create")
+            .description("Create new material asset with default parameters. Creates folders recursively if they do not exist. Provide proper 'shaderName' - use 'assets-shader-list-all' tool to find available shaders.");
+        cmd.addOption(new Option("--assetPath <string>", "Asset path. Starts with 'Assets/'. Ends with '.mat'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--shaderName <string>", "Name of the shader that need to be used to create the material.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["assetPath"] !== undefined)
+                    args["assetPath"] = opts["assetPath"];
+                if (opts["shaderName"] !== undefined)
+                    args["shaderName"] = opts["shaderName"];
+                return ctx.transport.callTool("assets-material-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Modify
+    {
+        const cmd = program
+            .command("assets-modify")
+            .description("Modify asset file in the project. Use 'assets-get-data' tool first to inspect the asset structure before modifying. Not allowed to modify asset file in 'Packages/' folder. Please modify it in 'Assets/' folder. Three modification surfaces (use whichever fits the task): 1. 'content' — full SerializedMember override (legacy, backwards compatible). 2. 'pathPatches' — list of {path, value} pairs routed through Reflector.TryModifyAt. 3. 'jsonPatch' — JSON Merge Patch routed through Reflector.TryPatch. When more than one is supplied they run in this order: jsonPatch → pathPatches → content. At least one is required. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--assetRef <json>", "Reference to UnityEngine.Object asset instance. It could be Material, ScriptableObject, Prefab, and any other Asset. Anything located in the Assets and Packages folders.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--content <json>", "Optional. The asset content. It overrides the existing asset content (legacy path).").argParser(coerceJson));
+        cmd.addOption(new Option("--jsonPatch <string>", "Optional. JSON Merge Patch (RFC 7396, extended with [i]/[key] keys) routed through Reflector.TryPatch."));
+        cmd.addOption(new Option("--pathPatches <json>", "Optional. List of path-scoped patches routed through Reflector.TryModifyAt.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["assetRef"] !== undefined)
+                    args["assetRef"] = opts["assetRef"];
+                if (opts["content"] !== undefined)
+                    args["content"] = opts["content"];
+                if (opts["jsonPatch"] !== undefined)
+                    args["jsonPatch"] = opts["jsonPatch"];
+                if (opts["pathPatches"] !== undefined)
+                    args["pathPatches"] = opts["pathPatches"];
+                return ctx.transport.callTool("assets-modify", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Move
+    {
+        const cmd = program
+            .command("assets-move")
+            .description("Move the assets at paths in the project. Should be used for asset rename. Does AssetDatabase.Refresh() at the end. Use 'assets-find' tool to find assets before moving.");
+        cmd.addOption(new Option("--destinationPaths <json>", "The paths of moved assets.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--sourcePaths <json>", "The paths of the assets to move.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["destinationPaths"] !== undefined)
+                    args["destinationPaths"] = opts["destinationPaths"];
+                if (opts["sourcePaths"] !== undefined)
+                    args["sourcePaths"] = opts["sourcePaths"];
+                return ctx.transport.callTool("assets-move", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Prefab / Close
+    {
+        const cmd = program
+            .command("assets-prefab-close")
+            .description("Close currently opened prefab. Use it when you are in prefab editing mode in Unity Editor. Use 'assets-prefab-open' tool to open a prefab first.");
+        cmd.addOption(new Option("--save <bool>", "True to save prefab. False to discard changes.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["save"] !== undefined)
+                    args["save"] = opts["save"];
+                return ctx.transport.callTool("assets-prefab-close", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Prefab / Create
+    {
+        const cmd = program
+            .command("assets-prefab-create")
+            .description("Create a prefab from a GameObject in the current active scene. The prefab will be saved in the project assets at the specified path. Creates folders recursively if they do not exist. If the source GameObject is already a prefab instance and 'connectGameObjectToPrefab' is true, a Prefab Variant is created automatically. To create a Prefab Variant from an existing prefab asset, provide 'sourcePrefabAssetPath' instead of 'gameObjectRef'. Use 'gameobject-find' tool to find the target GameObject first.");
+        cmd.addOption(new Option("--connectGameObjectToPrefab <bool>", "If true, the scene GameObject will be connected to the new prefab (becoming a prefab instance). If the source is already a prefab instance, this creates a Prefab Variant. If false, the prefab asset is created but the scene GameObject remains unchanged. Ignored when 'sourcePrefabAssetPath' is used (always creates a variant).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Reference to a scene GameObject to create the prefab from. If the GameObject is already a prefab instance, a Prefab Variant is created when 'connectGameObjectToPrefab' is true. Optional if 'sourcePrefabAssetPath' is provided.").argParser(coerceGameObjectRef));
+        cmd.addOption(new Option("--prefabAssetPath <string>", "Prefab asset path. Should be in the format 'Assets/Path/To/Prefab.prefab'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--sourcePrefabAssetPath <string>", "Path to an existing prefab asset to create a Prefab Variant from (e.g. 'Assets/Prefabs/Base.prefab'). When provided, a temporary instance is created, saved as a Prefab Variant, and cleaned up. Optional if 'gameObjectRef' is provided."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["connectGameObjectToPrefab"] !== undefined)
+                    args["connectGameObjectToPrefab"] = opts["connectGameObjectToPrefab"];
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                if (opts["prefabAssetPath"] !== undefined)
+                    args["prefabAssetPath"] = opts["prefabAssetPath"];
+                if (opts["sourcePrefabAssetPath"] !== undefined)
+                    args["sourcePrefabAssetPath"] = opts["sourcePrefabAssetPath"];
+                return ctx.transport.callTool("assets-prefab-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Prefab / Instantiate
+    {
+        const cmd = program
+            .command("assets-prefab-instantiate")
+            .description("Instantiates prefab in the current active scene. Use 'assets-find' tool to find prefab assets in the project.");
+        cmd.addOption(new Option("--gameObjectPath <string>", "GameObject path in the current active scene.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--isLocalSpace <bool>", "World or Local space of transform.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--position <x,y,z|json>", "Transform position of the GameObject.").argParser(coerceVec3));
+        cmd.addOption(new Option("--prefabAssetPath <string>", "Prefab asset path.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--rotation <x,y,z|json>", "Transform rotation of the GameObject. Euler angles in degrees.").argParser(coerceVec3));
+        cmd.addOption(new Option("--scale <x,y,z|json>", "Transform scale of the GameObject.").argParser(coerceVec3));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectPath"] !== undefined)
+                    args["gameObjectPath"] = opts["gameObjectPath"];
+                if (opts["isLocalSpace"] !== undefined)
+                    args["isLocalSpace"] = opts["isLocalSpace"];
+                if (opts["position"] !== undefined)
+                    args["position"] = opts["position"];
+                if (opts["prefabAssetPath"] !== undefined)
+                    args["prefabAssetPath"] = opts["prefabAssetPath"];
+                if (opts["rotation"] !== undefined)
+                    args["rotation"] = opts["rotation"];
+                if (opts["scale"] !== undefined)
+                    args["scale"] = opts["scale"];
+                return ctx.transport.callTool("assets-prefab-instantiate", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Prefab / Open
+    {
+        const cmd = program
+            .command("assets-prefab-open")
+            .description("Open prefab edit mode for a specific GameObject. In the Edit mode you can modify the prefab. The modification will be applied to all instances of the prefab across the project. Note: Please use 'assets-prefab-close' tool later to exit prefab editing mode.");
+        cmd.addOption(new Option("--gameObjectRef <ref>", "GameObject that represents prefab instance of an original prefab GameObject.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                return ctx.transport.callTool("assets-prefab-open", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Prefab / Save
+    {
+        const cmd = program
+            .command("assets-prefab-save")
+            .description("Save a prefab. Use it when you are in prefab editing mode in Unity Editor. Use 'assets-prefab-open' tool to open a prefab first.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("assets-prefab-save", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Refresh
+    {
+        const cmd = program
+            .command("assets-refresh")
+            .description("Refreshes the AssetDatabase. Use it if any file was added or updated in the project outside of Unity API. Use it if need to force scripts recompilation when '.cs' file changed.");
+        cmd.addOption(new Option("--options <value>", "Asset import options.").choices(["Default", "ForceUpdate", "ForceSynchronousImport", "ImportRecursive", "DontDownloadFromCacheServer", "ForceUncompressedImport"]));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["options"] !== undefined)
+                    args["options"] = opts["options"];
+                return ctx.transport.callTool("assets-refresh", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / Shader / Get Data
+    {
+        const cmd = program
+            .command("assets-shader-get-data")
+            .description("Get detailed data about a shader asset in the Unity project. Returns shader properties, subshaders, passes, compilation errors, and supported status. Use 'assets-find' tool with filter 't:Shader' to find shaders, or 'assets-shader-list-all' tool to list all shader names. Path-scoped reads (token-saving): supply 'paths' (a list of paths) to read only the listed fields/elements via Reflector.TryReadAt, or 'viewQuery' (a ViewQuery) to navigate to a subtree and/or filter by name regex / max depth / type via Reflector.View. The result populates 'View' on the returned ShaderData. These two parameters are mutually exclusive. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--assetRef <json>", "Reference to UnityEngine.Object asset instance. It could be Material, ScriptableObject, Prefab, and any other Asset. Anything located in the Assets and Packages folders.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--includeMessages <bool>", "Include compilation error and warning messages. Default: true").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeProperties <bool>", "Include shader properties (uniforms) list. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeSourceCode <bool>", "Include pass source code in subshader data. Requires 'includeSubshaders' to be true. Can produce very large responses. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeSubshaders <bool>", "Include subshader and pass structure. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--paths <json>", "Optional. List of paths to read individually via Reflector.TryReadAt against the underlying Shader asset. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Mutually exclusive with 'viewQuery'.").argParser(coerceJson));
+        cmd.addOption(new Option("--viewQuery <json>", "Optional. View-query filter routed through Reflector.View against the underlying Shader asset. Mutually exclusive with 'paths'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["assetRef"] !== undefined)
+                    args["assetRef"] = opts["assetRef"];
+                if (opts["includeMessages"] !== undefined)
+                    args["includeMessages"] = opts["includeMessages"];
+                if (opts["includeProperties"] !== undefined)
+                    args["includeProperties"] = opts["includeProperties"];
+                if (opts["includeSourceCode"] !== undefined)
+                    args["includeSourceCode"] = opts["includeSourceCode"];
+                if (opts["includeSubshaders"] !== undefined)
+                    args["includeSubshaders"] = opts["includeSubshaders"];
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                if (opts["viewQuery"] !== undefined)
+                    args["viewQuery"] = opts["viewQuery"];
+                return ctx.transport.callTool("assets-shader-get-data", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Assets / List Shaders
+    {
+        const cmd = program
+            .command("assets-shader-list-all")
+            .description("List all available shaders in the project assets and packages. Returns their names. Use this to find a shader name for 'assets-material-create' tool.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("assets-shader-list-all", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Batch Execute
+    {
+        const cmd = program
+            .command("batch-execute")
+            .description("Execute multiple tool calls in a single SignalR round-trip. Drastically reduces LLM-to-Unity latency by amortizing transport overhead across many calls.");
+        cmd.addOption(new Option("--commands <json>", "Array of commands. Each must have 'tool' (string) and 'params' (object). Max DefaultMaxCommands (25) recommended; hard max HardMaxCommands (100).").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--failFast <bool>", "Stop after first failure. Default true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--maxParallelism <int>", "Hint for max parallel workers when parallel=true. Default 4. Ignored when parallel=false or when the implementation falls back to sequential.").argParser(coerceInteger));
+        cmd.addOption(new Option("--parallel <bool>", "Run read-only commands in parallel. Falls back to sequential if any command is destructive or the read-only hint is not exposed by the underlying tool surface. Default false.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["commands"] !== undefined)
+                    args["commands"] = opts["commands"];
+                if (opts["failFast"] !== undefined)
+                    args["failFast"] = opts["failFast"];
+                if (opts["maxParallelism"] !== undefined)
+                    args["maxParallelism"] = opts["maxParallelism"];
+                if (opts["parallel"] !== undefined)
+                    args["parallel"] = opts["parallel"];
+                return ctx.transport.callTool("batch-execute", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / Cancel Job
+    {
+        const cmd = program
+            .command("build-job-cancel")
+            .description("Request cancellation of a queued/running player build. Running BuildPipeline work is non-interruptible and reports cancellation pending until it returns.");
+        cmd.addOption(new Option("--jobId <string>", "jobId").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["jobId"] !== undefined)
+                    args["jobId"] = opts["jobId"];
+                return ctx.transport.callTool("build-job-cancel", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / Get Job
+    {
+        const cmd = program
+            .command("build-job-get")
+            .description("Get the current state of a build job by ID. Returns null when the job ID is unknown.");
+        cmd.addOption(new Option("--jobId <string>", "Job ID returned by 'build-player'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["jobId"] !== undefined)
+                    args["jobId"] = opts["jobId"];
+                return ctx.transport.callTool("build-job-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / List Jobs
+    {
+        const cmd = program
+            .command("build-job-list")
+            .description("List every build job currently tracked by the editor.");
+        cmd.addOption(new Option("--includeCompleted <bool>", "When false, only return jobs with Status='queued' or 'running'. Default: true.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeCompleted"] !== undefined)
+                    args["includeCompleted"] = opts["includeCompleted"];
+                return ctx.transport.callTool("build-job-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / Player
+    {
+        const cmd = program
+            .command("build-player")
+            .description("Start a Unity player build for the requested target platform and return a poll-able BuildJobInfo.");
+        cmd.addOption(new Option("--buildOptions <int>", "Build options bitmask. 0=None, 1=Development, 2=AutoRunPlayer, 4=ShowBuiltPlayer, 8=ScriptsOnlyBuild. Default 0.").argParser(coerceInteger));
+        cmd.addOption(new Option("--buildTarget <string>", "Target platform: 'StandaloneWindows64' | 'StandaloneOSX' | 'StandaloneLinux64' | 'Android' | 'iOS' | 'WebGL'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--outputPath <string>", "Output path. Default 'Builds/{target}/{productName}'."));
+        cmd.addOption(new Option("--scenes <json>", "Override scenes list (project-relative .unity paths). Default uses EditorBuildSettings.scenes.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["buildOptions"] !== undefined)
+                    args["buildOptions"] = opts["buildOptions"];
+                if (opts["buildTarget"] !== undefined)
+                    args["buildTarget"] = opts["buildTarget"];
+                if (opts["outputPath"] !== undefined)
+                    args["outputPath"] = opts["outputPath"];
+                if (opts["scenes"] !== undefined)
+                    args["scenes"] = opts["scenes"];
+                return ctx.transport.callTool("build-player", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / Add Scene
+    {
+        const cmd = program
+            .command("build-scene-add")
+            .description("Add a scene to EditorBuildSettings.scenes. Returns the updated list.");
+        cmd.addOption(new Option("--enabled <bool>", "Whether the scene should be enabled in the build. Default: true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--insertAt <int>", "Optional insertion index. When null, the scene is appended.").argParser(coerceInteger));
+        cmd.addOption(new Option("--scenePath <string>", "Project-relative path to the .unity scene asset.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["enabled"] !== undefined)
+                    args["enabled"] = opts["enabled"];
+                if (opts["insertAt"] !== undefined)
+                    args["insertAt"] = opts["insertAt"];
+                if (opts["scenePath"] !== undefined)
+                    args["scenePath"] = opts["scenePath"];
+                return ctx.transport.callTool("build-scene-add", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / List Scenes
+    {
+        const cmd = program
+            .command("build-scene-list")
+            .description("List scenes registered in EditorBuildSettings, preserving build order. Set includeDisabled=false to omit scenes disabled in the build settings.");
+        cmd.addOption(new Option("--includeDisabled <bool>", "Include scenes disabled in EditorBuildSettings (default true). Set false to list only scenes that will be packed into the player.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeDisabled"] !== undefined)
+                    args["includeDisabled"] = opts["includeDisabled"];
+                return ctx.transport.callTool("build-scene-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / Remove Scene
+    {
+        const cmd = program
+            .command("build-scene-remove")
+            .description("Remove a scene from EditorBuildSettings.scenes by path. Returns the updated list.");
+        cmd.addOption(new Option("--scenePath <string>", "Project-relative path of the scene to remove.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["scenePath"] !== undefined)
+                    args["scenePath"] = opts["scenePath"];
+                return ctx.transport.callTool("build-scene-remove", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Build / Switch Platform
+    {
+        const cmd = program
+            .command("build-switch-platform")
+            .description("Switch the editor's active build target. Blocks for the duration of the reimport.");
+        cmd.addOption(new Option("--buildTarget <string>", "Target platform identifier (e.g. 'StandaloneWindows64', 'Android').").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["buildTarget"] !== undefined)
+                    args["buildTarget"] = opts["buildTarget"];
+                return ctx.transport.callTool("build-switch-platform", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Camera / Cinemachine / Set Default Blend
+    {
+        const cmd = program
+            .command("camera-cm-set-default-blend")
+            .description("Set the default blend (style + duration) on the active CinemachineBrain. Returns Ok=false when Cinemachine is not installed or no Brain is present.");
+        cmd.addOption(new Option("--duration <num>", "Blend duration in seconds. Negative values are ignored.").argParser(coerceNumber));
+        cmd.addOption(new Option("--style <string>", "Blend style name (e.g. Cut, EaseInOut, Linear, HardIn, HardOut). Ignored when null/empty."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["duration"] !== undefined)
+                    args["duration"] = opts["duration"];
+                if (opts["style"] !== undefined)
+                    args["style"] = opts["style"];
+                return ctx.transport.callTool("camera-cm-set-default-blend", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Camera / Cinemachine / Configure VCam
+    {
+        const cmd = program
+            .command("camera-cm-vcam-configure")
+            .description("Configure a Cinemachine virtual-camera (priority, FOV, optional noise). Returns Ok=false when the Cinemachine package is not installed.");
+        cmd.addOption(new Option("--followLensIndex <int>", "Reserved for future lens-preset index. Currently ignored.").argParser(coerceInteger));
+        cmd.addOption(new Option("--fov <num>", "Lens field of view (degrees). Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--noiseAmplitudeGain <num>", "Noise amplitude gain. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--noiseFrequencyGain <num>", "Noise frequency gain. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--noiseProfileAssetPath <string>", "Asset path of a NoiseSettings ScriptableObject. When supplied, a CinemachineBasicMultiChannelPerlin component is added/updated. Ignored when null."));
+        cmd.addOption(new Option("--priority <int>", "Cinemachine virtual-camera priority (Brain selection). Ignored when null.").argParser(coerceInteger));
+        cmd.addOption(new Option("--vcamRef <ref>", "Target GameObject hosting the Cinemachine virtual-camera component.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["followLensIndex"] !== undefined)
+                    args["followLensIndex"] = opts["followLensIndex"];
+                if (opts["fov"] !== undefined)
+                    args["fov"] = opts["fov"];
+                if (opts["noiseAmplitudeGain"] !== undefined)
+                    args["noiseAmplitudeGain"] = opts["noiseAmplitudeGain"];
+                if (opts["noiseFrequencyGain"] !== undefined)
+                    args["noiseFrequencyGain"] = opts["noiseFrequencyGain"];
+                if (opts["noiseProfileAssetPath"] !== undefined)
+                    args["noiseProfileAssetPath"] = opts["noiseProfileAssetPath"];
+                if (opts["priority"] !== undefined)
+                    args["priority"] = opts["priority"];
+                if (opts["vcamRef"] !== undefined)
+                    args["vcamRef"] = opts["vcamRef"];
+                return ctx.transport.callTool("camera-cm-vcam-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Camera / Cinemachine / Set VCam Priority
+    {
+        const cmd = program
+            .command("camera-cm-vcam-priority")
+            .description("Set a Cinemachine virtual-camera's priority (persisted via SerializedProperty). Returns Ok=false when Cinemachine is not installed.");
+        cmd.addOption(new Option("--priority <int>", "New priority value. Higher = more likely to become the live camera.").argParser(coerceInteger).makeOptionMandatory(true));
+        cmd.addOption(new Option("--vcamRef <ref>", "Target GameObject hosting the Cinemachine virtual-camera component.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["priority"] !== undefined)
+                    args["priority"] = opts["priority"];
+                if (opts["vcamRef"] !== undefined)
+                    args["vcamRef"] = opts["vcamRef"];
+                return ctx.transport.callTool("camera-cm-vcam-priority", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Camera / Configure
+    {
+        const cmd = program
+            .command("camera-configure")
+            .description("Configure a UnityEngine.Camera's most-common fields. Only provided (non-null) parameters are written. Use 'camera-get-data' to inspect current values first.");
+        cmd.addOption(new Option("--backgroundColor <json>", "Background color (RGBA in [0..1]). Used together with clearFlags=SolidColor. Ignored when null.").argParser(coerceJson));
+        cmd.addOption(new Option("--cameraRef <ref>", "Target Camera GameObject. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--clearFlags <string>", "Clear flags: Skybox | SolidColor | Depth | Nothing. Ignored when null."));
+        cmd.addOption(new Option("--cullingMask <int>", "Culling-mask bitmask. Ignored when null.").argParser(coerceInteger));
+        cmd.addOption(new Option("--depth <num>", "Camera depth (render order / fallback 'priority'). Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--farClipPlane <num>", "Far clip plane. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--fieldOfView <num>", "Field of View in degrees (perspective). Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--nearClipPlane <num>", "Near clip plane. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--orthographic <bool>", "Orthographic mode. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--orthographicSize <num>", "Orthographic size (half-height in world units). Used when orthographic=true. Ignored when null.").argParser(coerceNumber));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["backgroundColor"] !== undefined)
+                    args["backgroundColor"] = opts["backgroundColor"];
+                if (opts["cameraRef"] !== undefined)
+                    args["cameraRef"] = opts["cameraRef"];
+                if (opts["clearFlags"] !== undefined)
+                    args["clearFlags"] = opts["clearFlags"];
+                if (opts["cullingMask"] !== undefined)
+                    args["cullingMask"] = opts["cullingMask"];
+                if (opts["depth"] !== undefined)
+                    args["depth"] = opts["depth"];
+                if (opts["farClipPlane"] !== undefined)
+                    args["farClipPlane"] = opts["farClipPlane"];
+                if (opts["fieldOfView"] !== undefined)
+                    args["fieldOfView"] = opts["fieldOfView"];
+                if (opts["nearClipPlane"] !== undefined)
+                    args["nearClipPlane"] = opts["nearClipPlane"];
+                if (opts["orthographic"] !== undefined)
+                    args["orthographic"] = opts["orthographic"];
+                if (opts["orthographicSize"] !== undefined)
+                    args["orthographicSize"] = opts["orthographicSize"];
+                return ctx.transport.callTool("camera-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Camera / Get Data
+    {
+        const cmd = program
+            .command("camera-get-data")
+            .description("Read a Camera's configuration plus optional Cinemachine virtual-camera priority. Pair with 'camera-configure' to write back.");
+        cmd.addOption(new Option("--cameraRef <ref>", "Target Camera GameObject. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["cameraRef"] !== undefined)
+                    args["cameraRef"] = opts["cameraRef"];
+                return ctx.transport.callTool("camera-get-data", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Camera / List All
+    {
+        const cmd = program
+            .command("camera-list-all")
+            .description("List all Cameras in the scenes with a config snapshot per camera. Also reports whether the Cinemachine package is installed.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("camera-list-all", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Console / Clear Logs
+    {
+        const cmd = program
+            .command("console-clear-logs")
+            .description("Clears the log cache (used by console-get-logs) and the Unity Editor Console window. Useful for isolating errors related to a specific action by clearing logs before performing the action.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("console-clear-logs", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Console / Get Logs
+    {
+        const cmd = program
+            .command("console-get-logs")
+            .description("Retrieves Unity Editor logs with correlation/source attribution and loss accounting. Useful for debugging and monitoring Unity Editor activity.");
+        cmd.addOption(new Option("--correlationId <string>", "Only entries emitted inside this tool call's execution window (correlation identity). Example: 'call-...'."));
+        cmd.addOption(new Option("--includeStackTrace <bool>", "Include stack traces in the output. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--lastMinutes <int>", "Return logs from the last N minutes. If 0, returns all available logs. Default: 0").argParser(coerceInteger));
+        cmd.addOption(new Option("--logTypeFilter <value>", "Filter by log type. 'null' means All.").choices(["Error", "Assert", "Warning", "Log", "Exception"]));
+        cmd.addOption(new Option("--maxEntries <int>", "Maximum number of log entries to return. Minimum: 1. Default: 100").argParser(coerceInteger));
+        cmd.addOption(new Option("--operationId <string>", "Only entries attributed to this durable operation id. Example: the operationId returned by tests-run."));
+        cmd.addOption(new Option("--sinceUnixMs <int>", "Only entries at or after this Unix-epoch millisecond boundary. Record the boundary before an operation, then filter new entries here. Example: 1760000000000.").argParser(coerceInteger));
+        cmd.addOption(new Option("--source <string>", "Source classification filter: 'product', 'bridge', 'tool', or 'unity'. 'null' returns all sources."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["correlationId"] !== undefined)
+                    args["correlationId"] = opts["correlationId"];
+                if (opts["includeStackTrace"] !== undefined)
+                    args["includeStackTrace"] = opts["includeStackTrace"];
+                if (opts["lastMinutes"] !== undefined)
+                    args["lastMinutes"] = opts["lastMinutes"];
+                if (opts["logTypeFilter"] !== undefined)
+                    args["logTypeFilter"] = opts["logTypeFilter"];
+                if (opts["maxEntries"] !== undefined)
+                    args["maxEntries"] = opts["maxEntries"];
+                if (opts["operationId"] !== undefined)
+                    args["operationId"] = opts["operationId"];
+                if (opts["sinceUnixMs"] !== undefined)
+                    args["sinceUnixMs"] = opts["sinceUnixMs"];
+                if (opts["source"] !== undefined)
+                    args["source"] = opts["source"];
+                return ctx.transport.callTool("console-get-logs", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Docs / Get Manual
+    {
+        const cmd = program
+            .command("docs-get-manual")
+            .description("Fetch a Unity Manual page by slug and return its parsed title/sections/code examples.");
+        cmd.addOption(new Option("--slug <string>", "Manual page slug as it appears in the URL, e.g. 'execution-order', 'urp/urp-introduction'. Required.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--version <string>", "Full Unity version such as '6000.0.38f1'. Only the major.minor portion is used. Optional."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["slug"] !== undefined)
+                    args["slug"] = opts["slug"];
+                if (opts["version"] !== undefined)
+                    args["version"] = opts["version"];
+                return ctx.transport.callTool("docs-get-manual", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Docs / Get Package
+    {
+        const cmd = program
+            .command("docs-get-package")
+            .description("Fetch a Unity package manual page and return its parsed title/sections/code examples.");
+        cmd.addOption(new Option("--package <string>", "Package id, e.g. 'com.unity.render-pipelines.universal'. Required.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--page <string>", "Page slug under the package's manual folder, e.g. 'index', '2d-index', 'whats-new'. Required.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--pkgVersion <string>", "Package version, e.g. '17.0' or '17.0.3'. Required.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["package"] !== undefined)
+                    args["package"] = opts["package"];
+                if (opts["page"] !== undefined)
+                    args["page"] = opts["page"];
+                if (opts["pkgVersion"] !== undefined)
+                    args["pkgVersion"] = opts["pkgVersion"];
+                return ctx.transport.callTool("docs-get-package", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Docs / Get ScriptReference
+    {
+        const cmd = program
+            .command("docs-get-script-reference")
+            .description("Fetch a Unity ScriptReference page (class or member) and return a structured ScriptRefDoc. Verifies class / method signatures and surfaces official code examples for self-correction.");
+        cmd.addOption(new Option("--className <string>", "Unity class name, e.g. 'Physics', 'Transform', 'AnimationCurve'. Required.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--memberName <string>", "Method or property name on the class, e.g. 'Raycast', 'position'. Optional — omit for the class-level page."));
+        cmd.addOption(new Option("--version <string>", "Full Unity version such as '6000.0.38f1'. Only the major.minor portion is used. Optional — omitted means latest."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["className"] !== undefined)
+                    args["className"] = opts["className"];
+                if (opts["memberName"] !== undefined)
+                    args["memberName"] = opts["memberName"];
+                if (opts["version"] !== undefined)
+                    args["version"] = opts["version"];
+                return ctx.transport.callTool("docs-get-script-reference", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Docs / Lookup
+    {
+        const cmd = program
+            .command("docs-lookup")
+            .description("Look up one or more Unity doc queries across ScriptReference, Manual, and Package docs in parallel.");
+        cmd.addOption(new Option("--package <string>", "Optional package id (e.g. 'com.unity.render-pipelines.universal') to also probe package docs. Requires pkgVersion."));
+        cmd.addOption(new Option("--pkgVersion <string>", "Optional package version (e.g. '17.0'). Requires package."));
+        cmd.addOption(new Option("--queries <json>", "One or more query strings. Examples: 'Physics.Raycast', 'NavMeshAgent', 'execution-order'. Required.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--version <string>", "Full Unity version such as '6000.0.38f1'. Only the major.minor portion is used. Optional."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["package"] !== undefined)
+                    args["package"] = opts["package"];
+                if (opts["pkgVersion"] !== undefined)
+                    args["pkgVersion"] = opts["pkgVersion"];
+                if (opts["queries"] !== undefined)
+                    args["queries"] = opts["queries"];
+                if (opts["version"] !== undefined)
+                    args["version"] = opts["version"];
+                return ctx.transport.callTool("docs-lookup", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor / Application / Get State
+    {
+        const cmd = program
+            .command("editor-application-get-state")
+            .description("Returns available information about 'UnityEditor.EditorApplication'. Use it to get information about the current state of the Unity Editor application. Such as: playmode, paused state, compilation state, etc.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("editor-application-get-state", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor / Application / Set State
+    {
+        const cmd = program
+            .command("editor-application-set-state")
+            .description("Control the Unity Editor application state. You can start, stop, or pause the 'playmode'. Use 'editor-application-get-state' tool to get the current state first.");
+        cmd.addOption(new Option("--isPaused <bool>", "If true, the 'playmode' will be paused. If false, the 'playmode' will be resumed.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--isPlaying <bool>", "If true, the 'playmode' will be started. If false, the 'playmode' will be stopped.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["isPaused"] !== undefined)
+                    args["isPaused"] = opts["isPaused"];
+                if (opts["isPlaying"] !== undefined)
+                    args["isPlaying"] = opts["isPlaying"];
+                return ctx.transport.callTool("editor-application-set-state", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor / Execute Menu Item
+    {
+        const cmd = program
+            .command("editor-execute-menu-item")
+            .description("Execute a Unity Editor menu item by full path. Use the 'editor://menu-items' resource to list available menu paths first.");
+        cmd.addOption(new Option("--menuPath <string>", "Full menu path, e.g. 'GameObject/Create Empty', 'Assets/Refresh'. Get the canonical list from the 'editor://menu-items' resource.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["menuPath"] !== undefined)
+                    args["menuPath"] = opts["menuPath"];
+                return ctx.transport.callTool("editor-execute-menu-item", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor Operation / Cancel
+    {
+        const cmd = program
+            .command("editor-operation-cancel")
+            .description("Request cooperative cancellation for an Editor operation.");
+        cmd.addOption(new Option("--operationId <string>", "operationId").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["operationId"] !== undefined)
+                    args["operationId"] = opts["operationId"];
+                return ctx.transport.callTool("editor-operation-cancel", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor Operation / Get
+    {
+        const cmd = program
+            .command("editor-operation-get")
+            .description("Get one durable Editor operation by ID. Returns null when it is unknown.");
+        cmd.addOption(new Option("--operationId <string>", "operationId").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["operationId"] !== undefined)
+                    args["operationId"] = opts["operationId"];
+                return ctx.transport.callTool("editor-operation-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor Operation / List
+    {
+        const cmd = program
+            .command("editor-operation-list")
+            .description("List durable Editor operations, optionally filtered by kind and terminal state.");
+        cmd.addOption(new Option("--includeTerminal <bool>", "includeTerminal").argParser(coerceBoolean));
+        cmd.addOption(new Option("--kind <string>", "kind"));
+        cmd.addOption(new Option("--limit <int>", "limit").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeTerminal"] !== undefined)
+                    args["includeTerminal"] = opts["includeTerminal"];
+                if (opts["kind"] !== undefined)
+                    args["kind"] = opts["kind"];
+                if (opts["limit"] !== undefined)
+                    args["limit"] = opts["limit"];
+                return ctx.transport.callTool("editor-operation-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor / Selection / Get
+    {
+        const cmd = program
+            .command("editor-selection-get")
+            .description("Get information about the current Selection in the Unity Editor. Use 'editor-selection-set' tool to set the selection.");
+        cmd.addOption(new Option("--includeActiveObject <bool>", "includeActiveObject").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeActiveTransform <bool>", "includeActiveTransform").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeAssetGUIDs <bool>", "includeAssetGUIDs").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeGameObjects <bool>", "includeGameObjects").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeInstanceIDs <bool>", "includeInstanceIDs").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeTransforms <bool>", "includeTransforms").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeActiveObject"] !== undefined)
+                    args["includeActiveObject"] = opts["includeActiveObject"];
+                if (opts["includeActiveTransform"] !== undefined)
+                    args["includeActiveTransform"] = opts["includeActiveTransform"];
+                if (opts["includeAssetGUIDs"] !== undefined)
+                    args["includeAssetGUIDs"] = opts["includeAssetGUIDs"];
+                if (opts["includeGameObjects"] !== undefined)
+                    args["includeGameObjects"] = opts["includeGameObjects"];
+                if (opts["includeInstanceIDs"] !== undefined)
+                    args["includeInstanceIDs"] = opts["includeInstanceIDs"];
+                if (opts["includeTransforms"] !== undefined)
+                    args["includeTransforms"] = opts["includeTransforms"];
+                return ctx.transport.callTool("editor-selection-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Editor / Selection / Set
+    {
+        const cmd = program
+            .command("editor-selection-set")
+            .description("Set the current Selection in the Unity Editor to the provided objects. Use 'editor-selection-get' tool to get the current selection first.");
+        cmd.addOption(new Option("--select <json>", "select").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["select"] !== undefined)
+                    args["select"] = opts["select"];
+                return ctx.transport.callTool("editor-selection-set", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Frame Debugger / Disable
+    {
+        const cmd = program
+            .command("frame-debugger-disable")
+            .description("Disable the Unity Frame Debugger via reflection.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("frame-debugger-disable", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Frame Debugger / Enable
+    {
+        const cmd = program
+            .command("frame-debugger-enable")
+            .description("Enable the Unity Frame Debugger via reflection on FrameDebuggerUtility.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("frame-debugger-enable", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Frame Debugger / Get Events
+    {
+        const cmd = program
+            .command("frame-debugger-get-events")
+            .description("Page through draw-call events captured by the Frame Debugger.");
+        cmd.addOption(new Option("--cursor <int>", "Cursor offset into the event list. Default: 0.").argParser(coerceInteger));
+        cmd.addOption(new Option("--pageSize <int>", "Number of events per page. Default: 50.").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["cursor"] !== undefined)
+                    args["cursor"] = opts["cursor"];
+                if (opts["pageSize"] !== undefined)
+                    args["pageSize"] = opts["pageSize"];
+                return ctx.transport.callTool("frame-debugger-get-events", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Component / Add
+    {
+        const cmd = program
+            .command("gameobject-component-add")
+            .description("Add Component to GameObject in opened Prefab or in a Scene. Use 'gameobject-find' tool to find the target GameObject first. Use 'gameobject-component-list-all' tool to find the component type names to add.");
+        cmd.addOption(new Option("--componentNames <json>", "Full name of the Component. It should include full namespace path and the class name.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Find GameObject in opened Prefab or in the active Scene.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["componentNames"] !== undefined)
+                    args["componentNames"] = opts["componentNames"];
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                return ctx.transport.callTool("gameobject-component-add", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Component / Destroy
+    {
+        const cmd = program
+            .command("gameobject-component-destroy")
+            .description("Destroy one or many components from target GameObject. Can't destroy missed components. Use 'gameobject-find' tool to find the target GameObject and 'gameobject-component-get' to get component details first.");
+        cmd.addOption(new Option("--destroyComponentRefs <json-array>", "Component reference array. Used to find Component at GameObject.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Find GameObject in opened Prefab or in the active Scene.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["destroyComponentRefs"] !== undefined)
+                    args["destroyComponentRefs"] = opts["destroyComponentRefs"];
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                return ctx.transport.callTool("gameobject-component-destroy", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Component / Get
+    {
+        const cmd = program
+            .command("gameobject-component-get")
+            .description("Get detailed information about a specific Component on a GameObject. Returns component type, enabled state, and optionally serialized fields and properties. Use this to inspect component data before modifying it. Use 'gameobject-find' tool to get the list of all components on the GameObject. Path-scoped reads (token-saving): supply 'paths' (a list of paths) to read only the listed fields/elements via Reflector.TryReadAt, or 'viewQuery' (a ViewQuery) to navigate to a subtree and/or filter by name regex / max depth / type via Reflector.View. The result is returned in the 'View' field of the response. These two parameters are mutually exclusive — supply at most one. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--componentRef <json>", "Component reference. Used to find a Component at GameObject.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--deepSerialization <bool>", "Performs deep serialization including all nested objects. Otherwise, only serializes top-level members.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Find GameObject in opened Prefab or in the active Scene.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--includeFields <bool>", "Include serialized fields of the component.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeProperties <bool>", "Include serialized properties of the component.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--paths <json>", "Optional. List of paths to read individually via Reflector.TryReadAt. When supplied, the legacy 'Fields'/'Properties' lists are skipped and the result is returned in 'View'. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Mutually exclusive with 'viewQuery'.").argParser(coerceJson));
+        cmd.addOption(new Option("--viewQuery <json>", "Optional. View-query filter routed through Reflector.View. When supplied, the legacy 'Fields'/'Properties' lists are skipped and the filtered subtree is returned in 'View'. Mutually exclusive with 'paths'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["componentRef"] !== undefined)
+                    args["componentRef"] = opts["componentRef"];
+                if (opts["deepSerialization"] !== undefined)
+                    args["deepSerialization"] = opts["deepSerialization"];
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                if (opts["includeFields"] !== undefined)
+                    args["includeFields"] = opts["includeFields"];
+                if (opts["includeProperties"] !== undefined)
+                    args["includeProperties"] = opts["includeProperties"];
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                if (opts["viewQuery"] !== undefined)
+                    args["viewQuery"] = opts["viewQuery"];
+                return ctx.transport.callTool("gameobject-component-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Component / List All
+    {
+        const cmd = program
+            .command("gameobject-component-list-all")
+            .description("List C# class names extended from UnityEngine.Component. Use this to find component type names for 'gameobject-component-add' tool. Results are paginated to avoid overwhelming responses.");
+        cmd.addOption(new Option("--page <int>", "Page number (0-based). Default is 0.").argParser(coerceInteger));
+        cmd.addOption(new Option("--pageSize <int>", "Number of items per page. Default is 5. Max is 500.").argParser(coerceInteger));
+        cmd.addOption(new Option("--search <string>", "Substring for searching components. Could be empty."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["page"] !== undefined)
+                    args["page"] = opts["page"];
+                if (opts["pageSize"] !== undefined)
+                    args["pageSize"] = opts["pageSize"];
+                if (opts["search"] !== undefined)
+                    args["search"] = opts["search"];
+                return ctx.transport.callTool("gameobject-component-list-all", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Component / Modify
+    {
+        const cmd = program
+            .command("gameobject-component-modify")
+            .description("Modify a specific Component on a GameObject in opened Prefab or in a Scene. Allows direct modification of component fields and properties without wrapping in GameObject structure. Use 'gameobject-component-get' first to inspect the component structure before modifying. Three modification surfaces (use whichever fits the task): 1. 'componentDiff' — full SerializedMember diff (legacy, backwards compatible). 2. 'pathPatches' — list of {path, value} pairs routed through Reflector.TryModifyAt; atomic per-path modification, multiple entries can target different depths. 3. 'jsonPatch' — a JSON Merge Patch (RFC 7396, extended with [i]/[key] notation) routed through Reflector.TryPatch; multiple fields at any depth in a single call. When more than one is supplied they run in this order: jsonPatch → pathPatches → componentDiff. At least one is required. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--componentDiff <json>", "Optional. The full component data to apply (legacy path). Should contain 'fields' and/or 'props' with the values to modify. Only include the fields/properties you want to change. Any unknown or invalid fields and properties will be reported in the response.").argParser(coerceJson));
+        cmd.addOption(new Option("--componentRef <json>", "Component reference. Used to find a Component at GameObject.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Find GameObject in opened Prefab or in the active Scene.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--jsonPatch <string>", "Optional. JSON Merge Patch (RFC 7396, extended with [i]/[key] keys) routed through Reflector.TryPatch. Allows multiple fields at any depth to be updated in a single call. Use '$type' for compatible-subtype replacement."));
+        cmd.addOption(new Option("--pathPatches <json>", "Optional. List of path-scoped patches routed through Reflector.TryModifyAt. Each entry targets one field/element/entry by path. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["componentDiff"] !== undefined)
+                    args["componentDiff"] = opts["componentDiff"];
+                if (opts["componentRef"] !== undefined)
+                    args["componentRef"] = opts["componentRef"];
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                if (opts["jsonPatch"] !== undefined)
+                    args["jsonPatch"] = opts["jsonPatch"];
+                if (opts["pathPatches"] !== undefined)
+                    args["pathPatches"] = opts["pathPatches"];
+                return ctx.transport.callTool("gameobject-component-modify", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Create
+    {
+        const cmd = program
+            .command("gameobject-create")
+            .description("Create a new GameObject in opened Prefab or in a Scene. If needed - provide proper 'position', 'rotation' and 'scale' to reduce amount of operations.");
+        cmd.addOption(new Option("--isLocalSpace <bool>", "World or Local space of transform.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--name <string>", "Name of the new GameObject.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--parentGameObjectRef <ref>", "Parent GameObject reference. If not provided, the GameObject will be created at the root of the scene or prefab.").argParser(coerceGameObjectRef));
+        cmd.addOption(new Option("--position <x,y,z|json>", "Transform position of the GameObject.").argParser(coerceVec3));
+        cmd.addOption(new Option("--primitiveType <value>", "primitiveType").choices(["Sphere", "Capsule", "Cylinder", "Cube", "Plane", "Quad"]));
+        cmd.addOption(new Option("--rotation <x,y,z|json>", "Transform rotation of the GameObject. Euler angles in degrees.").argParser(coerceVec3));
+        cmd.addOption(new Option("--scale <x,y,z|json>", "Transform scale of the GameObject.").argParser(coerceVec3));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["isLocalSpace"] !== undefined)
+                    args["isLocalSpace"] = opts["isLocalSpace"];
+                if (opts["name"] !== undefined)
+                    args["name"] = opts["name"];
+                if (opts["parentGameObjectRef"] !== undefined)
+                    args["parentGameObjectRef"] = opts["parentGameObjectRef"];
+                if (opts["position"] !== undefined)
+                    args["position"] = opts["position"];
+                if (opts["primitiveType"] !== undefined)
+                    args["primitiveType"] = opts["primitiveType"];
+                if (opts["rotation"] !== undefined)
+                    args["rotation"] = opts["rotation"];
+                if (opts["scale"] !== undefined)
+                    args["scale"] = opts["scale"];
+                return ctx.transport.callTool("gameobject-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Destroy
+    {
+        const cmd = program
+            .command("gameobject-destroy")
+            .description("Destroy GameObject and all nested GameObjects recursively in opened Prefab or in a Scene. Use 'gameobject-find' tool to find the target GameObject first.");
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Find GameObject in opened Prefab or in the active Scene.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                return ctx.transport.callTool("gameobject-destroy", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Duplicate
+    {
+        const cmd = program
+            .command("gameobject-duplicate")
+            .description("Duplicate GameObjects in opened Prefab or in a Scene. Use 'gameobject-find' tool to find the target GameObjects first.");
+        cmd.addOption(new Option("--gameObjectRefs <json-array>", "Array of GameObjects in opened Prefab or in the active Scene.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectRefs"] !== undefined)
+                    args["gameObjectRefs"] = opts["gameObjectRefs"];
+                return ctx.transport.callTool("gameobject-duplicate", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Find
+    {
+        const cmd = program
+            .command("gameobject-find")
+            .description("Finds specific GameObject by provided information in opened Prefab or in a Scene. First it looks for the opened Prefab, if any Prefab is opened it looks only there ignoring a scene. If no opened Prefab it looks into current active scene. Returns GameObject information and its children. Also, it returns Components preview just for the target GameObject. Path-scoped reads (token-saving): supply 'paths' (a list of paths) to read only the listed fields/elements via Reflector.TryReadAt, or 'viewQuery' (a ViewQuery) to navigate to a subtree and/or filter by name regex / max depth / type via Reflector.View. When either is supplied, the result populates 'Data' on the returned GameObjectData and overrides 'includeData' (which would otherwise produce a full recursive serialization). These two parameters are mutually exclusive — supply at most one. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Find GameObject in opened Prefab or in the active Scene.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--hierarchyDepth <int>", "Determines the depth of the hierarchy to include. 0 - means only the target GameObject. 1 - means to include one layer below.").argParser(coerceInteger));
+        cmd.addOption(new Option("--includeBounds <bool>", "Include 3D bounds of the GameObject.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeComponents <bool>", "Include attached components references.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeData <bool>", "Include editable GameObject data (tag, layer, etc).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeHierarchy <bool>", "Include hierarchy metadata.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--paths <json>", "Optional. List of paths to read individually via Reflector.TryReadAt. When supplied, replaces 'includeData'-style full serialization with a path-scoped aggregate. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Mutually exclusive with 'viewQuery'.").argParser(coerceJson));
+        cmd.addOption(new Option("--viewQuery <json>", "Optional. View-query filter routed through Reflector.View. When supplied, replaces 'includeData'-style full serialization with the filtered subtree. Mutually exclusive with 'paths'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                if (opts["hierarchyDepth"] !== undefined)
+                    args["hierarchyDepth"] = opts["hierarchyDepth"];
+                if (opts["includeBounds"] !== undefined)
+                    args["includeBounds"] = opts["includeBounds"];
+                if (opts["includeComponents"] !== undefined)
+                    args["includeComponents"] = opts["includeComponents"];
+                if (opts["includeData"] !== undefined)
+                    args["includeData"] = opts["includeData"];
+                if (opts["includeHierarchy"] !== undefined)
+                    args["includeHierarchy"] = opts["includeHierarchy"];
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                if (opts["viewQuery"] !== undefined)
+                    args["viewQuery"] = opts["viewQuery"];
+                return ctx.transport.callTool("gameobject-find", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Modify
+    {
+        const cmd = program
+            .command("gameobject-modify")
+            .description("Modify GameObject fields and properties in opened Prefab or in a Scene. You can modify multiple GameObjects at once. Just provide the same number of GameObject references and SerializedMember objects. Three modification surfaces (per GameObject — parallel arrays must have the same length as gameObjectRefs): 1. 'gameObjectDiffs' — full SerializedMember diff per GameObject (legacy, backwards compatible). 2. 'pathPatchesPerGameObject' — list of {path, value} patches per GameObject routed through Reflector.TryModifyAt; atomic per-path modification. 3. 'jsonPatchesPerGameObject' — JSON Merge Patch per GameObject routed through Reflector.TryPatch. When more than one is supplied for the same GameObject they run in this order: jsonPatch → pathPatches → diff. At least one of the three is required. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'.");
+        cmd.addOption(new Option("--gameObjectDiffs <json-array>", "Optional. Each item in the array represents a GameObject modification of the 'gameObjectRefs' at the same index. Usually a GameObject is a container for components. Each component may have fields and properties for modification. If you need to modify components of a GameObject, please use 'gameobject-component-modify' tool. Ignore values that should not be modified. Any unknown or wrong located fields and properties will be ignored. Check the result of this command to see what was changed. The ignored fields and properties will be listed.").argParser(coerceJson));
+        cmd.addOption(new Option("--gameObjectRefs <json-array>", "Array of GameObjects in opened Prefab or in the active Scene.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--jsonPatchesPerGameObject <json>", "Optional. Per-GameObject JSON Merge Patch (RFC 7396, extended with [i]/[key] keys) routed through Reflector.TryPatch. Outer index aligns with 'gameObjectRefs'. Pass null or omit for GameObjects that should not receive a JSON patch.").argParser(coerceJson));
+        cmd.addOption(new Option("--pathPatchesPerGameObject <json>", "Optional. Per-GameObject list of path-scoped patches routed through Reflector.TryModifyAt. Outer index aligns with 'gameObjectRefs'; inner list contains {path, value} entries. Pass null or omit for GameObjects that should not receive path patches.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectDiffs"] !== undefined)
+                    args["gameObjectDiffs"] = opts["gameObjectDiffs"];
+                if (opts["gameObjectRefs"] !== undefined)
+                    args["gameObjectRefs"] = opts["gameObjectRefs"];
+                if (opts["jsonPatchesPerGameObject"] !== undefined)
+                    args["jsonPatchesPerGameObject"] = opts["jsonPatchesPerGameObject"];
+                if (opts["pathPatchesPerGameObject"] !== undefined)
+                    args["pathPatchesPerGameObject"] = opts["pathPatchesPerGameObject"];
+                return ctx.transport.callTool("gameobject-modify", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // GameObject / Set Parent
+    {
+        const cmd = program
+            .command("gameobject-set-parent")
+            .description("Set parent GameObject to list of GameObjects in opened Prefab or in a Scene. Use 'gameobject-find' tool to find the target GameObjects first.");
+        cmd.addOption(new Option("--gameObjectRefs <json-array>", "List of references to the GameObjects to set new parent.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--parentGameObjectRef <ref>", "Reference to the parent GameObject.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--worldPositionStays <bool>", "A boolean flag indicating whether the GameObject's world position should remain unchanged when setting its parent.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["gameObjectRefs"] !== undefined)
+                    args["gameObjectRefs"] = opts["gameObjectRefs"];
+                if (opts["parentGameObjectRef"] !== undefined)
+                    args["parentGameObjectRef"] = opts["parentGameObjectRef"];
+                if (opts["worldPositionStays"] !== undefined)
+                    args["worldPositionStays"] = opts["worldPositionStays"];
+                return ctx.transport.callTool("gameobject-set-parent", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Lightmap Bake / Cancel
+    {
+        const cmd = program
+            .command("graphics-lightbake-cancel")
+            .description("Cancel the in-progress lightmap bake (Lightmapping.Cancel).");
+        cmd.addOption(new Option("--failIfNotRunning <bool>", "Fail with an error instead of returning a 'no-op' when no bake is running (default false). Useful for automation that must assert a bake was actually cancelled.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["failIfNotRunning"] !== undefined)
+                    args["failIfNotRunning"] = opts["failIfNotRunning"];
+                return ctx.transport.callTool("graphics-lightbake-cancel", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Lightmap Bake / Clear
+    {
+        const cmd = program
+            .command("graphics-lightbake-clear")
+            .description("Clear baked lightmaps for the open scenes (Lightmapping.Clear).");
+        cmd.addOption(new Option("--cancelRunningBake <bool>", "Cancel a running bake before clearing instead of refusing (default false).").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["cancelRunningBake"] !== undefined)
+                    args["cancelRunningBake"] = opts["cancelRunningBake"];
+                return ctx.transport.callTool("graphics-lightbake-clear", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Lightmap Bake / Start
+    {
+        const cmd = program
+            .command("graphics-lightbake-start")
+            .description("Start an asynchronous lightmap bake (Lightmapping.BakeAsync).");
+        cmd.addOption(new Option("--bakeMode <string>", "Bake mode: 'BakedGI' | 'RealtimeGI' | 'BakedAndRealtimeGI'. Default 'BakedGI'."));
+        cmd.addOption(new Option("--clearExisting <bool>", "Whether to clear existing lightmaps first. Default false.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["bakeMode"] !== undefined)
+                    args["bakeMode"] = opts["bakeMode"];
+                if (opts["clearExisting"] !== undefined)
+                    args["clearExisting"] = opts["clearExisting"];
+                return ctx.transport.callTool("graphics-lightbake-start", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Lightmap Bake / Status
+    {
+        const cmd = program
+            .command("graphics-lightbake-status")
+            .description("Get current lightmap bake status and generated lightmap stats.");
+        cmd.addOption(new Option("--includeDiskSize <bool>", "Sum the on-disk sizes of the lightmap textures into TotalSizeBytes (default true). Set false for a cheap IsBaking/Progress/LightmapCount probe without touching the disk.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeDiskSize"] !== undefined)
+                    args["includeDiskSize"] = opts["includeDiskSize"];
+                return ctx.transport.callTool("graphics-lightbake-status", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Rendering Stats
+    {
+        const cmd = program
+            .command("graphics-rendering-stats")
+            .description("Sample UnityEditor.UnityStats for the most-recent frame's renderer counters.");
+        cmd.addOption(new Option("--includeMemoryStats <bool>", "Populate TotalMemoryMB/TextureCount from the texture-memory stats (default true). Set false for a compact draw-call/batch/triangle snapshot.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeMemoryStats"] !== undefined)
+                    args["includeMemoryStats"] = opts["includeMemoryStats"];
+                return ctx.transport.callTool("graphics-rendering-stats", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / URP Asset / Get
+    {
+        const cmd = program
+            .command("graphics-urp-asset-get")
+            .description("Read URP UniversalRenderPipelineAsset settings.");
+        cmd.addOption(new Option("--assetPath <string>", "URP asset path. Default = QualitySettings.renderPipeline of the current Quality level."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["assetPath"] !== undefined)
+                    args["assetPath"] = opts["assetPath"];
+                return ctx.transport.callTool("graphics-urp-asset-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / URP Asset / Set
+    {
+        const cmd = program
+            .command("graphics-urp-asset-set")
+            .description("Mutate URP UniversalRenderPipelineAsset settings (only non-null params are written).");
+        cmd.addOption(new Option("--additionalLightsPerObjectLimit <int>", "Maximum number of additional per-object lights. Ignored when null.").argParser(coerceInteger));
+        cmd.addOption(new Option("--additionalLightsRenderingMode <string>", "Additional-lights rendering mode enum name (e.g. 'Disabled', 'PerPixel', 'PerVertex'). Ignored when null."));
+        cmd.addOption(new Option("--assetPath <string>", "URP asset path (must point at a UniversalRenderPipelineAsset).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--hdr <bool>", "UniversalRenderPipelineAsset.supportsHDR. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--mainLightRenderingMode <string>", "Main-light rendering mode enum name (e.g. 'Disabled', 'PerPixel'). Ignored when null."));
+        cmd.addOption(new Option("--msaaSampleCount <string>", "MSAA sample count: 'Disabled' | '_2x' | '_4x' | '_8x'. Ignored when null."));
+        cmd.addOption(new Option("--renderScale <num>", "UniversalRenderPipelineAsset.renderScale. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--supportsCameraDepthTexture <bool>", "UniversalRenderPipelineAsset.supportsCameraDepthTexture. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--supportsCameraOpaqueTexture <bool>", "UniversalRenderPipelineAsset.supportsCameraOpaqueTexture. Ignored when null.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["additionalLightsPerObjectLimit"] !== undefined)
+                    args["additionalLightsPerObjectLimit"] = opts["additionalLightsPerObjectLimit"];
+                if (opts["additionalLightsRenderingMode"] !== undefined)
+                    args["additionalLightsRenderingMode"] = opts["additionalLightsRenderingMode"];
+                if (opts["assetPath"] !== undefined)
+                    args["assetPath"] = opts["assetPath"];
+                if (opts["hdr"] !== undefined)
+                    args["hdr"] = opts["hdr"];
+                if (opts["mainLightRenderingMode"] !== undefined)
+                    args["mainLightRenderingMode"] = opts["mainLightRenderingMode"];
+                if (opts["msaaSampleCount"] !== undefined)
+                    args["msaaSampleCount"] = opts["msaaSampleCount"];
+                if (opts["renderScale"] !== undefined)
+                    args["renderScale"] = opts["renderScale"];
+                if (opts["supportsCameraDepthTexture"] !== undefined)
+                    args["supportsCameraDepthTexture"] = opts["supportsCameraDepthTexture"];
+                if (opts["supportsCameraOpaqueTexture"] !== undefined)
+                    args["supportsCameraOpaqueTexture"] = opts["supportsCameraOpaqueTexture"];
+                return ctx.transport.callTool("graphics-urp-asset-set", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / URP Renderer Feature / Add
+    {
+        const cmd = program
+            .command("graphics-urp-renderer-feature-add")
+            .description("Add a ScriptableRendererFeature to a URP renderer data asset.");
+        cmd.addOption(new Option("--featureTypeName <string>", "Type name of the feature, e.g. 'UnityEngine.Rendering.Universal.RenderObjects'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--rendererDataPath <string>", "ScriptableRendererData asset path (required).").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["featureTypeName"] !== undefined)
+                    args["featureTypeName"] = opts["featureTypeName"];
+                if (opts["rendererDataPath"] !== undefined)
+                    args["rendererDataPath"] = opts["rendererDataPath"];
+                return ctx.transport.callTool("graphics-urp-renderer-feature-add", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / URP Renderer Feature / Configure
+    {
+        const cmd = program
+            .command("graphics-urp-renderer-feature-configure")
+            .description("Set a single field on a URP renderer feature (JSON-encoded value).");
+        cmd.addOption(new Option("--fieldName <string>", "Field name to set.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--rendererDataPath <string>", "ScriptableRendererData asset path (required).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--typeNameOrIndex <string>", "Type name (matches what was added) OR 0-based index.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--valueJson <string>", "JSON-encoded value.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["fieldName"] !== undefined)
+                    args["fieldName"] = opts["fieldName"];
+                if (opts["rendererDataPath"] !== undefined)
+                    args["rendererDataPath"] = opts["rendererDataPath"];
+                if (opts["typeNameOrIndex"] !== undefined)
+                    args["typeNameOrIndex"] = opts["typeNameOrIndex"];
+                if (opts["valueJson"] !== undefined)
+                    args["valueJson"] = opts["valueJson"];
+                return ctx.transport.callTool("graphics-urp-renderer-feature-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / URP Renderer Feature / List
+    {
+        const cmd = program
+            .command("graphics-urp-renderer-feature-list")
+            .description("Enumerate URP renderer features on a ScriptableRendererData asset.");
+        cmd.addOption(new Option("--rendererDataPath <string>", "ScriptableRendererData asset path. Optional — defaults to the URP asset's first renderer."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["rendererDataPath"] !== undefined)
+                    args["rendererDataPath"] = opts["rendererDataPath"];
+                return ctx.transport.callTool("graphics-urp-renderer-feature-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / URP Renderer Feature / Remove
+    {
+        const cmd = program
+            .command("graphics-urp-renderer-feature-remove")
+            .description("Remove a URP renderer feature by 0-based index or type-name match.");
+        cmd.addOption(new Option("--rendererDataPath <string>", "ScriptableRendererData asset path (required).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--typeNameOrIndex <string>", "Type name (matches what was added) OR 0-based index.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["rendererDataPath"] !== undefined)
+                    args["rendererDataPath"] = opts["rendererDataPath"];
+                if (opts["typeNameOrIndex"] !== undefined)
+                    args["typeNameOrIndex"] = opts["typeNameOrIndex"];
+                return ctx.transport.callTool("graphics-urp-renderer-feature-remove", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Volume / Add Override
+    {
+        const cmd = program
+            .command("graphics-volume-add-override")
+            .description("Add a VolumeComponent override (e.g. Bloom, ColorAdjustments) to a VolumeProfile. profileOrVolumePath accepts either an asset path or a scene Volume's hierarchy path.");
+        cmd.addOption(new Option("--active <bool>", "Set VolumeComponent.active after adding. Default true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--componentTypeName <string>", "Full or short type name of the VolumeComponent. Examples: 'UnityEngine.Rendering.Universal.Bloom', 'ColorAdjustments', 'UnityEngine.Rendering.HighDefinition.Tonemapping'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--profileOrVolumePath <string>", "Asset path of a VolumeProfile (*.asset) OR scene hierarchy path of a Volume GameObject.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["active"] !== undefined)
+                    args["active"] = opts["active"];
+                if (opts["componentTypeName"] !== undefined)
+                    args["componentTypeName"] = opts["componentTypeName"];
+                if (opts["profileOrVolumePath"] !== undefined)
+                    args["profileOrVolumePath"] = opts["profileOrVolumePath"];
+                return ctx.transport.callTool("graphics-volume-add-override", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Volume / Create
+    {
+        const cmd = program
+            .command("graphics-volume-create")
+            .description("Create a Volume GameObject with a VolumeProfile assigned. Reuses an existing profile if profileAssetPath is set, otherwise creates a blank one.");
+        cmd.addOption(new Option("--isGlobal <bool>", "Set Volume.isGlobal. Default true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--name <string>", "Name of the new GameObject.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--newProfileAssetPath <string>", "Path where a fresh VolumeProfile asset will be created when 'profileAssetPath' is null. Default 'Assets/Volumes/{name}_Profile.asset'. Intermediate folders are created."));
+        cmd.addOption(new Option("--parent <ref>", "Optional parent GameObject. When null, the volume is created at scene root.").argParser(coerceGameObjectRef));
+        cmd.addOption(new Option("--position <x,y,z|json>", "Optional local position. Defaults to (0,0,0).").argParser(coerceVec3));
+        cmd.addOption(new Option("--priority <num>", "Set Volume.priority. Default 0.").argParser(coerceNumber));
+        cmd.addOption(new Option("--profileAssetPath <string>", "Path to an existing VolumeProfile asset to assign. Optional — when null, a blank profile is created at 'newProfileAssetPath'."));
+        cmd.addOption(new Option("--weight <num>", "Set Volume.weight in [0..1]. Default 1.").argParser(coerceNumber));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["isGlobal"] !== undefined)
+                    args["isGlobal"] = opts["isGlobal"];
+                if (opts["name"] !== undefined)
+                    args["name"] = opts["name"];
+                if (opts["newProfileAssetPath"] !== undefined)
+                    args["newProfileAssetPath"] = opts["newProfileAssetPath"];
+                if (opts["parent"] !== undefined)
+                    args["parent"] = opts["parent"];
+                if (opts["position"] !== undefined)
+                    args["position"] = opts["position"];
+                if (opts["priority"] !== undefined)
+                    args["priority"] = opts["priority"];
+                if (opts["profileAssetPath"] !== undefined)
+                    args["profileAssetPath"] = opts["profileAssetPath"];
+                if (opts["weight"] !== undefined)
+                    args["weight"] = opts["weight"];
+                return ctx.transport.callTool("graphics-volume-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Volume / List
+    {
+        const cmd = program
+            .command("graphics-volume-list")
+            .description("List every UnityEngine.Rendering.Volume in the opened scenes. Filter by sceneGlob (wildcard against scene asset path) or onlyWithProfile.");
+        cmd.addOption(new Option("--onlyWithProfile <bool>", "Include only volumes that have a VolumeProfile assigned. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--sceneGlob <string>", "Filter by scene asset-path glob (e.g. 'Assets/Scenes/*.unity'). Optional."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["onlyWithProfile"] !== undefined)
+                    args["onlyWithProfile"] = opts["onlyWithProfile"];
+                if (opts["sceneGlob"] !== undefined)
+                    args["sceneGlob"] = opts["sceneGlob"];
+                return ctx.transport.callTool("graphics-volume-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Volume / Remove Override
+    {
+        const cmd = program
+            .command("graphics-volume-remove-override")
+            .description("Remove a VolumeComponent override (e.g. Bloom) from a VolumeProfile.");
+        cmd.addOption(new Option("--componentTypeName <string>", "Full or short type name of the VolumeComponent override to remove.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--profileOrVolumePath <string>", "Asset path of a VolumeProfile (*.asset) OR scene hierarchy path of a Volume GameObject.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["componentTypeName"] !== undefined)
+                    args["componentTypeName"] = opts["componentTypeName"];
+                if (opts["profileOrVolumePath"] !== undefined)
+                    args["profileOrVolumePath"] = opts["profileOrVolumePath"];
+                return ctx.transport.callTool("graphics-volume-remove-override", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Graphics / Volume / Set Field
+    {
+        const cmd = program
+            .command("graphics-volume-set-field")
+            .description("Set a VolumeParameter<T> field on a VolumeComponent override (e.g. Bloom.intensity = 1.5). Optionally toggles VolumeParameter.overrideState.");
+        cmd.addOption(new Option("--componentTypeName <string>", "Full or short type name of the VolumeComponent that owns the parameter.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--fieldName <string>", "Parameter / field name on the VolumeComponent (e.g. 'intensity', 'threshold', 'tint').").makeOptionMandatory(true));
+        cmd.addOption(new Option("--profileOrVolumePath <string>", "Asset path of a VolumeProfile (*.asset) OR scene hierarchy path of a Volume GameObject.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--setOverrideState <bool>", "When true, also sets VolumeParameter.overrideState = true so the value contributes. Default true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--valueJson <string>", "JSON-encoded value matching the parameter's underlying T type. Examples: '1.5' (float), 'true' (bool), '[1,0,0,1]' (Color RGBA), '\"ACES\"' (enum).").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["componentTypeName"] !== undefined)
+                    args["componentTypeName"] = opts["componentTypeName"];
+                if (opts["fieldName"] !== undefined)
+                    args["fieldName"] = opts["fieldName"];
+                if (opts["profileOrVolumePath"] !== undefined)
+                    args["profileOrVolumePath"] = opts["profileOrVolumePath"];
+                if (opts["setOverrideState"] !== undefined)
+                    args["setOverrideState"] = opts["setOverrideState"];
+                if (opts["valueJson"] !== undefined)
+                    args["valueJson"] = opts["valueJson"];
+                return ctx.transport.callTool("graphics-volume-set-field", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Instance / Get Current
+    {
+        const cmd = program
+            .command("instance-get-current")
+            .description("Return identity metadata of the calling Unity Editor: port, project path, project name, Unity version, process id, and stable instance id. Pass includeEnvironment=true to also report the batchmode/CI launch flags.");
+        cmd.addOption(new Option("--includeEnvironment <bool>", "Also populate the IsBatchMode/IsCi diagnostic fields (default false). Useful when diagnosing why the bridge is not connecting (batchmode/CI launches skip it).").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeEnvironment"] !== undefined)
+                    args["includeEnvironment"] = opts["includeEnvironment"];
+                return ctx.transport.callTool("instance-get-current", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Instance / List All
+    {
+        const cmd = program
+            .command("instance-list-all")
+            .description("List all Unity Editor instances registered on this machine plus identify the calling Editor.");
+        cmd.addOption(new Option("--includeStale <bool>", "Include stale entries (Editor exited without cleanup). Default false.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeStale"] !== undefined)
+                    args["includeStale"] = opts["includeStale"];
+                return ctx.transport.callTool("instance-list-all", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Object / Get Data
+    {
+        const cmd = program
+            .command("object-get-data")
+            .description("Get data of the specified Unity Object. Returns serialized data of the object including its properties and fields. If need to modify the data use 'object-modify' tool. Path-scoped reads (token-saving): supply 'paths' (a list of paths) to read only the listed fields/elements via Reflector.TryReadAt, or 'viewQuery' (a ViewQuery) to navigate to a subtree and/or filter by name regex / max depth / type via Reflector.View. These two parameters are mutually exclusive — supply at most one. When neither is supplied the full object is serialized as before (backwards compatible). Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--objectRef <json>", "Reference to UnityEngine.Object instance. It could be GameObject, Component, Asset, etc. Anything extended from UnityEngine.Object.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--paths <json>", "Optional. List of paths to read individually via Reflector.TryReadAt. Each path may target a different depth. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Mutually exclusive with 'viewQuery'.").argParser(coerceJson));
+        cmd.addOption(new Option("--viewQuery <json>", "Optional. View-query filter routed through Reflector.View — combines a starting Path, a case-insensitive NamePattern regex, MaxDepth, and an optional TypeFilter. Mutually exclusive with 'paths'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["objectRef"] !== undefined)
+                    args["objectRef"] = opts["objectRef"];
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                if (opts["viewQuery"] !== undefined)
+                    args["viewQuery"] = opts["viewQuery"];
+                return ctx.transport.callTool("object-get-data", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Object / Modify
+    {
+        const cmd = program
+            .command("object-modify")
+            .description("Modify the specified Unity Object. Allows direct modification of object fields and properties. Use 'object-get-data' first to inspect the object structure before modifying. Three modification surfaces (use whichever fits the task): 1. 'objectDiff' — full SerializedMember diff (legacy, backwards compatible). 2. 'pathPatches' — list of {path, value} pairs routed through Reflector.TryModifyAt; atomic per-path modification, multiple entries can target different depths. 3. 'jsonPatch' — a JSON Merge Patch (RFC 7396, extended with [i]/[key] notation) routed through Reflector.TryPatch; multiple fields at any depth in a single call. When more than one is supplied they run in this order: jsonPatch → pathPatches → objectDiff. At least one is required. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped.");
+        cmd.addOption(new Option("--jsonPatch <string>", "Optional. JSON Merge Patch (RFC 7396, extended with [i]/[key] keys) routed through Reflector.TryPatch."));
+        cmd.addOption(new Option("--objectDiff <json>", "Optional. The full object data to apply (legacy path). Should contain 'fields' and/or 'props' with the values to modify. Only include the fields/properties you want to change. Any unknown or invalid fields and properties will be reported in the response.").argParser(coerceJson));
+        cmd.addOption(new Option("--objectRef <json>", "Reference to UnityEngine.Object instance. It could be GameObject, Component, Asset, etc. Anything extended from UnityEngine.Object.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--pathPatches <json>", "Optional. List of path-scoped patches routed through Reflector.TryModifyAt.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["jsonPatch"] !== undefined)
+                    args["jsonPatch"] = opts["jsonPatch"];
+                if (opts["objectDiff"] !== undefined)
+                    args["objectDiff"] = opts["objectDiff"];
+                if (opts["objectRef"] !== undefined)
+                    args["objectRef"] = opts["objectRef"];
+                if (opts["pathPatches"] !== undefined)
+                    args["pathPatches"] = opts["pathPatches"];
+                return ctx.transport.callTool("object-modify", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Package Manager / Add
+    {
+        const cmd = program
+            .command("package-add")
+            .description("Install a package from the Unity Package Manager registry, Git URL, or local path. This operation modifies the project's manifest.json and triggers package resolution. Note: Package installation may trigger a domain reload. The result will be sent after the reload completes. Use 'package-search' tool to search for packages and 'package-list' to list installed packages.");
+        cmd.addOption(new Option("--packageId <string>", "The package ID to install. Formats: Package ID 'com.unity.textmeshpro' (installs latest compatible version), Package ID with version 'com.unity.textmeshpro@3.0.6', Git URL 'https://github.com/user/repo.git', Git URL with branch/tag 'https://github.com/user/repo.git#v1.0.0', Local path 'file:../MyPackage'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["packageId"] !== undefined)
+                    args["packageId"] = opts["packageId"];
+                return ctx.transport.callTool("package-add", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Package Manager / List Installed
+    {
+        const cmd = program
+            .command("package-list")
+            .description("List all packages installed in the Unity project (UPM packages). Returns information about each installed package including name, version, source, and description. Use this to check which packages are currently installed before adding or removing packages.");
+        cmd.addOption(new Option("--directDependenciesOnly <bool>", "Include only direct dependencies (packages in manifest.json). If false, includes all resolved packages. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--nameFilter <string>", "Filter packages by name, display name, or description (case-insensitive). Results are prioritized: exact name match, exact display name match, name substring, display name substring, description substring."));
+        cmd.addOption(new Option("--sourceFilter <value>", "Filter packages by source.").choices(["All", "Registry", "Embedded", "Local", "Git", "BuiltIn", "LocalTarball"]));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["directDependenciesOnly"] !== undefined)
+                    args["directDependenciesOnly"] = opts["directDependenciesOnly"];
+                if (opts["nameFilter"] !== undefined)
+                    args["nameFilter"] = opts["nameFilter"];
+                if (opts["sourceFilter"] !== undefined)
+                    args["sourceFilter"] = opts["sourceFilter"];
+                return ctx.transport.callTool("package-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Package Manager / Remove
+    {
+        const cmd = program
+            .command("package-remove")
+            .description("Remove (uninstall) a package from the Unity project. This removes the package from the project's manifest.json and triggers package resolution. Note: Built-in packages and packages that are dependencies of other installed packages cannot be removed. Note: Package removal may trigger a domain reload. The result will be sent after the reload completes. Use 'package-list' tool to list installed packages first.");
+        cmd.addOption(new Option("--packageId <string>", "The ID of the package to remove. Example: 'com.unity.textmeshpro'. Do not include version number.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["packageId"] !== undefined)
+                    args["packageId"] = opts["packageId"];
+                return ctx.transport.callTool("package-remove", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Package Manager / Search
+    {
+        const cmd = program
+            .command("package-search")
+            .description("Search for packages in both Unity Package Manager registry and installed packages. Use this to find packages by name before installing them. Returns available versions and installation status. Searches both the Unity registry and locally installed packages (including Git, local, and embedded sources). Results are prioritized: exact name match, exact display name match, name substring, display name substring, description substring. Note: Online mode fetches exact matches from live registry, then supplements with cached substring matches.");
+        cmd.addOption(new Option("--maxResults <int>", "Maximum number of results to return. Default: 10").argParser(coerceInteger));
+        cmd.addOption(new Option("--offlineMode <bool>", "Whether to perform the search in offline mode (uses cached registry data only). Default: true. Set to false to fetch latest exact matches from Unity registry.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--query <string>", "The package id, name, or description. Can be: Full package id 'com.unity.textmeshpro', Full package name 'TextMesh Pro', Partial name 'TextMesh' (will search in Unity registry and installed packages), Description keyword 'rendering' (searches in package descriptions).").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["maxResults"] !== undefined)
+                    args["maxResults"] = opts["maxResults"];
+                if (opts["offlineMode"] !== undefined)
+                    args["offlineMode"] = opts["offlineMode"];
+                if (opts["query"] !== undefined)
+                    args["query"] = opts["query"];
+                return ctx.transport.callTool("package-search", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Collision Matrix / Get
+    {
+        const cmd = program
+            .command("physics-collision-matrix-get")
+            .description("Read the layer-vs-layer collision matrix for the requested dimension.");
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                return ctx.transport.callTool("physics-collision-matrix-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Collision Matrix / Set
+    {
+        const cmd = program
+            .command("physics-collision-matrix-set")
+            .description("Toggle collision between two layers for the requested dimension. Layer arguments accept either a layer name or a numeric index.");
+        cmd.addOption(new Option("--collide <bool>", "Whether the two layers should collide. Internally calls IgnoreLayerCollision(!collide).").argParser(coerceBoolean).makeOptionMandatory(true));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--layerA <string>", "Layer A: name or integer index 0..31.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--layerB <string>", "Layer B: name or integer index 0..31.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["collide"] !== undefined)
+                    args["collide"] = opts["collide"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["layerA"] !== undefined)
+                    args["layerA"] = opts["layerA"];
+                if (opts["layerB"] !== undefined)
+                    args["layerB"] = opts["layerB"];
+                return ctx.transport.callTool("physics-collision-matrix-set", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Force / Apply
+    {
+        const cmd = program
+            .command("physics-force-apply")
+            .description("Apply a force / torque / explosion / impulse to a Rigidbody (3D or 2D).");
+        cmd.addOption(new Option("--action <string>", "Action: 'force' | 'torque' | 'explosion' | 'impulse'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--explosionForce <num>", "Explosion magnitude. Used by 'explosion' action.").argParser(coerceNumber));
+        cmd.addOption(new Option("--explosionPosition <x,y,z|json>", "Explosion origin in world space. Used by 'explosion' action.").argParser(coerceVec3));
+        cmd.addOption(new Option("--explosionRadius <num>", "Explosion radius. Used by 'explosion' action.").argParser(coerceNumber));
+        cmd.addOption(new Option("--force <x,y,z|json>", "Force vector. Used by 'force' and 'impulse' actions.").argParser(coerceVec3));
+        cmd.addOption(new Option("--mode <string>", "ForceMode: 'Force' (default) | 'Impulse' | 'VelocityChange' | 'Acceleration'. 2D only supports 'Force' and 'Impulse'."));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the Rigidbody / Rigidbody2D.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--torque <x,y,z|json>", "Torque vector. Used by 'torque' action. In 2D only the Z component is honored.").argParser(coerceVec3));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["action"] !== undefined)
+                    args["action"] = opts["action"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["explosionForce"] !== undefined)
+                    args["explosionForce"] = opts["explosionForce"];
+                if (opts["explosionPosition"] !== undefined)
+                    args["explosionPosition"] = opts["explosionPosition"];
+                if (opts["explosionRadius"] !== undefined)
+                    args["explosionRadius"] = opts["explosionRadius"];
+                if (opts["force"] !== undefined)
+                    args["force"] = opts["force"];
+                if (opts["mode"] !== undefined)
+                    args["mode"] = opts["mode"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["torque"] !== undefined)
+                    args["torque"] = opts["torque"];
+                return ctx.transport.callTool("physics-force-apply", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Joint / Add
+    {
+        const cmd = program
+            .command("physics-joint-add")
+            .description("Attach a 3D or 2D Joint component to a GameObject. Auto-adds Rigidbody/Rigidbody2D when missing. Use 'physics-joint-configure' afterwards to tune motors/limits/springs.");
+        cmd.addOption(new Option("--anchor <x,y,z|json>", "Anchor (local space) where the joint attaches on the host body.").argParser(coerceVec3));
+        cmd.addOption(new Option("--autoConfigureConnectedAnchor <bool>", "Toggle 'Auto Configure Connected Anchor' (where the joint exposes it; most 2D joints).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--axis <x,y,z|json>", "Axis (3D joints only — HingeJoint/ConfigurableJoint).").argParser(coerceVec3));
+        cmd.addOption(new Option("--connectedAnchor <x,y,z|json>", "Connected anchor in the connected body's local space.").argParser(coerceVec3));
+        cmd.addOption(new Option("--connectedBody <ref>", "GameObject that this joint connects to (the 'connected body'). Null = connect to world.").argParser(coerceGameObjectRef));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'. Case-insensitive."));
+        cmd.addOption(new Option("--jointType <string>", "Joint type. 3D: fixed/hinge/spring/character/configurable. 2D: distance/fixed/friction/hinge/relative/slider/spring/target/wheel.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--target <ref>", "GameObject to attach the joint to. Required.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["anchor"] !== undefined)
+                    args["anchor"] = opts["anchor"];
+                if (opts["autoConfigureConnectedAnchor"] !== undefined)
+                    args["autoConfigureConnectedAnchor"] = opts["autoConfigureConnectedAnchor"];
+                if (opts["axis"] !== undefined)
+                    args["axis"] = opts["axis"];
+                if (opts["connectedAnchor"] !== undefined)
+                    args["connectedAnchor"] = opts["connectedAnchor"];
+                if (opts["connectedBody"] !== undefined)
+                    args["connectedBody"] = opts["connectedBody"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["jointType"] !== undefined)
+                    args["jointType"] = opts["jointType"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("physics-joint-add", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Joint / Configure
+    {
+        const cmd = program
+            .command("physics-joint-configure")
+            .description("Configure an existing 3D or 2D Joint on a GameObject. Only provided (non-null) parameters are written. Use 'jointIndex' + 'jointType' to disambiguate multi-joint GameObjects.");
+        cmd.addOption(new Option("--anchor <x,y,z|json>", "Anchor (local space).").argParser(coerceVec3));
+        cmd.addOption(new Option("--angularXMotion <string>", "ConfigurableJoint angularXMotion: Locked / Limited / Free."));
+        cmd.addOption(new Option("--angularYMotion <string>", "ConfigurableJoint angularYMotion: Locked / Limited / Free."));
+        cmd.addOption(new Option("--angularZMotion <string>", "ConfigurableJoint angularZMotion: Locked / Limited / Free."));
+        cmd.addOption(new Option("--axis <x,y,z|json>", "Axis (3D joints only — HingeJoint/ConfigurableJoint/CharacterJoint).").argParser(coerceVec3));
+        cmd.addOption(new Option("--breakForce <num>", "3D-only: force threshold above which the joint breaks. Float.PositiveInfinity = unbreakable.").argParser(coerceNumber));
+        cmd.addOption(new Option("--breakTorque <num>", "3D-only: torque threshold above which the joint breaks.").argParser(coerceNumber));
+        cmd.addOption(new Option("--connectedAnchor <x,y,z|json>", "Connected anchor (connected body's local space).").argParser(coerceVec3));
+        cmd.addOption(new Option("--connectedBody <ref>", "GameObject providing the connected Rigidbody / Rigidbody2D. Pass an unresolved ref to leave unchanged.").argParser(coerceGameObjectRef));
+        cmd.addOption(new Option("--damper <num>", "SpringJoint(2D): damper coefficient.").argParser(coerceNumber));
+        cmd.addOption(new Option("--dampingRatio <num>", "2D spring-style joints: damping ratio.").argParser(coerceNumber));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--distance <num>", "DistanceJoint2D / SliderJoint2D / SpringJoint2D: target distance.").argParser(coerceNumber));
+        cmd.addOption(new Option("--frequency <num>", "2D spring-style joints: oscillation frequency (Hz).").argParser(coerceNumber));
+        cmd.addOption(new Option("--jointIndex <int>", "Index of the joint on the GameObject (0-based, in component-order). Defaults to 0.").argParser(coerceInteger));
+        cmd.addOption(new Option("--jointType <string>", "Optional joint-type filter (case-insensitive alias). 3D: fixed/hinge/spring/character/configurable. 2D: distance/fixed/friction/hinge/relative/slider/spring/target/wheel."));
+        cmd.addOption(new Option("--limitMax <num>", "Hinge limit maximum (degrees).").argParser(coerceNumber));
+        cmd.addOption(new Option("--limitMin <num>", "Hinge limit minimum (degrees).").argParser(coerceNumber));
+        cmd.addOption(new Option("--maxDistance <num>", "3D SpringJoint: maximum distance.").argParser(coerceNumber));
+        cmd.addOption(new Option("--minDistance <num>", "3D SpringJoint: minimum distance.").argParser(coerceNumber));
+        cmd.addOption(new Option("--motorForce <num>", "3D HingeJoint motor.force.").argParser(coerceNumber));
+        cmd.addOption(new Option("--motorMaxTorque <num>", "2D HingeJoint / WheelJoint motor.maxMotorTorque.").argParser(coerceNumber));
+        cmd.addOption(new Option("--motorTargetVelocity <num>", "Hinge/Wheel motor: target angular velocity.").argParser(coerceNumber));
+        cmd.addOption(new Option("--spring <num>", "SpringJoint(2D): spring stiffness.").argParser(coerceNumber));
+        cmd.addOption(new Option("--springDamper <num>", "Hinge spring damper.").argParser(coerceNumber));
+        cmd.addOption(new Option("--springForce <num>", "Hinge spring stiffness (3D 'spring' / 2D analogous field).").argParser(coerceNumber));
+        cmd.addOption(new Option("--target <ref>", "GameObject hosting the joint. Required.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--tolerance <num>", "3D SpringJoint: tolerance.").argParser(coerceNumber));
+        cmd.addOption(new Option("--useLimits <bool>", "Hinge: enable angular limits.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--useMotor <bool>", "Hinge/Wheel: enable the motor.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--useSpring <bool>", "Hinge: enable the spring.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--wheelDamping <num>", "WheelJoint2D suspension: damping ratio.").argParser(coerceNumber));
+        cmd.addOption(new Option("--wheelFrequency <num>", "WheelJoint2D suspension: frequency (Hz).").argParser(coerceNumber));
+        cmd.addOption(new Option("--xMotion <string>", "ConfigurableJoint xMotion: Locked / Limited / Free (case-insensitive)."));
+        cmd.addOption(new Option("--yMotion <string>", "ConfigurableJoint yMotion: Locked / Limited / Free."));
+        cmd.addOption(new Option("--zMotion <string>", "ConfigurableJoint zMotion: Locked / Limited / Free."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["anchor"] !== undefined)
+                    args["anchor"] = opts["anchor"];
+                if (opts["angularXMotion"] !== undefined)
+                    args["angularXMotion"] = opts["angularXMotion"];
+                if (opts["angularYMotion"] !== undefined)
+                    args["angularYMotion"] = opts["angularYMotion"];
+                if (opts["angularZMotion"] !== undefined)
+                    args["angularZMotion"] = opts["angularZMotion"];
+                if (opts["axis"] !== undefined)
+                    args["axis"] = opts["axis"];
+                if (opts["breakForce"] !== undefined)
+                    args["breakForce"] = opts["breakForce"];
+                if (opts["breakTorque"] !== undefined)
+                    args["breakTorque"] = opts["breakTorque"];
+                if (opts["connectedAnchor"] !== undefined)
+                    args["connectedAnchor"] = opts["connectedAnchor"];
+                if (opts["connectedBody"] !== undefined)
+                    args["connectedBody"] = opts["connectedBody"];
+                if (opts["damper"] !== undefined)
+                    args["damper"] = opts["damper"];
+                if (opts["dampingRatio"] !== undefined)
+                    args["dampingRatio"] = opts["dampingRatio"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["distance"] !== undefined)
+                    args["distance"] = opts["distance"];
+                if (opts["frequency"] !== undefined)
+                    args["frequency"] = opts["frequency"];
+                if (opts["jointIndex"] !== undefined)
+                    args["jointIndex"] = opts["jointIndex"];
+                if (opts["jointType"] !== undefined)
+                    args["jointType"] = opts["jointType"];
+                if (opts["limitMax"] !== undefined)
+                    args["limitMax"] = opts["limitMax"];
+                if (opts["limitMin"] !== undefined)
+                    args["limitMin"] = opts["limitMin"];
+                if (opts["maxDistance"] !== undefined)
+                    args["maxDistance"] = opts["maxDistance"];
+                if (opts["minDistance"] !== undefined)
+                    args["minDistance"] = opts["minDistance"];
+                if (opts["motorForce"] !== undefined)
+                    args["motorForce"] = opts["motorForce"];
+                if (opts["motorMaxTorque"] !== undefined)
+                    args["motorMaxTorque"] = opts["motorMaxTorque"];
+                if (opts["motorTargetVelocity"] !== undefined)
+                    args["motorTargetVelocity"] = opts["motorTargetVelocity"];
+                if (opts["spring"] !== undefined)
+                    args["spring"] = opts["spring"];
+                if (opts["springDamper"] !== undefined)
+                    args["springDamper"] = opts["springDamper"];
+                if (opts["springForce"] !== undefined)
+                    args["springForce"] = opts["springForce"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["tolerance"] !== undefined)
+                    args["tolerance"] = opts["tolerance"];
+                if (opts["useLimits"] !== undefined)
+                    args["useLimits"] = opts["useLimits"];
+                if (opts["useMotor"] !== undefined)
+                    args["useMotor"] = opts["useMotor"];
+                if (opts["useSpring"] !== undefined)
+                    args["useSpring"] = opts["useSpring"];
+                if (opts["wheelDamping"] !== undefined)
+                    args["wheelDamping"] = opts["wheelDamping"];
+                if (opts["wheelFrequency"] !== undefined)
+                    args["wheelFrequency"] = opts["wheelFrequency"];
+                if (opts["xMotion"] !== undefined)
+                    args["xMotion"] = opts["xMotion"];
+                if (opts["yMotion"] !== undefined)
+                    args["yMotion"] = opts["yMotion"];
+                if (opts["zMotion"] !== undefined)
+                    args["zMotion"] = opts["zMotion"];
+                return ctx.transport.callTool("physics-joint-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Joint / Remove
+    {
+        const cmd = program
+            .command("physics-joint-remove")
+            .description("Remove one or all Joint / Joint2D components from a GameObject. Pass jointIndex=-1 to remove every match.");
+        cmd.addOption(new Option("--jointIndex <int>", "Index 0-based, or -1 to remove all matching joints. Default 0.").argParser(coerceInteger));
+        cmd.addOption(new Option("--jointType <string>", "Optional joint-type filter (case-insensitive alias). 3D: fixed/hinge/spring/character/configurable. 2D: distance/fixed/friction/hinge/relative/slider/spring/target/wheel."));
+        cmd.addOption(new Option("--target <ref>", "GameObject hosting the joint(s) to remove. Required.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["jointIndex"] !== undefined)
+                    args["jointIndex"] = opts["jointIndex"];
+                if (opts["jointType"] !== undefined)
+                    args["jointType"] = opts["jointType"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("physics-joint-remove", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Linecast
+    {
+        const cmd = program
+            .command("physics-linecast")
+            .description("Linecast between two world-space points (3D or 2D).");
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--from <x,y,z|json>", "Segment start in world space.").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--layerMask <int>", "Layer mask bitmask. Defaults to all (~0) when null or -1.").argParser(coerceInteger));
+        cmd.addOption(new Option("--to <x,y,z|json>", "Segment end in world space.").argParser(coerceVec3).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["from"] !== undefined)
+                    args["from"] = opts["from"];
+                if (opts["layerMask"] !== undefined)
+                    args["layerMask"] = opts["layerMask"];
+                if (opts["to"] !== undefined)
+                    args["to"] = opts["to"];
+                return ctx.transport.callTool("physics-linecast", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Material / Assign
+    {
+        const cmd = program
+            .command("physics-material-assign")
+            .description("Assign a physics material asset to a collider on a GameObject.");
+        cmd.addOption(new Option("--materialPath <string>", "Asset path of the physics material to assign.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject to receive the physics material.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["materialPath"] !== undefined)
+                    args["materialPath"] = opts["materialPath"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("physics-material-assign", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Material / Configure
+    {
+        const cmd = program
+            .command("physics-material-configure")
+            .description("Mutate properties of an existing physics material asset.");
+        cmd.addOption(new Option("--bounceCombine <string>", "Bounce combine mode (3D only): Average, Minimum, Multiply, Maximum."));
+        cmd.addOption(new Option("--bounciness <num>", "Bounciness. Applies to both dimensions.").argParser(coerceNumber));
+        cmd.addOption(new Option("--dimension <string>", "Dimension override: '3d' or '2d'. If omitted, inferred from the file extension."));
+        cmd.addOption(new Option("--dynamicFriction <num>", "Dynamic friction (3D only).").argParser(coerceNumber));
+        cmd.addOption(new Option("--friction <num>", "Combined friction value (2D only).").argParser(coerceNumber));
+        cmd.addOption(new Option("--frictionCombine <string>", "Friction combine mode (3D only): Average, Minimum, Multiply, Maximum."));
+        cmd.addOption(new Option("--path <string>", "Asset path of the existing physics material.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--staticFriction <num>", "Static friction (3D only).").argParser(coerceNumber));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["bounceCombine"] !== undefined)
+                    args["bounceCombine"] = opts["bounceCombine"];
+                if (opts["bounciness"] !== undefined)
+                    args["bounciness"] = opts["bounciness"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["dynamicFriction"] !== undefined)
+                    args["dynamicFriction"] = opts["dynamicFriction"];
+                if (opts["friction"] !== undefined)
+                    args["friction"] = opts["friction"];
+                if (opts["frictionCombine"] !== undefined)
+                    args["frictionCombine"] = opts["frictionCombine"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["staticFriction"] !== undefined)
+                    args["staticFriction"] = opts["staticFriction"];
+                return ctx.transport.callTool("physics-material-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Material / Create
+    {
+        const cmd = program
+            .command("physics-material-create")
+            .description("Create a new physics material asset (3D or 2D). Path must live under 'Assets/' and end with '.physicMaterial' (3D) or '.physicsMaterial2D' (2D).");
+        cmd.addOption(new Option("--bounceCombine <string>", "Bounce combine mode (3D only): Average, Minimum, Multiply, Maximum."));
+        cmd.addOption(new Option("--bounciness <num>", "Bounciness. Default 0. Applies to both dimensions.").argParser(coerceNumber));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--dynamicFriction <num>", "Dynamic friction (3D only). Default 0.6.").argParser(coerceNumber));
+        cmd.addOption(new Option("--friction <num>", "Combined friction value (2D only). Default 0.4.").argParser(coerceNumber));
+        cmd.addOption(new Option("--frictionCombine <string>", "Friction combine mode (3D only): Average, Minimum, Multiply, Maximum."));
+        cmd.addOption(new Option("--overwrite <bool>", "If true, overwrite an existing asset at the same path. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.physicMaterial' (3D) or '.physicsMaterial2D' (2D).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--staticFriction <num>", "Static friction (3D only). Default 0.6.").argParser(coerceNumber));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["bounceCombine"] !== undefined)
+                    args["bounceCombine"] = opts["bounceCombine"];
+                if (opts["bounciness"] !== undefined)
+                    args["bounciness"] = opts["bounciness"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["dynamicFriction"] !== undefined)
+                    args["dynamicFriction"] = opts["dynamicFriction"];
+                if (opts["friction"] !== undefined)
+                    args["friction"] = opts["friction"];
+                if (opts["frictionCombine"] !== undefined)
+                    args["frictionCombine"] = opts["frictionCombine"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["staticFriction"] !== undefined)
+                    args["staticFriction"] = opts["staticFriction"];
+                return ctx.transport.callTool("physics-material-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Overlap
+    {
+        const cmd = program
+            .command("physics-overlap")
+            .description("Find all colliders overlapping a primitive volume (3D or 2D).");
+        cmd.addOption(new Option("--center <x,y,z|json>", "Volume center in world space.").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--halfExtents <x,y,z|json>", "Box only: half-extents (Vector3).").argParser(coerceVec3));
+        cmd.addOption(new Option("--layerMask <int>", "Layer mask bitmask. Defaults to all (~0) when null or -1.").argParser(coerceInteger));
+        cmd.addOption(new Option("--radius <num>", "Sphere only: radius.").argParser(coerceNumber));
+        cmd.addOption(new Option("--rotation <json>", "Box only: rotation (Quaternion). Identity when null.").argParser(coerceJson));
+        cmd.addOption(new Option("--shape <string>", "Shape: 'box' | 'sphere'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["center"] !== undefined)
+                    args["center"] = opts["center"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["halfExtents"] !== undefined)
+                    args["halfExtents"] = opts["halfExtents"];
+                if (opts["layerMask"] !== undefined)
+                    args["layerMask"] = opts["layerMask"];
+                if (opts["radius"] !== undefined)
+                    args["radius"] = opts["radius"];
+                if (opts["rotation"] !== undefined)
+                    args["rotation"] = opts["rotation"];
+                if (opts["shape"] !== undefined)
+                    args["shape"] = opts["shape"];
+                return ctx.transport.callTool("physics-overlap", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Raycast
+    {
+        const cmd = program
+            .command("physics-raycast")
+            .description("Cast a ray and return the first hit (3D or 2D).");
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--direction <x,y,z|json>", "Ray direction (will be normalized).").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--layerMask <int>", "Layer mask bitmask. Defaults to all (~0) when null or -1.").argParser(coerceInteger));
+        cmd.addOption(new Option("--maxDistance <num>", "Max distance. Defaults to Mathf.Infinity when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--origin <x,y,z|json>", "Ray origin in world space.").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--queryTriggerInteraction <string>", "Query trigger interaction: 'UseGlobal' (default) | 'Collide' | 'Ignore'."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["direction"] !== undefined)
+                    args["direction"] = opts["direction"];
+                if (opts["layerMask"] !== undefined)
+                    args["layerMask"] = opts["layerMask"];
+                if (opts["maxDistance"] !== undefined)
+                    args["maxDistance"] = opts["maxDistance"];
+                if (opts["origin"] !== undefined)
+                    args["origin"] = opts["origin"];
+                if (opts["queryTriggerInteraction"] !== undefined)
+                    args["queryTriggerInteraction"] = opts["queryTriggerInteraction"];
+                return ctx.transport.callTool("physics-raycast", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Raycast / All
+    {
+        const cmd = program
+            .command("physics-raycast-all")
+            .description("Cast a ray and return every collider it hits (3D or 2D).");
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--direction <x,y,z|json>", "Ray direction (will be normalized).").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--layerMask <int>", "Layer mask bitmask. Defaults to all (~0) when null or -1.").argParser(coerceInteger));
+        cmd.addOption(new Option("--maxDistance <num>", "Max distance. Defaults to Mathf.Infinity when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--origin <x,y,z|json>", "Ray origin in world space.").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--queryTriggerInteraction <string>", "Query trigger interaction: 'UseGlobal' (default) | 'Collide' | 'Ignore'."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["direction"] !== undefined)
+                    args["direction"] = opts["direction"];
+                if (opts["layerMask"] !== undefined)
+                    args["layerMask"] = opts["layerMask"];
+                if (opts["maxDistance"] !== undefined)
+                    args["maxDistance"] = opts["maxDistance"];
+                if (opts["origin"] !== undefined)
+                    args["origin"] = opts["origin"];
+                if (opts["queryTriggerInteraction"] !== undefined)
+                    args["queryTriggerInteraction"] = opts["queryTriggerInteraction"];
+                return ctx.transport.callTool("physics-raycast-all", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Rigidbody / Configure
+    {
+        const cmd = program
+            .command("physics-rigidbody-configure")
+            .description("Mutate fields of a Rigidbody / Rigidbody2D on the target GameObject.");
+        cmd.addOption(new Option("--angularDrag <num>", "Angular drag / damping. Maps to Unity 6 angularDamping.").argParser(coerceNumber));
+        cmd.addOption(new Option("--bodyType <string>", "Body type (2D only): Dynamic, Kinematic, Static."));
+        cmd.addOption(new Option("--collisionDetection <string>", "Collision detection mode. 3D: Discrete / Continuous / ContinuousDynamic / ContinuousSpeculative. 2D: Discrete / Continuous."));
+        cmd.addOption(new Option("--constraints <string>", "Constraints flags. Comma-separated enum names (e.g. 'FreezePositionX, FreezeRotationY') or an integer bitmask."));
+        cmd.addOption(new Option("--dimension <string>", "Dimension override: '3d' or '2d'. If omitted, inferred from the present component."));
+        cmd.addOption(new Option("--drag <num>", "Linear drag / damping. Maps to Unity 6 linearDamping.").argParser(coerceNumber));
+        cmd.addOption(new Option("--gravityScale <num>", "Gravity scale (2D only).").argParser(coerceNumber));
+        cmd.addOption(new Option("--interpolation <string>", "Interpolation mode (3D only): None, Interpolate, Extrapolate."));
+        cmd.addOption(new Option("--isKinematic <bool>", "Whether the body is kinematic.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--mass <num>", "Mass.").argParser(coerceNumber));
+        cmd.addOption(new Option("--simulated <bool>", "Whether the 2D body is simulated.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject with a Rigidbody or Rigidbody2D.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--useGravity <bool>", "Whether 3D gravity is applied (3D only).").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["angularDrag"] !== undefined)
+                    args["angularDrag"] = opts["angularDrag"];
+                if (opts["bodyType"] !== undefined)
+                    args["bodyType"] = opts["bodyType"];
+                if (opts["collisionDetection"] !== undefined)
+                    args["collisionDetection"] = opts["collisionDetection"];
+                if (opts["constraints"] !== undefined)
+                    args["constraints"] = opts["constraints"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["drag"] !== undefined)
+                    args["drag"] = opts["drag"];
+                if (opts["gravityScale"] !== undefined)
+                    args["gravityScale"] = opts["gravityScale"];
+                if (opts["interpolation"] !== undefined)
+                    args["interpolation"] = opts["interpolation"];
+                if (opts["isKinematic"] !== undefined)
+                    args["isKinematic"] = opts["isKinematic"];
+                if (opts["mass"] !== undefined)
+                    args["mass"] = opts["mass"];
+                if (opts["simulated"] !== undefined)
+                    args["simulated"] = opts["simulated"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["useGravity"] !== undefined)
+                    args["useGravity"] = opts["useGravity"];
+                return ctx.transport.callTool("physics-rigidbody-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Rigidbody / Get
+    {
+        const cmd = program
+            .command("physics-rigidbody-get")
+            .description("Snapshot the Rigidbody / Rigidbody2D state on the target GameObject.");
+        cmd.addOption(new Option("--dimension <string>", "Dimension override: '3d' or '2d'. If omitted, inferred from the present component."));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject with a Rigidbody or Rigidbody2D.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("physics-rigidbody-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Settings / Get
+    {
+        const cmd = program
+            .command("physics-settings-get")
+            .description("Read current physics settings (gravity, solver iterations, thresholds, query flags) for the requested dimension.");
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                return ctx.transport.callTool("physics-settings-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Settings / Set
+    {
+        const cmd = program
+            .command("physics-settings-set")
+            .description("Mutate physics settings for the requested dimension (gravity, thresholds, solver counts, global query flags). Only non-null arguments are applied.");
+        cmd.addOption(new Option("--autoSimulation <bool>", "Auto-simulation enabled. Maps to Physics.simulationMode (3D) and Physics2D.simulationMode (2D).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--bounceThreshold <num>", "Bounce threshold velocity. Applies to both 2D and 3D.").argParser(coerceNumber));
+        cmd.addOption(new Option("--defaultContactOffset <num>", "Default contact offset (3D only).").argParser(coerceNumber));
+        cmd.addOption(new Option("--defaultMaxAngularSpeed <num>", "Default maximum angular speed (3D only).").argParser(coerceNumber));
+        cmd.addOption(new Option("--defaultSolverIterations <int>", "Default solver iterations (3D only).").argParser(coerceInteger));
+        cmd.addOption(new Option("--defaultSolverVelocityIterations <int>", "Default solver velocity iterations (3D only).").argParser(coerceInteger));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--gravity <x,y,z|json>", "Gravity vector (x,y,z). For 2D the z component is ignored.").argParser(coerceVec3));
+        cmd.addOption(new Option("--positionIterations <int>", "Number of position iterations per simulation step (2D only).").argParser(coerceInteger));
+        cmd.addOption(new Option("--queriesHitBackfaces <bool>", "Whether queries hit back-faces globally (3D only).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--queriesHitTriggers <bool>", "Whether queries (raycast / overlap / cast) collide with triggers globally.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--sleepThreshold <num>", "Sleep threshold (3D only).").argParser(coerceNumber));
+        cmd.addOption(new Option("--velocityIterations <int>", "Number of velocity iterations per simulation step (2D only).").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["autoSimulation"] !== undefined)
+                    args["autoSimulation"] = opts["autoSimulation"];
+                if (opts["bounceThreshold"] !== undefined)
+                    args["bounceThreshold"] = opts["bounceThreshold"];
+                if (opts["defaultContactOffset"] !== undefined)
+                    args["defaultContactOffset"] = opts["defaultContactOffset"];
+                if (opts["defaultMaxAngularSpeed"] !== undefined)
+                    args["defaultMaxAngularSpeed"] = opts["defaultMaxAngularSpeed"];
+                if (opts["defaultSolverIterations"] !== undefined)
+                    args["defaultSolverIterations"] = opts["defaultSolverIterations"];
+                if (opts["defaultSolverVelocityIterations"] !== undefined)
+                    args["defaultSolverVelocityIterations"] = opts["defaultSolverVelocityIterations"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["gravity"] !== undefined)
+                    args["gravity"] = opts["gravity"];
+                if (opts["positionIterations"] !== undefined)
+                    args["positionIterations"] = opts["positionIterations"];
+                if (opts["queriesHitBackfaces"] !== undefined)
+                    args["queriesHitBackfaces"] = opts["queriesHitBackfaces"];
+                if (opts["queriesHitTriggers"] !== undefined)
+                    args["queriesHitTriggers"] = opts["queriesHitTriggers"];
+                if (opts["sleepThreshold"] !== undefined)
+                    args["sleepThreshold"] = opts["sleepThreshold"];
+                if (opts["velocityIterations"] !== undefined)
+                    args["velocityIterations"] = opts["velocityIterations"];
+                return ctx.transport.callTool("physics-settings-set", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Shapecast
+    {
+        const cmd = program
+            .command("physics-shapecast")
+            .description("Shapecast a primitive volume (box/sphere/capsule) and return the colliders it hits.");
+        cmd.addOption(new Option("--capsulePoint2 <x,y,z|json>", "Capsule only: world-space position of the second end-cap (the first is `origin`).").argParser(coerceVec3));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        cmd.addOption(new Option("--direction <x,y,z|json>", "Cast direction (normalized internally).").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--halfExtents <x,y,z|json>", "Box only: half-extents (Vector3). For 2D capsule it is also used as the capsule size (x=width, y=height).").argParser(coerceVec3));
+        cmd.addOption(new Option("--layerMask <int>", "Layer mask bitmask. Defaults to all (~0) when null or -1.").argParser(coerceInteger));
+        cmd.addOption(new Option("--maxDistance <num>", "Max cast distance. Defaults to Mathf.Infinity when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--origin <x,y,z|json>", "Shape center / start position in world space.").argParser(coerceVec3).makeOptionMandatory(true));
+        cmd.addOption(new Option("--radius <num>", "Sphere / capsule radius.").argParser(coerceNumber));
+        cmd.addOption(new Option("--returnAll <bool>", "When true, returns every hit along the cast. When false, returns at most the closest hit.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--rotation <json>", "Box only: rotation (Quaternion) of the box. Identity when null.").argParser(coerceJson));
+        cmd.addOption(new Option("--shape <string>", "Shape: 'box' | 'sphere' | 'capsule'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["capsulePoint2"] !== undefined)
+                    args["capsulePoint2"] = opts["capsulePoint2"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                if (opts["direction"] !== undefined)
+                    args["direction"] = opts["direction"];
+                if (opts["halfExtents"] !== undefined)
+                    args["halfExtents"] = opts["halfExtents"];
+                if (opts["layerMask"] !== undefined)
+                    args["layerMask"] = opts["layerMask"];
+                if (opts["maxDistance"] !== undefined)
+                    args["maxDistance"] = opts["maxDistance"];
+                if (opts["origin"] !== undefined)
+                    args["origin"] = opts["origin"];
+                if (opts["radius"] !== undefined)
+                    args["radius"] = opts["radius"];
+                if (opts["returnAll"] !== undefined)
+                    args["returnAll"] = opts["returnAll"];
+                if (opts["rotation"] !== undefined)
+                    args["rotation"] = opts["rotation"];
+                if (opts["shape"] !== undefined)
+                    args["shape"] = opts["shape"];
+                return ctx.transport.callTool("physics-shapecast", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Simulate / Step
+    {
+        const cmd = program
+            .command("physics-simulate-step")
+            .description("Advance the physics simulation by one step in Edit Mode (3D or 2D).");
+        cmd.addOption(new Option("--deltaTime <num>", "Time step in seconds. Defaults to Time.fixedDeltaTime when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--dimension <string>", "Dimension: '3d' (default) or '2d'."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["deltaTime"] !== undefined)
+                    args["deltaTime"] = opts["deltaTime"];
+                if (opts["dimension"] !== undefined)
+                    args["dimension"] = opts["dimension"];
+                return ctx.transport.callTool("physics-simulate-step", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Physics / Validate
+    {
+        const cmd = program
+            .command("physics-validate")
+            .description("Scan all loaded scenes for common physics misconfigurations and return a list of issues.");
+        cmd.addOption(new Option("--includeInfo <bool>", "When true, also emit Info-severity findings. Default false.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeInfo"] !== undefined)
+                    args["includeInfo"] = opts["includeInfo"];
+                return ctx.transport.callTool("physics-validate", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Get Counters
+    {
+        const cmd = program
+            .command("profiler-get-counters")
+            .description("Sample ProfilerRecorder counters in a category. Pass explicit names or omit to enumerate all in the category.");
+        cmd.addOption(new Option("--category <string>", "ProfilerCategory name. Examples: Render, Scripts, Memory, Physics, Animation, Audio.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--counters <json>", "Optional list of explicit counter names. Omit to read every counter available in the category.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["category"] !== undefined)
+                    args["category"] = opts["category"];
+                if (opts["counters"] !== undefined)
+                    args["counters"] = opts["counters"];
+                return ctx.transport.callTool("profiler-get-counters", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Get Frame Timing
+    {
+        const cmd = program
+            .command("profiler-get-frame-timing")
+            .description("Capture the latest FrameTimingManager frame timing data.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("profiler-get-frame-timing", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Get Object Memory
+    {
+        const cmd = program
+            .command("profiler-get-object-memory")
+            .description("Return runtime memory size for a scene or asset object via Profiler.GetRuntimeMemorySizeLong.");
+        cmd.addOption(new Option("--objectPath <string>", "Scene hierarchy path (e.g. '/Player/Mesh') or asset path (e.g. 'Assets/Textures/hero.png').").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["objectPath"] !== undefined)
+                    args["objectPath"] = opts["objectPath"];
+                return ctx.transport.callTool("profiler-get-object-memory", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Memory Snapshot / Compare
+    {
+        const cmd = program
+            .command("profiler-memory-snapshot-compare")
+            .description("Compare two .snap files at file-metadata level (size and creation-time delta).");
+        cmd.addOption(new Option("--snapshotA <string>", "Path to the first .snap file.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--snapshotB <string>", "Path to the second .snap file.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["snapshotA"] !== undefined)
+                    args["snapshotA"] = opts["snapshotA"];
+                if (opts["snapshotB"] !== undefined)
+                    args["snapshotB"] = opts["snapshotB"];
+                return ctx.transport.callTool("profiler-memory-snapshot-compare", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Memory Snapshot / List
+    {
+        const cmd = program
+            .command("profiler-memory-snapshot-list")
+            .description("List .snap memory snapshot files in known or supplied directories.");
+        cmd.addOption(new Option("--searchPath <string>", "Optional directory to search for .snap files. When empty, scans the default snapshot directories."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["searchPath"] !== undefined)
+                    args["searchPath"] = opts["searchPath"];
+                return ctx.transport.callTool("profiler-memory-snapshot-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Memory Snapshot / Take
+    {
+        const cmd = program
+            .command("profiler-memory-snapshot-take")
+            .description("Capture a Unity memory snapshot to a .snap file (requires com.unity.memoryprofiler).");
+        cmd.addOption(new Option("--snapshotPath <string>", "Output path for the .snap file. Optional — when empty, writes to Application.temporaryCachePath/MemoryCaptures/ with a timestamped name."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["snapshotPath"] !== undefined)
+                    args["snapshotPath"] = opts["snapshotPath"];
+                return ctx.transport.callTool("profiler-memory-snapshot-take", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Set Areas
+    {
+        const cmd = program
+            .command("profiler-set-areas")
+            .description("Toggle Unity ProfilerArea values via Profiler.SetAreaEnabled.");
+        cmd.addOption(new Option("--areas <json>", "Dictionary of ProfilerArea name -> bool. Use 'profiler-status' for valid area names.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["areas"] !== undefined)
+                    args["areas"] = opts["areas"];
+                return ctx.transport.callTool("profiler-set-areas", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Start
+    {
+        const cmd = program
+            .command("profiler-start")
+            .description("Enable the Unity Profiler. Optionally record to a .raw file and enable allocation callstacks.");
+        cmd.addOption(new Option("--enableCallstacks <bool>", "If true, enables Profiler.enableAllocationCallstacks. Default: false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--logFile <string>", "Absolute path for an optional binary '.raw' profiler recording. The parent directory must exist."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["enableCallstacks"] !== undefined)
+                    args["enableCallstacks"] = opts["enableCallstacks"];
+                if (opts["logFile"] !== undefined)
+                    args["logFile"] = opts["logFile"];
+                return ctx.transport.callTool("profiler-start", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Status
+    {
+        const cmd = program
+            .command("profiler-status")
+            .description("Return Unity Profiler state and the per-area enabled map.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("profiler-status", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Profiler / Stop
+    {
+        const cmd = program
+            .command("profiler-stop")
+            .description("Disable the Unity Profiler and stop recording.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("profiler-stop", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Method C# / Call
+    {
+        const cmd = program
+            .command("reflection-method-call")
+            .description("Call C# method. Any method could be called, even private methods. It requires to receive proper method schema. Use 'reflection-method-find' to find available method before using it. Receives input parameters and returns result.");
+        cmd.addOption(new Option("--executeInMainThread <bool>", "Set to true if the method should be executed in the main thread. Otherwise, set to false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--filter <json>", "Method reference. Used to find method in codebase of the project.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--inputParameters <json-array>", "Method input parameters. Per each parameter specify: type - full type name of the object to call method on, name - parameter name, value - serialized object value (it will be deserialized to the specified type).").argParser(coerceJson));
+        cmd.addOption(new Option("--knownNamespace <bool>", "Set to true if 'Namespace' is known and full namespace name is specified in the 'filter.Namespace' property. Otherwise, set to false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--methodNameMatchLevel <int>", "Minimal match level for 'MethodName'. 0 - ignore 'filter.MethodName', 1 - contains ignoring case (default value), 2 - contains case sensitive, 3 - starts with ignoring case, 4 - starts with case sensitive, 5 - equals ignoring case, 6 - equals case sensitive.").argParser(coerceInteger));
+        cmd.addOption(new Option("--parametersMatchLevel <int>", "Minimal match level for 'Parameters'. 0 - ignore 'filter.Parameters', 1 - parameters count is the same, 2 - equals (default value).").argParser(coerceInteger));
+        cmd.addOption(new Option("--targetObject <json>", "Specify target object to call method on. Should be null if the method is static or if there is no specific target instance. New instance of the specified class will be created if the method is instance method and the targetObject is null. Required: type - full type name of the object to call method on, value - serialized object value (it will be deserialized to the specified type).").argParser(coerceJson));
+        cmd.addOption(new Option("--typeNameMatchLevel <int>", "Minimal match level for 'typeName'. 0 - ignore 'filter.typeName', 1 - contains ignoring case (default value), 2 - contains case sensitive, 3 - starts with ignoring case, 4 - starts with case sensitive, 5 - equals ignoring case, 6 - equals case sensitive.").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["executeInMainThread"] !== undefined)
+                    args["executeInMainThread"] = opts["executeInMainThread"];
+                if (opts["filter"] !== undefined)
+                    args["filter"] = opts["filter"];
+                if (opts["inputParameters"] !== undefined)
+                    args["inputParameters"] = opts["inputParameters"];
+                if (opts["knownNamespace"] !== undefined)
+                    args["knownNamespace"] = opts["knownNamespace"];
+                if (opts["methodNameMatchLevel"] !== undefined)
+                    args["methodNameMatchLevel"] = opts["methodNameMatchLevel"];
+                if (opts["parametersMatchLevel"] !== undefined)
+                    args["parametersMatchLevel"] = opts["parametersMatchLevel"];
+                if (opts["targetObject"] !== undefined)
+                    args["targetObject"] = opts["targetObject"];
+                if (opts["typeNameMatchLevel"] !== undefined)
+                    args["typeNameMatchLevel"] = opts["typeNameMatchLevel"];
+                return ctx.transport.callTool("reflection-method-call", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Method C# / Find
+    {
+        const cmd = program
+            .command("reflection-method-find")
+            .description("Find method in the project using C# Reflection. It looks for all assemblies in the project and finds method by its name, class name and parameters. Even private methods are available. Use 'reflection-method-call' to call the method after finding it.");
+        cmd.addOption(new Option("--filter <json>", "Method reference. Used to find method in codebase of the project.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--knownNamespace <bool>", "Set to true if 'Namespace' is known and full namespace name is specified in the 'filter.Namespace' property. Otherwise, set to false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--methodNameMatchLevel <int>", "Minimal match level for 'MethodName'. 0 - ignore 'filter.MethodName', 1 - contains ignoring case (default value), 2 - contains case sensitive, 3 - starts with ignoring case, 4 - starts with case sensitive, 5 - equals ignoring case, 6 - equals case sensitive.").argParser(coerceInteger));
+        cmd.addOption(new Option("--parametersMatchLevel <int>", "Minimal match level for 'Parameters'. 0 - ignore 'filter.Parameters' (default value), 1 - parameters count is the same, 2 - equals.").argParser(coerceInteger));
+        cmd.addOption(new Option("--typeNameMatchLevel <int>", "Minimal match level for 'typeName'. 0 - ignore 'filter.typeName', 1 - contains ignoring case (default value), 2 - contains case sensitive, 3 - starts with ignoring case, 4 - starts with case sensitive, 5 - equals ignoring case, 6 - equals case sensitive.").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["filter"] !== undefined)
+                    args["filter"] = opts["filter"];
+                if (opts["knownNamespace"] !== undefined)
+                    args["knownNamespace"] = opts["knownNamespace"];
+                if (opts["methodNameMatchLevel"] !== undefined)
+                    args["methodNameMatchLevel"] = opts["methodNameMatchLevel"];
+                if (opts["parametersMatchLevel"] !== undefined)
+                    args["parametersMatchLevel"] = opts["parametersMatchLevel"];
+                if (opts["typeNameMatchLevel"] !== undefined)
+                    args["typeNameMatchLevel"] = opts["typeNameMatchLevel"];
+                return ctx.transport.callTool("reflection-method-find", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / Create
+    {
+        const cmd = program
+            .command("scene-create")
+            .description("Create new scene in the project assets. Use 'scene-list-opened' tool to list all opened scenes after creation.");
+        cmd.addOption(new Option("--newSceneMode <value>", "newSceneMode").choices(["Single", "Additive"]));
+        cmd.addOption(new Option("--newSceneSetup <value>", "newSceneSetup").choices(["EmptyScene", "DefaultGameObjects"]));
+        cmd.addOption(new Option("--path <string>", "Path to the scene file. Should end with \".unity\" extension.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["newSceneMode"] !== undefined)
+                    args["newSceneMode"] = opts["newSceneMode"];
+                if (opts["newSceneSetup"] !== undefined)
+                    args["newSceneSetup"] = opts["newSceneSetup"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("scene-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / Get Data
+    {
+        const cmd = program
+            .command("scene-get-data")
+            .description("This tool retrieves the list of root GameObjects in the specified scene. Use 'scene-list-opened' tool to get the list of all opened scenes. Path-scoped reads (token-saving): supply 'paths' (a list of paths) to read only the listed fields/elements from the scene's root-GameObjects array via Reflector.TryReadAt, or 'viewQuery' (a ViewQuery) to navigate/filter the same array via Reflector.View. The result populates 'Data' on the returned SceneData. These two parameters are mutually exclusive. Path syntax: 'fieldName', 'nested/field', 'arrayField/[i]', 'dictField/[key]'. Leading '#/' is stripped. Example: paths=['[0]/name'] reads the name of the first root GameObject.");
+        cmd.addOption(new Option("--includeBounds <bool>", "If true, includes bounding box information for GameObjects.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeChildrenDepth <int>", "Determines the depth of the hierarchy to include.").argParser(coerceInteger));
+        cmd.addOption(new Option("--includeData <bool>", "If true, includes component data for GameObjects.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeRootGameObjects <bool>", "If true, includes root GameObjects in the scene data.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--openedSceneName <string>", "Name of the opened scene. If empty or null, the active scene will be used."));
+        cmd.addOption(new Option("--paths <json>", "Optional. List of paths to read individually via Reflector.TryReadAt against the scene's root-GameObjects array. Path syntax: 'fieldName', '[i]/field', '[i]/component/[j]/property'. Mutually exclusive with 'viewQuery'.").argParser(coerceJson));
+        cmd.addOption(new Option("--viewQuery <json>", "Optional. View-query filter routed through Reflector.View on the scene's root-GameObjects array. Mutually exclusive with 'paths'.").argParser(coerceJson));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeBounds"] !== undefined)
+                    args["includeBounds"] = opts["includeBounds"];
+                if (opts["includeChildrenDepth"] !== undefined)
+                    args["includeChildrenDepth"] = opts["includeChildrenDepth"];
+                if (opts["includeData"] !== undefined)
+                    args["includeData"] = opts["includeData"];
+                if (opts["includeRootGameObjects"] !== undefined)
+                    args["includeRootGameObjects"] = opts["includeRootGameObjects"];
+                if (opts["openedSceneName"] !== undefined)
+                    args["openedSceneName"] = opts["openedSceneName"];
+                if (opts["paths"] !== undefined)
+                    args["paths"] = opts["paths"];
+                if (opts["viewQuery"] !== undefined)
+                    args["viewQuery"] = opts["viewQuery"];
+                return ctx.transport.callTool("scene-get-data", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / List Opened
+    {
+        const cmd = program
+            .command("scene-list-opened")
+            .description("Returns the list of currently opened scenes in Unity Editor. Use 'scene-get-data' tool to get detailed information about a specific scene.");
+        cmd.addOption(new Option("--nothing <string>", "nothing"));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["nothing"] !== undefined)
+                    args["nothing"] = opts["nothing"];
+                return ctx.transport.callTool("scene-list-opened", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / Open
+    {
+        const cmd = program
+            .command("scene-open")
+            .description("Open scene from the project asset file. Use 'assets-find' tool to find the scene asset first.");
+        cmd.addOption(new Option("--loadSceneMode <value>", "Open scene mode. Single: closes the current scenes and opens a new one. Additive: keeps the current scene and opens additional one.").choices(["Single", "Additive", "AdditiveWithoutLoading"]));
+        cmd.addOption(new Option("--sceneRef <json>", "Reference to UnityEngine.Object asset instance. It could be Material, ScriptableObject, Prefab, and any other Asset. Anything located in the Assets and Packages folders.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["loadSceneMode"] !== undefined)
+                    args["loadSceneMode"] = opts["loadSceneMode"];
+                if (opts["sceneRef"] !== undefined)
+                    args["sceneRef"] = opts["sceneRef"];
+                return ctx.transport.callTool("scene-open", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / Save
+    {
+        const cmd = program
+            .command("scene-save")
+            .description("Save Opened scene to the asset file. Use 'scene-list-opened' tool to get the list of all opened scenes.");
+        cmd.addOption(new Option("--openedSceneName <string>", "Name of the opened scene that should be saved. Could be empty if need to save the current active scene."));
+        cmd.addOption(new Option("--path <string>", "Path to the scene file. Should end with \".unity\". If null or empty save to the existed scene asset file."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["openedSceneName"] !== undefined)
+                    args["openedSceneName"] = opts["openedSceneName"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("scene-save", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / Set Active
+    {
+        const cmd = program
+            .command("scene-set-active")
+            .description("Set the specified opened scene as the active scene. Use 'scene-list-opened' tool to get the list of all opened scenes.");
+        cmd.addOption(new Option("--sceneRef <json>", "Reference to UnityEngine.Object asset instance. It could be Material, ScriptableObject, Prefab, and any other Asset. Anything located in the Assets and Packages folders.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["sceneRef"] !== undefined)
+                    args["sceneRef"] = opts["sceneRef"];
+                return ctx.transport.callTool("scene-set-active", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Scene / Unload
+    {
+        const cmd = program
+            .command("scene-unload")
+            .description("Unload scene from the Opened scenes in Unity Editor. Use 'scene-list-opened' tool to get the list of all opened scenes.");
+        cmd.addOption(new Option("--name <string>", "Name of the loaded scene.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["name"] !== undefined)
+                    args["name"] = opts["name"];
+                return ctx.transport.callTool("scene-unload", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Screenshot / Camera
+    {
+        const cmd = program
+            .command("screenshot-camera")
+            .description("Captures a screenshot from a camera and returns it as an image. If no camera is specified, uses the Main Camera. Returns the image directly for visual inspection by the LLM.");
+        cmd.addOption(new Option("--asynchronous <bool>", "Queue file/metadata capture as a durable operation. Inline image capture remains synchronous.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--cameraRef <ref>", "Reference to the camera GameObject. If not specified, uses the Main Camera.").argParser(coerceGameObjectRef));
+        cmd.addOption(new Option("--height <int>", "Height of the screenshot in pixels.").argParser(coerceInteger));
+        cmd.addOption(new Option("--metadataOnly <bool>", "Return bounded metadata without inline base64. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--outputFile <string>", "Project-relative PNG output path. When set, returns metadata without base64."));
+        cmd.addOption(new Option("--width <int>", "Width of the screenshot in pixels.").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["asynchronous"] !== undefined)
+                    args["asynchronous"] = opts["asynchronous"];
+                if (opts["cameraRef"] !== undefined)
+                    args["cameraRef"] = opts["cameraRef"];
+                if (opts["height"] !== undefined)
+                    args["height"] = opts["height"];
+                if (opts["metadataOnly"] !== undefined)
+                    args["metadataOnly"] = opts["metadataOnly"];
+                if (opts["outputFile"] !== undefined)
+                    args["outputFile"] = opts["outputFile"];
+                if (opts["width"] !== undefined)
+                    args["width"] = opts["width"];
+                return ctx.transport.callTool("screenshot-camera", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Screenshot / Game View
+    {
+        const cmd = program
+            .command("screenshot-game-view")
+            .description("Captures a screenshot from the Unity Editor Game View and returns it as an image. Reads the Game View's own render texture directly via the Unity Editor API. The image size matches the current Game View resolution. Returns the image directly for visual inspection by the LLM.");
+        cmd.addOption(new Option("--asynchronous <bool>", "Queue file/metadata capture as a durable operation. Inline image capture remains synchronous.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--metadataOnly <bool>", "Return bounded metadata without inline base64. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--outputFile <string>", "Project-relative PNG output path. When set, returns metadata without base64."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["asynchronous"] !== undefined)
+                    args["asynchronous"] = opts["asynchronous"];
+                if (opts["metadataOnly"] !== undefined)
+                    args["metadataOnly"] = opts["metadataOnly"];
+                if (opts["outputFile"] !== undefined)
+                    args["outputFile"] = opts["outputFile"];
+                return ctx.transport.callTool("screenshot-game-view", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Screenshot / Isolated GameObject
+    {
+        const cmd = program
+            .command("screenshot-isolated")
+            .description("Renders a screenshot of a target GameObject with configurable isolation, background, camera angle, and lighting. When isolated=true (default), only the target object is visible via layer-based culling and inactive children of the target are temporarily activated for the render (their OnEnable callbacks may fire — restored in finally, but side effects like audio/network/animation events are not undoable). When isolated=false, the existing scene state is rendered as-is without activating inactive objects. Supports custom multi-light setups via JSON. Returns a base64-encoded PNG.");
+        cmd.addOption(new Option("--asynchronous <bool>", "Queue file/metadata capture as a durable operation. Inline image capture remains synchronous.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--backgroundColor <string>", "Hex background color (e.g. '#404040'). Only used when backgroundMode is SolidColor."));
+        cmd.addOption(new Option("--backgroundMode <json>", "Background mode. Default: SolidColor.").argParser(coerceJson));
+        cmd.addOption(new Option("--cameraView <json>", "Camera angle relative to the target object's bounding box. Default: Front.").argParser(coerceJson));
+        cmd.addOption(new Option("--farClipPlane <num>", "Camera far clip plane distance. Default: 1000.").argParser(coerceNumber));
+        cmd.addOption(new Option("--fieldOfView <num>", "Camera vertical field of view in degrees. Default: 60.").argParser(coerceNumber));
+        cmd.addOption(new Option("--gameObjectRef <ref>", "Reference to the target GameObject (by instanceId, path, or name).").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--includeChildren <bool>", "Include child GameObjects in the render. Default: true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--isolated <bool>", "When true, renders only the target object using layer-based culling. When false, renders the full scene from the computed camera position. Default: true.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--lights <string>", "JSON array of light configurations. Each object defines type, color, intensity, rotation, position, range, spotAngle, shadows, etc. When null, a default white directional light at rotation (50,-30,0) is used. Example: [{\"type\":\"Directional\",\"color\":\"#FFF4E5\",\"intensity\":1.2,\"rotation\":[45,-45,0]}]"));
+        cmd.addOption(new Option("--metadataOnly <bool>", "Return bounded metadata without inline base64. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--nearClipPlane <num>", "Camera near clip plane distance. Default: 0.01.").argParser(coerceNumber));
+        cmd.addOption(new Option("--outputFile <string>", "Project-relative PNG output path. When set, returns metadata without base64."));
+        cmd.addOption(new Option("--padding <num>", "Framing multiplier around the object. 1.0 = tight fit, 1.5 = 50% extra space. Default: 1.2.").argParser(coerceNumber));
+        cmd.addOption(new Option("--resolution <int>", "Output image resolution in pixels (width = height). Default: 512.").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["asynchronous"] !== undefined)
+                    args["asynchronous"] = opts["asynchronous"];
+                if (opts["backgroundColor"] !== undefined)
+                    args["backgroundColor"] = opts["backgroundColor"];
+                if (opts["backgroundMode"] !== undefined)
+                    args["backgroundMode"] = opts["backgroundMode"];
+                if (opts["cameraView"] !== undefined)
+                    args["cameraView"] = opts["cameraView"];
+                if (opts["farClipPlane"] !== undefined)
+                    args["farClipPlane"] = opts["farClipPlane"];
+                if (opts["fieldOfView"] !== undefined)
+                    args["fieldOfView"] = opts["fieldOfView"];
+                if (opts["gameObjectRef"] !== undefined)
+                    args["gameObjectRef"] = opts["gameObjectRef"];
+                if (opts["includeChildren"] !== undefined)
+                    args["includeChildren"] = opts["includeChildren"];
+                if (opts["isolated"] !== undefined)
+                    args["isolated"] = opts["isolated"];
+                if (opts["lights"] !== undefined)
+                    args["lights"] = opts["lights"];
+                if (opts["metadataOnly"] !== undefined)
+                    args["metadataOnly"] = opts["metadataOnly"];
+                if (opts["nearClipPlane"] !== undefined)
+                    args["nearClipPlane"] = opts["nearClipPlane"];
+                if (opts["outputFile"] !== undefined)
+                    args["outputFile"] = opts["outputFile"];
+                if (opts["padding"] !== undefined)
+                    args["padding"] = opts["padding"];
+                if (opts["resolution"] !== undefined)
+                    args["resolution"] = opts["resolution"];
+                return ctx.transport.callTool("screenshot-isolated", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Screenshot / Scene View
+    {
+        const cmd = program
+            .command("screenshot-scene-view")
+            .description("Captures a screenshot from the Unity Editor Scene View and returns it as an image. Returns the image directly for visual inspection by the LLM.");
+        cmd.addOption(new Option("--asynchronous <bool>", "Queue file/metadata capture as a durable operation. Inline image capture remains synchronous.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--height <int>", "Height of the screenshot in pixels.").argParser(coerceInteger));
+        cmd.addOption(new Option("--metadataOnly <bool>", "Return bounded metadata without inline base64. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--outputFile <string>", "Project-relative PNG output path. When set, returns metadata without base64."));
+        cmd.addOption(new Option("--width <int>", "Width of the screenshot in pixels.").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["asynchronous"] !== undefined)
+                    args["asynchronous"] = opts["asynchronous"];
+                if (opts["height"] !== undefined)
+                    args["height"] = opts["height"];
+                if (opts["metadataOnly"] !== undefined)
+                    args["metadataOnly"] = opts["metadataOnly"];
+                if (opts["outputFile"] !== undefined)
+                    args["outputFile"] = opts["outputFile"];
+                if (opts["width"] !== undefined)
+                    args["width"] = opts["width"];
+                return ctx.transport.callTool("screenshot-scene-view", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Apply Edits
+    {
+        const cmd = program
+            .command("script-apply-edits")
+            .description("Apply LSP-style line/column ranged edits to a .cs file. Send only the diff, not the whole file. Optional SHA-based optimistic locking; Roslyn syntax validation before write.");
+        cmd.addOption(new Option("--edits <json>", "Array of LSP-style edits. Each is { Range, NewText }. Applied in reverse-sorted order — caller need not compensate.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--expectedSha <string>", "Optional SHA-256 (hex, lower-case) of file content captured before edits via 'script-get-sha'. If set and mismatched, returns STALE_SHA without writing."));
+        cmd.addOption(new Option("--filePath <string>", "Project-relative path to the .cs file. Must exist. Sample: \"Assets/Scripts/MyScript.cs\".").makeOptionMandatory(true));
+        cmd.addOption(new Option("--validate <bool>", "Validate the post-edit text via Roslyn syntax parse before writing. Default true.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["edits"] !== undefined)
+                    args["edits"] = opts["edits"];
+                if (opts["expectedSha"] !== undefined)
+                    args["expectedSha"] = opts["expectedSha"];
+                if (opts["filePath"] !== undefined)
+                    args["filePath"] = opts["filePath"];
+                if (opts["validate"] !== undefined)
+                    args["validate"] = opts["validate"];
+                return ctx.transport.callTool("script-apply-edits", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Delete
+    {
+        const cmd = program
+            .command("script-delete")
+            .description("Delete the script file(s). Does AssetDatabase.Refresh() and waits for Unity compilation to complete before reporting results. Use 'script-read' tool to read existing script files first.");
+        cmd.addOption(new Option("--files <json>", "File paths to the files. Sample: \"Assets/Scripts/MyScript.cs\".").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["files"] !== undefined)
+                    args["files"] = opts["files"];
+                return ctx.transport.callTool("script-delete", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Execute
+    {
+        const cmd = program
+            .command("script-execute")
+            .description("Compiles and executes C# code dynamically using Roslyn. Supports two modes: full code mode (default) requires a complete class definition, while body-only mode (isMethodBody=true) auto-generates the boilerplate so you only provide the method body. Unity objects (GameObject, Component, etc.) can be passed as parameters using their Ref types (GameObjectRef, ComponentRef, etc.) or directly by type.");
+        cmd.addOption(new Option("--className <string>", "The name of the class containing the method to execute. In body-only mode this becomes the generated class name."));
+        cmd.addOption(new Option("--csharpCode <string>", "C# code to compile and execute. In full code mode (default, isMethodBody=false): must define a complete class with a static method. Example: 'using UnityEngine; public class Script { public static void Main() { Debug.Log(\"Hello\"); } }'. Do NOT use top-level statements. In body-only mode (isMethodBody=true): provide only the method body statements. The tool auto-generates usings, class, and method header. Example body: 'go.SetActive(false);'. Custom helper classes can still be defined inline in the body-only string after the main logic, but for complex additional class definitions use full code mode instead."));
+        cmd.addOption(new Option("--defines <json>", "Optional preprocessor symbols for the Roslyn compilation (e.g. ENABLE_PROFILER). Max 16, each a C# identifier of at most 128 characters; duplicates are removed. The Editor assemblies' own defines are NOT inherited by default — APIs guarded with [Conditional(\"DEFINE\")] or #if DEFINE are compiled out unless you pass the symbol here.").argParser(coerceJson));
+        cmd.addOption(new Option("--isMethodBody <bool>", "When true, 'csharpCode' is treated as just the method body. The tool auto-generates standard using directives (System, UnityEngine, AIGD, com.AtelierAI.Unity.Copilot.Runtime.Extensions, UnityEditor), the class definition, and the method signature. Parameters from the 'parameters' list are automatically added to the method signature using their typeName and name. When false (default), 'csharpCode' must be a complete C# compilation unit with class and method definitions.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--methodName <string>", "The name of the method to execute. Must be a static method. In body-only mode this becomes the generated method name."));
+        cmd.addOption(new Option("--parameters <json-array>", "Serialized parameters to pass to the method. Each entry must specify 'name' and 'typeName'. Supported parameter types include primitives, strings, and Unity object references: - 'UnityEngine.GameObject': resolves an actual GameObject from value '{\"instanceID\": N}', '{\"name\": \"...\"}', or '{\"path\": \"...\"}'. - 'UnityEngine.Component' (or any component subtype): resolves from '{\"instanceID\": N}'. - 'AIGD.GameObjectRef': passes a GameObjectRef POCO directly; the method body calls goRef.FindGameObject() to resolve it. - 'AIGD.ComponentRef': passes a ComponentRef POCO. - 'AIGD.ObjectRef': passes a base ObjectRef POCO. If the method does not require parameters, leave this empty.").argParser(coerceJson));
+        cmd.addOption(new Option("--returnType <string>", "Return type of the generated method in body-only mode. Default 'void' = side-effect only, no return value. Set to a C# type name to return data: 'int', 'bool', 'string', 'UnityEngine.Vector3', 'System.Collections.Generic.List<string>', etc. When non-void, the body MUST end with a 'return <expr>;' statement; the returned value is serialized back to the caller. Full-code mode declares its own return type in the code; this is informational there."));
+        cmd.addOption(new Option("--sandboxScene <bool>", "Execute inside a disposable sandbox scene: a new untitled scene is opened for the work, and the previously active scene setup, selection, and dirty state are restored afterwards. The result reports whether restoration succeeded. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--code-file <path>", "Read csharpCode as strict UTF-8 from a path or - (stdin)."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["className"] !== undefined)
+                    args["className"] = opts["className"];
+                args["csharpCode"] = resolveTextInput(opts["csharpCode"], opts["codeFile"], "--csharpCode", "--code-file");
+                if (opts["defines"] !== undefined)
+                    args["defines"] = opts["defines"];
+                if (opts["isMethodBody"] !== undefined)
+                    args["isMethodBody"] = opts["isMethodBody"];
+                if (opts["methodName"] !== undefined)
+                    args["methodName"] = opts["methodName"];
+                if (opts["parameters"] !== undefined)
+                    args["parameters"] = opts["parameters"];
+                if (opts["returnType"] !== undefined)
+                    args["returnType"] = opts["returnType"];
+                if (opts["sandboxScene"] !== undefined)
+                    args["sandboxScene"] = opts["sandboxScene"];
+                return ctx.transport.callTool("script-execute", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Find In File
+    {
+        const cmd = program
+            .command("script-find-in-file")
+            .description("Search files under Assets/ or Packages/ for a regex or plain-text pattern (ripgrep-style). Returns matching lines with optional context.");
+        cmd.addOption(new Option("--context <int>", "Lines of context before/after each match. Default 0, max 20.").argParser(coerceInteger));
+        cmd.addOption(new Option("--glob <string>", "Glob to filter files, e.g. '*.cs', '**/*.uss'. Default '*.cs'."));
+        cmd.addOption(new Option("--ignoreCase <bool>", "Case-insensitive match. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--maxFileBytes <int>", "Max bytes per file to scan. Default 5_000_000. Files larger are skipped.").argParser(coerceInteger));
+        cmd.addOption(new Option("--maxResults <int>", "Max matches returned across all files. Default 200, hard cap 2000.").argParser(coerceInteger));
+        cmd.addOption(new Option("--pattern <string>", "Search pattern (regex by default, plain text when 'plainText'=true).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--plainText <bool>", "Treat pattern as plain text (no regex metachars). Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--root <string>", "Root path relative to project. Default 'Assets/'. Use 'Packages/' to search packages."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["context"] !== undefined)
+                    args["context"] = opts["context"];
+                if (opts["glob"] !== undefined)
+                    args["glob"] = opts["glob"];
+                if (opts["ignoreCase"] !== undefined)
+                    args["ignoreCase"] = opts["ignoreCase"];
+                if (opts["maxFileBytes"] !== undefined)
+                    args["maxFileBytes"] = opts["maxFileBytes"];
+                if (opts["maxResults"] !== undefined)
+                    args["maxResults"] = opts["maxResults"];
+                if (opts["pattern"] !== undefined)
+                    args["pattern"] = opts["pattern"];
+                if (opts["plainText"] !== undefined)
+                    args["plainText"] = opts["plainText"];
+                if (opts["root"] !== undefined)
+                    args["root"] = opts["root"];
+                return ctx.transport.callTool("script-find-in-file", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Get SHA
+    {
+        const cmd = program
+            .command("script-get-sha")
+            .description("Compute the SHA-256 hash of a script file's raw bytes (hex, lower-case). Pair with 'script-apply-edits' as an optimistic-lock token.");
+        cmd.addOption(new Option("--filePath <string>", "Project-relative path to the .cs file. Sample: \"Assets/Scripts/MyScript.cs\".").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["filePath"] !== undefined)
+                    args["filePath"] = opts["filePath"];
+                return ctx.transport.callTool("script-get-sha", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Read
+    {
+        const cmd = program
+            .command("script-read")
+            .description("Reads the content of a script file and returns it as a string. Use 'script-update-or-create' tool to update or create script files.");
+        cmd.addOption(new Option("--filePath <string>", "The path to the file. Sample: \"Assets/Scripts/MyScript.cs\".").makeOptionMandatory(true));
+        cmd.addOption(new Option("--lineFrom <int>", "The line number to start reading from (1-based).").argParser(coerceInteger));
+        cmd.addOption(new Option("--lineTo <int>", "The line number to stop reading at (1-based, -1 for all lines).").argParser(coerceInteger));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["filePath"] !== undefined)
+                    args["filePath"] = opts["filePath"];
+                if (opts["lineFrom"] !== undefined)
+                    args["lineFrom"] = opts["lineFrom"];
+                if (opts["lineTo"] !== undefined)
+                    args["lineTo"] = opts["lineTo"];
+                return ctx.transport.callTool("script-read", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Update or Create
+    {
+        const cmd = program
+            .command("script-update-or-create")
+            .description("Updates or creates script file with the provided C# code. Does AssetDatabase.Refresh() at the end. Provides compilation error details if the code has syntax errors. Use 'script-read' tool to read existing script files first.");
+        cmd.addOption(new Option("--content <string>", "C# code - content of the file.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--filePath <string>", "The path to the file. Sample: \"Assets/Scripts/MyScript.cs\".").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["content"] !== undefined)
+                    args["content"] = opts["content"];
+                if (opts["filePath"] !== undefined)
+                    args["filePath"] = opts["filePath"];
+                return ctx.transport.callTool("script-update-or-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Script / Validate
+    {
+        const cmd = program
+            .command("script-validate")
+            .description("Validates C# source via Roslyn at Syntax / Semantic / Strict levels without compiling to an assembly or writing any file. Use as a pre-flight check before 'script-update-or-create'. Semantic/Strict catch references to unknown namespaces, types, and methods against the project's loaded assemblies.");
+        cmd.addOption(new Option("--code <string>", "C# source code to validate (full file text).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--fileName <string>", "Optional file name shown in diagnostic locations. Defaults to 'Submitted.cs'."));
+        cmd.addOption(new Option("--level <value>", "Validation strictness. 'Syntax' (default) = parser only. 'Semantic' = parser + project-assembly symbol resolution (catches unknown types/methods/namespaces). 'Strict' = Semantic + warnings-as-errors + nullable.").choices(["Syntax", "Semantic", "Strict"]));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["code"] !== undefined)
+                    args["code"] = opts["code"];
+                if (opts["fileName"] !== undefined)
+                    args["fileName"] = opts["fileName"];
+                if (opts["level"] !== undefined)
+                    args["level"] = opts["level"];
+                return ctx.transport.callTool("script-validate", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tests / Cancel Job
+    {
+        const cmd = program
+            .command("tests-job-cancel")
+            .description("Request cooperative cancellation of a tests-run operation.");
+        cmd.addOption(new Option("--jobId <string>", "jobId").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["jobId"] !== undefined)
+                    args["jobId"] = opts["jobId"];
+                return ctx.transport.callTool("tests-job-cancel", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tests / Get Job
+    {
+        const cmd = program
+            .command("tests-job-get")
+            .description("Get one durable tests-run operation by ID.");
+        cmd.addOption(new Option("--jobId <string>", "jobId").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["jobId"] !== undefined)
+                    args["jobId"] = opts["jobId"];
+                return ctx.transport.callTool("tests-job-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tests / List Jobs
+    {
+        const cmd = program
+            .command("tests-job-list")
+            .description("List durable tests-run operations.");
+        cmd.addOption(new Option("--includeTerminal <bool>", "includeTerminal").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeTerminal"] !== undefined)
+                    args["includeTerminal"] = opts["includeTerminal"];
+                return ctx.transport.callTool("tests-job-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tests / Run
+    {
+        const cmd = program
+            .command("tests-run")
+            .description("Execute Unity tests and return detailed results. Supports filtering by test mode, assembly, namespace, class, and method. Recommended to use 'EditMode' for faster iteration during development. Precondition: every open scene MUST be saved (no unsaved changes). If any open scene is dirty, this tool throws an InvalidOperationException listing the dirty scenes; save them and retry.");
+        cmd.addOption(new Option("--executionTimeoutSeconds <int>", "Maximum total test operation duration in seconds. Default 1800; valid range 1..86400.").argParser((raw) => coerceInteger(raw, 1, 86400)));
+        cmd.addOption(new Option("--includeLogs <bool>", "Include console logs in the test results (default: false).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeLogsStacktrace <bool>", "Include stack traces for console logs in the test results (default: false). This is huge amount of data, use only if really needed.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeMessages <bool>", "Include test result messages in the test results (default: true). If you just need pass/fail status, set to false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includePassingTests <bool>", "Include details for all tests, both passing and failing (default: false). If you just need details for failing tests, set to false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeStacktrace <bool>", "Include stack traces in the test results (default: false).").argParser(coerceBoolean));
+        cmd.addOption(new Option("--logType <value>", "Log type filter for console logs. Options: 'Log', 'Warning', 'Assert', 'Error', 'Exception'. (default: 'Warning')").choices(["Error", "Assert", "Warning", "Log", "Exception"]));
+        cmd.addOption(new Option("--sandboxScene <bool>", "Run the tests inside a disposable sandbox scene: a new untitled scene is opened for the run and the previously active scene setup, selection, and dirty state are restored afterwards. User scenes that were dirty before the call still block the run exactly as without sandbox mode. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--testAssembly <string>", "Specific test assembly name to run (optional). Example: 'Assembly-CSharp-Editor-testable'"));
+        cmd.addOption(new Option("--testClass <string>", "Specific test class name to run (optional). Example: 'MyTestClass'"));
+        cmd.addOption(new Option("--testMethod <string>", "Specific fully qualified test method to run (optional). Example: 'MyTestNamespace.FixtureName.TestName'"));
+        cmd.addOption(new Option("--testMode <value>", "Test mode to run. Options: 'EditMode', 'PlayMode'. Default: 'EditMode'").choices(["EditMode", "PlayMode"]));
+        cmd.addOption(new Option("--testNamespace <string>", "Specific test namespace to run (optional). Example: 'MyTestNamespace'"));
+        cmd.addOption(new Option("--waitTimeoutSeconds <int>", "Maximum discovery/initial wait in seconds before returning a failed operation. Default 10; valid range 1..300.").argParser((raw) => coerceInteger(raw, 1, 300)));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["executionTimeoutSeconds"] !== undefined)
+                    args["executionTimeoutSeconds"] = opts["executionTimeoutSeconds"];
+                if (opts["includeLogs"] !== undefined)
+                    args["includeLogs"] = opts["includeLogs"];
+                if (opts["includeLogsStacktrace"] !== undefined)
+                    args["includeLogsStacktrace"] = opts["includeLogsStacktrace"];
+                if (opts["includeMessages"] !== undefined)
+                    args["includeMessages"] = opts["includeMessages"];
+                if (opts["includePassingTests"] !== undefined)
+                    args["includePassingTests"] = opts["includePassingTests"];
+                if (opts["includeStacktrace"] !== undefined)
+                    args["includeStacktrace"] = opts["includeStacktrace"];
+                if (opts["logType"] !== undefined)
+                    args["logType"] = opts["logType"];
+                if (opts["sandboxScene"] !== undefined)
+                    args["sandboxScene"] = opts["sandboxScene"];
+                if (opts["testAssembly"] !== undefined)
+                    args["testAssembly"] = opts["testAssembly"];
+                if (opts["testClass"] !== undefined)
+                    args["testClass"] = opts["testClass"];
+                if (opts["testMethod"] !== undefined)
+                    args["testMethod"] = opts["testMethod"];
+                if (opts["testMode"] !== undefined)
+                    args["testMode"] = opts["testMode"];
+                if (opts["testNamespace"] !== undefined)
+                    args["testNamespace"] = opts["testNamespace"];
+                if (opts["waitTimeoutSeconds"] !== undefined)
+                    args["waitTimeoutSeconds"] = opts["waitTimeoutSeconds"];
+                return ctx.transport.callTool("tests-run", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Texture / Create Checker Pattern
+    {
+        const cmd = program
+            .command("texture-create-checker")
+            .description("Generate a Texture2D with a two-color checkerboard pattern and save it as a PNG asset under 'Assets/'.");
+        cmd.addOption(new Option("--color1 <json>", "Color of the (0,0) cell. RGBA channels in 0..1. Default opaque white.").argParser(coerceJson));
+        cmd.addOption(new Option("--color2 <json>", "Color of the alternating cells. RGBA channels in 0..1. Default opaque black.").argParser(coerceJson));
+        cmd.addOption(new Option("--height <int>", "Height in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        cmd.addOption(new Option("--overwrite <bool>", "Force overwrite if asset already exists. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.png'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--squareSize <int>", "Side length of a single checker cell in pixels. Must be >= 1.").argParser(coerceInteger));
+        cmd.addOption(new Option("--width <int>", "Width in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["color1"] !== undefined)
+                    args["color1"] = opts["color1"];
+                if (opts["color2"] !== undefined)
+                    args["color2"] = opts["color2"];
+                if (opts["height"] !== undefined)
+                    args["height"] = opts["height"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["squareSize"] !== undefined)
+                    args["squareSize"] = opts["squareSize"];
+                if (opts["width"] !== undefined)
+                    args["width"] = opts["width"];
+                return ctx.transport.callTool("texture-create-checker", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Texture / Create Gradient
+    {
+        const cmd = program
+            .command("texture-create-gradient")
+            .description("Generate a Texture2D containing a linear gradient and save it as a PNG asset under 'Assets/'.");
+        cmd.addOption(new Option("--direction <value>", "Gradient sweep direction: Horizontal, Vertical, Diagonal, or Radial.").choices(["Horizontal", "Vertical", "Diagonal", "Radial"]));
+        cmd.addOption(new Option("--endColor <json>", "Color at t=1 (right/top/corner). RGBA channels in 0..1.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--height <int>", "Height in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        cmd.addOption(new Option("--overwrite <bool>", "Force overwrite if asset already exists. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.png'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--startColor <json>", "Color at t=0 (left/bottom/center). RGBA channels in 0..1.").argParser(coerceJson).makeOptionMandatory(true));
+        cmd.addOption(new Option("--width <int>", "Width in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["direction"] !== undefined)
+                    args["direction"] = opts["direction"];
+                if (opts["endColor"] !== undefined)
+                    args["endColor"] = opts["endColor"];
+                if (opts["height"] !== undefined)
+                    args["height"] = opts["height"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["startColor"] !== undefined)
+                    args["startColor"] = opts["startColor"];
+                if (opts["width"] !== undefined)
+                    args["width"] = opts["width"];
+                return ctx.transport.callTool("texture-create-gradient", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Texture / Create Perlin Noise
+    {
+        const cmd = program
+            .command("texture-create-noise")
+            .description("Generate a Texture2D filled with Perlin / fBm noise and save it as a PNG asset under 'Assets/'.");
+        cmd.addOption(new Option("--grayscale <bool>", "When true (default) the output RGB channels carry the same noise value. When false they are tint.rgb * sample.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--height <int>", "Height in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        cmd.addOption(new Option("--octaves <int>", "Number of fBm octaves in [1, 16]. Default 1 (single octave Perlin).").argParser(coerceInteger));
+        cmd.addOption(new Option("--overwrite <bool>", "Force overwrite if asset already exists. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.png'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--persistence <num>", "Amplitude falloff per octave in [0, 1]. Default 0.5.").argParser(coerceNumber));
+        cmd.addOption(new Option("--scale <num>", "Base frequency in tiles across the texture. Higher = finer detail. > 0.").argParser(coerceNumber));
+        cmd.addOption(new Option("--seed <int>", "Integer offset applied to sample coordinates. Default 0.").argParser(coerceInteger));
+        cmd.addOption(new Option("--tint <json>", "RGBA tint applied multiplicatively. Default opaque white.").argParser(coerceJson));
+        cmd.addOption(new Option("--width <int>", "Width in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["grayscale"] !== undefined)
+                    args["grayscale"] = opts["grayscale"];
+                if (opts["height"] !== undefined)
+                    args["height"] = opts["height"];
+                if (opts["octaves"] !== undefined)
+                    args["octaves"] = opts["octaves"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["persistence"] !== undefined)
+                    args["persistence"] = opts["persistence"];
+                if (opts["scale"] !== undefined)
+                    args["scale"] = opts["scale"];
+                if (opts["seed"] !== undefined)
+                    args["seed"] = opts["seed"];
+                if (opts["tint"] !== undefined)
+                    args["tint"] = opts["tint"];
+                if (opts["width"] !== undefined)
+                    args["width"] = opts["width"];
+                return ctx.transport.callTool("texture-create-noise", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Texture / Create Solid Color
+    {
+        const cmd = program
+            .command("texture-create-solid")
+            .description("Generate a Texture2D filled with a single RGBA color and save it as a PNG asset under 'Assets/'.");
+        cmd.addOption(new Option("--color <json>", "RGBA color, each channel in 0..1. Default (1,1,1,1) = opaque white.").argParser(coerceJson));
+        cmd.addOption(new Option("--height <int>", "Height in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        cmd.addOption(new Option("--overwrite <bool>", "Force overwrite if asset already exists. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.png'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--width <int>", "Width in pixels. 1..4096.").argParser(coerceInteger).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["color"] !== undefined)
+                    args["color"] = opts["color"];
+                if (opts["height"] !== undefined)
+                    args["height"] = opts["height"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["width"] !== undefined)
+                    args["width"] = opts["width"];
+                return ctx.transport.callTool("texture-create-solid", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Texture / Read Metadata
+    {
+        const cmd = program
+            .command("texture-read")
+            .description("Read metadata of an existing texture asset (.png / .jpg / .jpeg) under 'Assets/'.");
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.png', '.jpg', or '.jpeg'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("texture-read", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tool / Set Enabled State
+    {
+        const cmd = program
+            .command("tool-set-enabled-state")
+            .description("Enable or disable uco tools by name. Allows controlling which tools are available for the AI agent.");
+        cmd.addOption(new Option("--includeLogs <bool>", "Include operation logs in the result. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--tools <json>", "Array of tools with their desired enabled state.").argParser(coerceJson).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeLogs"] !== undefined)
+                    args["includeLogs"] = opts["includeLogs"];
+                if (opts["tools"] !== undefined)
+                    args["tools"] = opts["tools"];
+                return ctx.transport.callTool("tool-set-enabled-state", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tools / List Groups
+    {
+        const cmd = program
+            .command("tools-list-groups")
+            .description("List all uco tool groups with current enabled state and tool membership. Pass includeTools=false to omit the per-group tool name arrays (ToolCount is still reported).");
+        cmd.addOption(new Option("--includeTools <bool>", "Populate each group's Tools array with its member tool names (default true). Set false for a compact overview — ToolCount still reports the membership size.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeTools"] !== undefined)
+                    args["includeTools"] = opts["includeTools"];
+                return ctx.transport.callTool("tools-list-groups", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tools / Set Group Enabled
+    {
+        const cmd = program
+            .command("tools-set-group-enabled")
+            .description("Enable or disable an uco tool group at runtime, persisting the choice to EditorPrefs. Soft hint only — disabled tools remain callable through the upstream request pipeline.");
+        cmd.addOption(new Option("--enabled <bool>", "True to enable the group, false to disable it.").argParser(coerceBoolean).makeOptionMandatory(true));
+        cmd.addOption(new Option("--group <string>", "Group name. Use 'tools-list-groups' to discover valid group names.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["enabled"] !== undefined)
+                    args["enabled"] = opts["enabled"];
+                if (opts["group"] !== undefined)
+                    args["group"] = opts["group"];
+                return ctx.transport.callTool("tools-set-group-enabled", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Type / Get Json Schema
+    {
+        const cmd = program
+            .command("type-get-json-schema")
+            .description("Generates a JSON Schema for a given C# type name using reflection. Supports primitives, enums, arrays, generic collections, dictionaries, and complex objects. The type must be present in any loaded assembly. Use the full type name (e.g. 'UnityEngine.Vector3') for best results.");
+        cmd.addOption(new Option("--descriptionMode <value>", "Controls the type-level 'description' field. Include: keep on the target type only. IncludeRecursively: keep on the target type and inside $defs entries. Ignore: strip all type-level descriptions. Default: Ignore.").choices(["Include", "IncludeRecursively", "Ignore"]));
+        cmd.addOption(new Option("--includeNestedTypes <bool>", "When true, complex nested types are extracted into '$defs' and referenced via '$ref' instead of being inlined. Useful for large or recursive types. Default: false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--propertyDescriptionMode <value>", "Controls 'description' fields on properties, fields, and array items. Include: keep on the target type's own properties/items only. IncludeRecursively: keep on all properties/items including those inside $defs entries. Ignore: strip all property/item descriptions. Default: Ignore.").choices(["Include", "IncludeRecursively", "Ignore"]));
+        cmd.addOption(new Option("--typeName <string>", "Full C# type name to generate the schema for. Examples: 'System.String', 'UnityEngine.Vector3', 'System.Collections.Generic.List<System.Int32>'. Simple names like 'Vector3' are also accepted when unambiguous.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--writeIndented <bool>", "Whether to format the output JSON with indentation for readability. Default: false.").argParser(coerceBoolean));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["descriptionMode"] !== undefined)
+                    args["descriptionMode"] = opts["descriptionMode"];
+                if (opts["includeNestedTypes"] !== undefined)
+                    args["includeNestedTypes"] = opts["includeNestedTypes"];
+                if (opts["propertyDescriptionMode"] !== undefined)
+                    args["propertyDescriptionMode"] = opts["propertyDescriptionMode"];
+                if (opts["typeName"] !== undefined)
+                    args["typeName"] = opts["typeName"];
+                if (opts["writeIndented"] !== undefined)
+                    args["writeIndented"] = opts["writeIndented"];
+                return ctx.transport.callTool("type-get-json-schema", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / Document / Attach
+    {
+        const cmd = program
+            .command("ui-document-attach")
+            .description("Attach a UIDocument to a GameObject and wire it to a UXML asset.");
+        cmd.addOption(new Option("--panelSettingsPath <string>", "Optional project-relative path to a PanelSettings .asset to assign to UIDocument.panelSettings."));
+        cmd.addOption(new Option("--sortingOrder <num>", "Optional sorting order. When null, UIDocument.sortingOrder is left untouched.").argParser(coerceNumber));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the UIDocument. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--visualTreeAssetPath <string>", "Project-relative path to .uxml source asset. Required.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["panelSettingsPath"] !== undefined)
+                    args["panelSettingsPath"] = opts["panelSettingsPath"];
+                if (opts["sortingOrder"] !== undefined)
+                    args["sortingOrder"] = opts["sortingOrder"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["visualTreeAssetPath"] !== undefined)
+                    args["visualTreeAssetPath"] = opts["visualTreeAssetPath"];
+                return ctx.transport.callTool("ui-document-attach", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / Document / Detach
+    {
+        const cmd = program
+            .command("ui-document-detach")
+            .description("Detach a UIDocument from a GameObject.");
+        cmd.addOption(new Option("--target <ref>", "Target GameObject. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("ui-document-detach", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / Element / Query
+    {
+        const cmd = program
+            .command("ui-element-query")
+            .description("Query VisualElements under a UIDocument's rootVisualElement by UQuery-style selector.");
+        cmd.addOption(new Option("--maxResults <int>", "Maximum number of results to return. Default 50.").argParser(coerceInteger));
+        cmd.addOption(new Option("--selector <string>", "UQuery selector. Sample: '.button-primary', '#title', 'Label.warning'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting a UIDocument. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["maxResults"] !== undefined)
+                    args["maxResults"] = opts["maxResults"];
+                if (opts["selector"] !== undefined)
+                    args["selector"] = opts["selector"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("ui-element-query", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / USS / Create
+    {
+        const cmd = program
+            .command("ui-uss-create")
+            .description("Create a new USS asset under 'Assets/'.");
+        cmd.addOption(new Option("--content <string>", "Full USS content (CSS-like text).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--overwrite <bool>", "Force overwrite if the asset already exists. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.uss'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["content"] !== undefined)
+                    args["content"] = opts["content"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("ui-uss-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / USS / Modify
+    {
+        const cmd = program
+            .command("ui-uss-modify")
+            .description("Modify a USS file via text operations: 'append', 'replace-all', 'add-rule', 'remove-rule'.");
+        cmd.addOption(new Option("--content <string>", "Content for 'append' or 'replace-all'."));
+        cmd.addOption(new Option("--declarations <string>", "Body for 'add-rule' (declarations without curly braces). Sample: 'color: red; font-size: 14px;'."));
+        cmd.addOption(new Option("--operation <string>", "Operation: 'append' | 'replace-all' | 'add-rule' | 'remove-rule'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.uss'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--selector <string>", "CSS selector for 'add-rule' / 'remove-rule'. Sample: '.button-primary' or '#header'."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["content"] !== undefined)
+                    args["content"] = opts["content"];
+                if (opts["declarations"] !== undefined)
+                    args["declarations"] = opts["declarations"];
+                if (opts["operation"] !== undefined)
+                    args["operation"] = opts["operation"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["selector"] !== undefined)
+                    args["selector"] = opts["selector"];
+                return ctx.transport.callTool("ui-uss-modify", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / USS / Read
+    {
+        const cmd = program
+            .command("ui-uss-read")
+            .description("Read USS content as a string.");
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.uss'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("ui-uss-read", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / UXML / Create
+    {
+        const cmd = program
+            .command("ui-uxml-create")
+            .description("Create a new UXML asset under 'Assets/'. Validates XML before writing.");
+        cmd.addOption(new Option("--content <string>", "Full UXML content (XML string).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--overwrite <bool>", "Force overwrite if the asset already exists. Default false.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.uxml'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["content"] !== undefined)
+                    args["content"] = opts["content"];
+                if (opts["overwrite"] !== undefined)
+                    args["overwrite"] = opts["overwrite"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("ui-uxml-create", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / UXML / Modify
+    {
+        const cmd = program
+            .command("ui-uxml-modify")
+            .description("Structurally modify a UXML file. Use 'ui-uxml-read' first to inspect existing content.");
+        cmd.addOption(new Option("--attributeName <string>", "Attribute name (for 'set-attribute')."));
+        cmd.addOption(new Option("--attributeValue <string>", "Attribute value (for 'set-attribute'). Pass empty string to clear; element keeps the attribute."));
+        cmd.addOption(new Option("--newContent <string>", "New XML content (for 'replace') or child XML fragment (for 'append-child')."));
+        cmd.addOption(new Option("--operation <string>", "Operation: 'replace' | 'append-child' | 'remove-element' | 'set-attribute'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.uxml'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--selector <string>", "XPath-like selector for the target element. Use 'ui:' prefix for UnityEngine.UIElements (e.g. '//ui:Label[@name=\"title\"]') or 'uie:' prefix for UnityEditor.UIElements."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["attributeName"] !== undefined)
+                    args["attributeName"] = opts["attributeName"];
+                if (opts["attributeValue"] !== undefined)
+                    args["attributeValue"] = opts["attributeValue"];
+                if (opts["newContent"] !== undefined)
+                    args["newContent"] = opts["newContent"];
+                if (opts["operation"] !== undefined)
+                    args["operation"] = opts["operation"];
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                if (opts["selector"] !== undefined)
+                    args["selector"] = opts["selector"];
+                return ctx.transport.callTool("ui-uxml-modify", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // UI / UXML / Read
+    {
+        const cmd = program
+            .command("ui-uxml-read")
+            .description("Read UXML content as a string.");
+        cmd.addOption(new Option("--path <string>", "Asset path under 'Assets/'. Must end with '.uxml'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["path"] !== undefined)
+                    args["path"] = opts["path"];
+                return ctx.transport.callTool("ui-uxml-read", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // Tool / List
+    {
+        const cmd = program
+            .command("unity-tool-list")
+            .description("List all uco tools registered in the connected Unity Editor instance. Optionally filter by regex across tool names, descriptions, and arguments.");
+        cmd.addOption(new Option("--includeDescription <bool>", "Include tool descriptions in the result. Default: false").argParser(coerceBoolean));
+        cmd.addOption(new Option("--includeInputs <json>", "Include input arguments in the result. Default: None").argParser(coerceJson));
+        cmd.addOption(new Option("--regexSearch <string>", "Regex pattern to filter tools. Matches against tool name, description, and argument names and descriptions."));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["includeDescription"] !== undefined)
+                    args["includeDescription"] = opts["includeDescription"];
+                if (opts["includeInputs"] !== undefined)
+                    args["includeInputs"] = opts["includeInputs"];
+                if (opts["regexSearch"] !== undefined)
+                    args["regexSearch"] = opts["regexSearch"];
+                return ctx.transport.callTool("unity-tool-list", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // VFX / Graph / Configure
+    {
+        const cmd = program
+            .command("vfx-graph-configure")
+            .description("Set a single exposed property on a VFX Graph VisualEffect. Returns Ok=false when the VFX Graph package is not installed.");
+        cmd.addOption(new Option("--propertyName <string>", "Property name in the VFX Graph asset (exposed parameter name).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the VisualEffect. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--valueJson <string>", "JSON-encoded value matching valueType. Examples: '1.5' (float), 'true' (bool), '[0.5, 1.0]' (vector2).").makeOptionMandatory(true));
+        cmd.addOption(new Option("--valueType <string>", "Value type: 'float' | 'int' | 'bool' | 'vector2' | 'vector3' | 'vector4' | 'color'.").makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["propertyName"] !== undefined)
+                    args["propertyName"] = opts["propertyName"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["valueJson"] !== undefined)
+                    args["valueJson"] = opts["valueJson"];
+                if (opts["valueType"] !== undefined)
+                    args["valueType"] = opts["valueType"];
+                return ctx.transport.callTool("vfx-graph-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // VFX / Particle / Configure
+    {
+        const cmd = program
+            .command("vfx-particle-configure")
+            .description("Configure a ParticleSystem's most-common module fields. Only provided (non-null) parameters are written. Use 'vfx-particle-get' to inspect current values first.");
+        cmd.addOption(new Option("--duration <num>", "Main: duration in seconds. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--emissionEnabled <bool>", "Emission: enabled flag. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--emissionRateOverTime <num>", "Emission: rateOverTime constant value. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--gravityModifier <num>", "Main: gravityModifier constant value. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--looping <bool>", "Main: looping flag. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--maxParticles <int>", "Main: maxParticles cap. Ignored when null.").argParser(coerceInteger));
+        cmd.addOption(new Option("--shapeEnabled <bool>", "Shape: enabled flag. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--shapeRadius <num>", "Shape: radius value. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--shapeType <string>", "Shape: shapeType — case-insensitive enum name ('Sphere', 'Hemisphere', 'Cone', 'Box', 'Donut', 'Circle', 'SingleSidedEdge', etc.). Ignored when null."));
+        cmd.addOption(new Option("--simulationSpace <string>", "Main: simulationSpace — one of 'Local', 'World', 'Custom' (case-insensitive). Ignored when null."));
+        cmd.addOption(new Option("--startColor <json>", "Main: startColor (RGBA in [0..1] as Vector4). Ignored when null.").argParser(coerceJson));
+        cmd.addOption(new Option("--startLifetime <num>", "Main: startLifetime constant value. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--startSize <num>", "Main: startSize constant value. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--startSpeed <num>", "Main: startSpeed constant value. Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the ParticleSystem. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--velocityEnabled <bool>", "Velocity over lifetime: enabled flag. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--velocityLinear <x,y,z|json>", "Velocity over lifetime: linear x/y/z constants. Ignored when null.").argParser(coerceVec3));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["duration"] !== undefined)
+                    args["duration"] = opts["duration"];
+                if (opts["emissionEnabled"] !== undefined)
+                    args["emissionEnabled"] = opts["emissionEnabled"];
+                if (opts["emissionRateOverTime"] !== undefined)
+                    args["emissionRateOverTime"] = opts["emissionRateOverTime"];
+                if (opts["gravityModifier"] !== undefined)
+                    args["gravityModifier"] = opts["gravityModifier"];
+                if (opts["looping"] !== undefined)
+                    args["looping"] = opts["looping"];
+                if (opts["maxParticles"] !== undefined)
+                    args["maxParticles"] = opts["maxParticles"];
+                if (opts["shapeEnabled"] !== undefined)
+                    args["shapeEnabled"] = opts["shapeEnabled"];
+                if (opts["shapeRadius"] !== undefined)
+                    args["shapeRadius"] = opts["shapeRadius"];
+                if (opts["shapeType"] !== undefined)
+                    args["shapeType"] = opts["shapeType"];
+                if (opts["simulationSpace"] !== undefined)
+                    args["simulationSpace"] = opts["simulationSpace"];
+                if (opts["startColor"] !== undefined)
+                    args["startColor"] = opts["startColor"];
+                if (opts["startLifetime"] !== undefined)
+                    args["startLifetime"] = opts["startLifetime"];
+                if (opts["startSize"] !== undefined)
+                    args["startSize"] = opts["startSize"];
+                if (opts["startSpeed"] !== undefined)
+                    args["startSpeed"] = opts["startSpeed"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["velocityEnabled"] !== undefined)
+                    args["velocityEnabled"] = opts["velocityEnabled"];
+                if (opts["velocityLinear"] !== undefined)
+                    args["velocityLinear"] = opts["velocityLinear"];
+                return ctx.transport.callTool("vfx-particle-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // VFX / Particle / Control
+    {
+        const cmd = program
+            .command("vfx-particle-control")
+            .description("Control ParticleSystem playback (play / pause / stop / clear / emit). Use 'emit' to inject a one-shot burst of N particles.");
+        cmd.addOption(new Option("--action <string>", "Action: 'play' | 'pause' | 'stop' | 'clear' | 'emit'.").makeOptionMandatory(true));
+        cmd.addOption(new Option("--emitCount <int>", "Number of particles to inject when action='emit'. Ignored otherwise.").argParser(coerceInteger));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the ParticleSystem. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["action"] !== undefined)
+                    args["action"] = opts["action"];
+                if (opts["emitCount"] !== undefined)
+                    args["emitCount"] = opts["emitCount"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("vfx-particle-control", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // VFX / Particle / Get
+    {
+        const cmd = program
+            .command("vfx-particle-get")
+            .description("Read a ParticleSystem's main/emission/shape/velocity-over-lifetime modules. Pair with 'vfx-particle-configure' to write back.");
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the ParticleSystem. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                return ctx.transport.callTool("vfx-particle-get", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+    // VFX / Trail / Configure
+    {
+        const cmd = program
+            .command("vfx-trail-configure")
+            .description("Configure a TrailRenderer's most-common fields. Only provided (non-null) parameters are written.");
+        cmd.addOption(new Option("--autoDestruct <bool>", "Whether the GameObject auto-destructs after the trail fades. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--emitting <bool>", "Whether the trail is currently emitting new segments. Ignored when null.").argParser(coerceBoolean));
+        cmd.addOption(new Option("--endColor <json>", "Trail end color (RGBA in [0..1] as Vector4). Ignored when null.").argParser(coerceJson));
+        cmd.addOption(new Option("--endWidth <num>", "Trail end width (world units). Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--minVertexDistance <num>", "Minimum distance between trail vertices. Ignored when null. Note: TrailRenderer.minVertexDistance is a float in Unity.").argParser(coerceNumber));
+        cmd.addOption(new Option("--startColor <json>", "Trail start color (RGBA in [0..1] as Vector4). Ignored when null.").argParser(coerceJson));
+        cmd.addOption(new Option("--startWidth <num>", "Trail start width (world units). Ignored when null.").argParser(coerceNumber));
+        cmd.addOption(new Option("--target <ref>", "Target GameObject hosting the TrailRenderer. Use 'gameobject-find' to locate it.").argParser(coerceGameObjectRef).makeOptionMandatory(true));
+        cmd.addOption(new Option("--time <num>", "Trail duration in seconds. Ignored when null.").argParser(coerceNumber));
+        addToolCallControlOptions(cmd);
+        cmd.action(function (_opts) {
+            return runCommand(this, async (ctx) => {
+                const opts = this.opts();
+                const args = {};
+                if (opts["autoDestruct"] !== undefined)
+                    args["autoDestruct"] = opts["autoDestruct"];
+                if (opts["emitting"] !== undefined)
+                    args["emitting"] = opts["emitting"];
+                if (opts["endColor"] !== undefined)
+                    args["endColor"] = opts["endColor"];
+                if (opts["endWidth"] !== undefined)
+                    args["endWidth"] = opts["endWidth"];
+                if (opts["minVertexDistance"] !== undefined)
+                    args["minVertexDistance"] = opts["minVertexDistance"];
+                if (opts["startColor"] !== undefined)
+                    args["startColor"] = opts["startColor"];
+                if (opts["startWidth"] !== undefined)
+                    args["startWidth"] = opts["startWidth"];
+                if (opts["target"] !== undefined)
+                    args["target"] = opts["target"];
+                if (opts["time"] !== undefined)
+                    args["time"] = opts["time"];
+                return ctx.transport.callTool("vfx-trail-configure", args, toolCallOptionsFromCli(opts));
+            })();
+        });
+    }
+}
+//# sourceMappingURL=tools.js.map