diff --git a/.code-linter.json b/.code-linter.json
index 2d325db..a16cfd4 100644
--- a/.code-linter.json
+++ b/.code-linter.json
@@ -1,10 +1,10 @@
 {
-  "max_file_lines": 750,
-  "max_function_lines": 150,
-  "max_nesting_depth": 8,
-  "max_parameters": 8,
-  "max_comment_lines": 15,
-  "max_types_per_file": 6,
+  "max_file_lines": 300,
+  "max_function_lines": 50,
+  "max_nesting_depth": 4,
+  "max_parameters": 5,
+  "max_comment_lines": 5,
+  "max_types_per_file": 2,
   "include_extensions": [
     ".cs",
     ".py"
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..b6496c5
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,10 @@
+* @daliys
+
+# Quality Gate & CI Policy files strictly owned by @daliys
+/.code-linter.json @daliys
+/.ruff.toml @daliys
+/.unity-quality-gate.json @daliys
+/.swift-quality-gate.json @daliys
+/.slop-review.json @daliys
+/.github/workflows/ @daliys
+/.github/CODEOWNERS @daliys
diff --git a/API_REFERENCE.MD b/API_REFERENCE.MD
index 2617c4f..dfabc36 100644
--- a/API_REFERENCE.MD
+++ b/API_REFERENCE.MD
@@ -192,7 +192,7 @@ Actions: `undo`, `redo`, `play`, `pause`, `step`, `menu`, `read_logs`, `clear_lo
 ### `unity_ui_automation`
 Actions: `list_windows`, `get_hierarchy`, `query`, `get_window_rect`, `set_window_rect`, `capture_window_snapshot`, `click`, `input`.
 
-`get_hierarchy` accepts `deep`. `query` accepts `name`, `text`, and `class_name`. Window rect and snapshot actions are intended for resize/layout QA; window snapshots include rect and hierarchy, with best-effort PNG image capture on macOS.
+`get_hierarchy` accepts `deep`, `max_depth`, and `max_elements` (with `children_truncated` and root `truncated` markers when capped). `query` accepts `name`, `text`, `class_name`, `max_depth`, and `max_results`. Window rect and snapshot actions are intended for resize/layout QA; window snapshots include rect and hierarchy (supporting `max_depth` and `max_elements`), with best-effort PNG image capture on macOS.
 
 ### `unity_wait`
 Conditions: `compilation`, `play_mode`, `import`, `editor_idle`.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e37e3c..847121f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@ All notable public changes to Nexus Unity are documented here.
 - Consolidated duplicate internal Ollama-review and serialized-property write helpers.
 
 ### Fixed
+- Add traversal depth and element/result bounds to UI Toolkit hierarchy serialization and element queries (`ui_get_hierarchy`, `ui_query_elements`, and `ui_capture_window_snapshot`), preventing editor stalls and payload bloat on complex UI windows, with `children_truncated` and `truncated` markers on partial hierarchy responses (#126).
 - Dispatch WebSocket request handling asynchronously in `Task.Run`, ensuring `ServerLoop` remains non-blocking for concurrent HTTP JSON-RPC requests and new connections (#129).
 - `EditorApplication.update` subscription for `HandlePostCompileFocusReturn` is now idempotent (unsubscribes before subscribing), preventing stacked duplicate frame handlers on repeated initialization or domain reloads (#138).
 - `ListPlayerPrefs` now uses `ProcessStartInfo.ArgumentList` and timeout guards for macOS `defaults read` execution, preventing process hangs, alongside regex unhashing for Windows registry keys, Linux XML prefs support, and double-default type verification (#143).
diff --git a/DOCUMENTATION.MD b/DOCUMENTATION.MD
index 654f90b..7cab974 100644
--- a/DOCUMENTATION.MD
+++ b/DOCUMENTATION.MD
@@ -117,7 +117,7 @@ MCP bridge:
 - `unity_hierarchy_manager` can create primitives with name, parent, transform, and material path; it can also rename, set transforms, and pass through `create_hierarchy`.
 - Raw `run_tests` returns `Submitted` when Unity accepts the asynchronous request; it does not confirm that execution has begun or completed. `unity_editor_controller` `run_tests_wait` waits in the Python bridge by polling raw `get_test_results` instead of blocking the Unity main thread.
 - `unity_editor_controller` also exposes `get_tool_usage_stats` and `reset_tool_usage_stats` so diagnostics are not split between raw and manager workflows.
-- `unity_ui_automation` passes through `deep` for UI hierarchy reads, `class_name` for queries, and window rect/snapshot actions for layout checks.
+- `unity_ui_automation` passes through `deep`, `max_depth`, and `max_elements` for UI hierarchy reads, `class_name`, `max_depth`, and `max_results` for queries, and window rect/snapshot actions for layout checks.
 
 ## Current Compatibility Decisions
 
diff --git a/Editor/MCPCliInstaller.ClaudeCode.cs b/Editor/MCPCliInstaller.ClaudeCode.cs
index e7734f0..619901c 100644
--- a/Editor/MCPCliInstaller.ClaudeCode.cs
+++ b/Editor/MCPCliInstaller.ClaudeCode.cs
@@ -1,8 +1,8 @@
-using UnityEditor;
-using UnityEngine;
-using System.IO;
 using System;
+using System.IO;
 using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
 
 namespace UnityMCP.Editor
 {
@@ -15,9 +15,7 @@ public static partial class MCPCliInstaller
         /// <remarks>
         /// Prefers the official <c>claude</c> CLI (<c>claude mcp add --scope project</c>, which itself writes
         /// <c>.mcp.json</c>). When the CLI is unavailable or fails, it falls back to writing <c>.mcp.json</c> directly.
-        /// Either path produces the same project-root <c>.mcp.json</c> that the Integrations tab tracks. This is distinct
-        /// from the Claude Desktop app config, which is handled by the generic JSON-config codepath in
-        /// <see cref="NexusMcpConfigGenerator"/> instead of a dedicated CLI installer.
+        /// Either path produces the same project-root <c>.mcp.json</c> that the Integrations tab tracks.
         /// </remarks>
         public static void LinkToClaudeCode()
         {
@@ -31,45 +29,43 @@ public static void LinkToClaudeCode()
         private static void ExecuteClaudeCodeLinkSequence(string scriptPath, string pythonPath)
         {
             string claudePath = ResolveExecutablePath("claude");
-
-            // Preferred path: the official claude CLI writes the project-scoped .mcp.json for us.
             if (!string.IsNullOrEmpty(claudePath) && claudePath != "claude")
             {
-                // 1. Remove any stale registration so re-running is idempotent.
-                // A missing registration is expected on first setup and is safe to add over.
-                bool removedStaleRegistration = RunInstallerProcess(CreateProcessStartInfo(claudePath, "mcp", "remove", "--scope", "project", "nexus-unity"), claudePath, false, "Claude Code", out string removeError, false);
-                bool registrationWasAbsent = !removedStaleRegistration && IsClaudeCodeRegistrationAbsent(removeError);
-
-                // 2. Add the server at project scope only when the prior state is known to be clear.
-                if ((removedStaleRegistration || registrationWasAbsent) && RunInstallerProcess(CreateProcessStartInfo(claudePath, "mcp", "add", "--transport", "stdio", "--scope", "project", "--env", MCPServer.AuthTokenEnvironmentVariable + "=" + MCPServer.AuthToken, "nexus-unity", "--", pythonPath, scriptPath), claudePath, false, "Claude Code"))
+                if (TryLinkViaClaudeCli(claudePath, scriptPath, pythonPath))
                 {
-                    NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Successfully linked Nexus Unity to Claude Code via '" + claudePath + "'.", true);
-                    EditorUtility.DisplayDialog("MCP Success", "Successfully linked Nexus Unity to Claude Code.\n\nRun /mcp inside Claude Code (or restart it) to load the server.", "OK");
                     return;
                 }
+            }
+
+            WriteClaudeCodeDirectJson(scriptPath, pythonPath);
+        }
 
-                NexusEditorLog.Warning(NexusLogCategory.Integrations, (removedStaleRegistration || registrationWasAbsent)
-                    ? "[MCP] Claude Code CLI add command failed at '" + claudePath + "'. Falling back to direct .mcp.json edit."
-                    : "[MCP] Claude Code CLI could not remove the existing registration at '" + claudePath + "': " + removeError + ". Skipping CLI add and falling back to direct .mcp.json edit.");
+        private static bool TryLinkViaClaudeCli(string claudePath, string scriptPath, string pythonPath)
+        {
+            bool removedStale = RunInstallerProcess(CreateProcessStartInfo(claudePath, "mcp", "remove", "--scope", "project", "nexus-unity"), false, "Claude Code", out string removeError, false);
+            bool registrationAbsent = !removedStale && IsClaudeCodeRegistrationAbsent(removeError);
+
+            if ((removedStale || registrationAbsent) && RunInstallerProcess(CreateProcessStartInfo(claudePath, "mcp", "add", "--transport", "stdio", "--scope", "project", "--env", MCPServer.AuthTokenEnvironmentVariable + "=" + MCPServer.AuthToken, "nexus-unity", "--", pythonPath, scriptPath), claudePath, false, "Claude Code"))
+            {
+                NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Successfully linked Nexus Unity to Claude Code via '" + claudePath + "'.", true);
+                EditorUtility.DisplayDialog("MCP Success", "Successfully linked Nexus Unity to Claude Code.\n\nRun /mcp inside Claude Code (or restart it) to load the server.", "OK");
+                return true;
             }
 
-            // Fallback: write the project-root .mcp.json directly.
+            NexusEditorLog.Warning(NexusLogCategory.Integrations, (removedStale || registrationAbsent)
+                ? "[MCP] Claude Code CLI add command failed at '" + claudePath + "'. Falling back to direct .mcp.json edit."
+                : "[MCP] Claude Code CLI could not remove the existing registration at '" + claudePath + "': " + removeError + ". Skipping CLI add and falling back to direct .mcp.json edit.");
+            return false;
+        }
+
+        private static void WriteClaudeCodeDirectJson(string scriptPath, string pythonPath)
+        {
             try
             {
                 string projectRoot = Path.GetDirectoryName(Application.dataPath);
                 string configPath = Path.Combine(projectRoot, ".mcp.json");
 
-                JObject config;
-                if (File.Exists(configPath))
-                {
-                    try { config = JObject.Parse(File.ReadAllText(configPath)); }
-                    catch { config = new JObject(); }
-                }
-                else
-                {
-                    config = new JObject();
-                }
-
+                JObject config = LoadOrCreateJsonObject(configPath);
                 if (config["mcpServers"] == null) config["mcpServers"] = new JObject();
                 JObject servers = (JObject)config["mcpServers"];
 
@@ -93,6 +89,16 @@ private static void ExecuteClaudeCodeLinkSequence(string scriptPath, string pyth
             }
         }
 
+        private static JObject LoadOrCreateJsonObject(string path)
+        {
+            if (File.Exists(path))
+            {
+                try { return JObject.Parse(File.ReadAllText(path)); }
+                catch { return new JObject(); }
+            }
+            return new JObject();
+        }
+
         internal static bool IsClaudeCodeRegistrationAbsent(string error)
         {
             return !string.IsNullOrEmpty(error)
diff --git a/Editor/MCPCliInstaller.Deploy.cs b/Editor/MCPCliInstaller.Deploy.cs
new file mode 100644
index 0000000..e3666bc
--- /dev/null
+++ b/Editor/MCPCliInstaller.Deploy.cs
@@ -0,0 +1,164 @@
+using System;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPCliInstaller
+    {
+        private static bool DeployBridgeScript(out string destinationPath)
+        {
+            destinationPath = null;
+            string sourcePath = FindBridgeScript();
+
+            if (string.IsNullOrEmpty(sourcePath))
+            {
+                NexusEditorLog.Error(NexusLogCategory.Integrations, "[MCP] Could not find 'nexus_unity_bridge.py' in the project.");
+                EditorUtility.DisplayDialog("MCP Error", "Could not find 'nexus_unity_bridge.py'.\n\nEnsure the library is correctly imported.", "OK");
+                return false;
+            }
+
+            string projectRoot = Path.GetDirectoryName(Application.dataPath);
+            destinationPath = Path.Combine(projectRoot, "nexus_unity_bridge.py");
+
+            try
+            {
+                File.Copy(sourcePath, destinationPath, true);
+                DeployBridgeModule(projectRoot, sourcePath);
+                NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Bridge script deployed to stable location: " + destinationPath, true);
+                DeployDocumentationPointer(projectRoot, sourcePath);
+                return true;
+            }
+            catch (Exception e)
+            {
+                NexusEditorLog.Error(NexusLogCategory.Integrations, "[MCP] Failed to deploy bridge or docs: " + e.Message);
+                EditorUtility.DisplayDialog("MCP Error", "Failed to deploy integration files to project root.\n\n" + e.Message, "OK");
+                return false;
+            }
+        }
+
+        private static void DeployBridgeModule(string projectRoot, string sourcePath)
+        {
+            string sourceDir = Path.GetDirectoryName(sourcePath);
+            string sourceModuleDir = Path.Combine(sourceDir, "nexus_bridge");
+            if (!Directory.Exists(sourceModuleDir))
+            {
+                return;
+            }
+
+            string destinationModuleDir = Path.Combine(projectRoot, "nexus_bridge");
+            CopyDirectory(sourceModuleDir, destinationModuleDir);
+            NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Bridge module deployed to stable location: " + destinationModuleDir);
+        }
+
+        private static void CopyDirectory(string sourceDir, string destinationDir)
+        {
+            Directory.CreateDirectory(destinationDir);
+
+            foreach (string file in Directory.GetFiles(sourceDir))
+            {
+                string fileName = Path.GetFileName(file);
+                if (fileName.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) ||
+                    fileName.EndsWith(".pyc", StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                File.Copy(file, Path.Combine(destinationDir, fileName), true);
+            }
+
+            foreach (string dir in Directory.GetDirectories(sourceDir))
+            {
+                string dirName = Path.GetFileName(dir);
+                if (dirName == "__pycache__")
+                {
+                    continue;
+                }
+
+                CopyDirectory(dir, Path.Combine(destinationDir, dirName));
+            }
+        }
+
+        private static string FindLibraryRoot(string sourcePath)
+        {
+            string dir = Path.GetDirectoryName(sourcePath);
+            while (!string.IsNullOrEmpty(dir))
+            {
+                if (File.Exists(Path.Combine(dir, "package.json")))
+                {
+                    return dir;
+                }
+                dir = Path.GetDirectoryName(dir);
+            }
+            return null;
+        }
+
+        private static void DeployDocumentationPointer(string projectRoot, string sourcePath)
+        {
+            string libraryRoot = FindLibraryRoot(sourcePath);
+            if (string.IsNullOrEmpty(libraryRoot))
+            {
+                return;
+            }
+
+            string docSource = Path.Combine(libraryRoot, "DOCUMENTATION.MD");
+            if (!File.Exists(docSource))
+            {
+                return;
+            }
+
+            string relativeDocPath = GetRelativePath(projectRoot, docSource).Replace("\\", "/");
+            string pointerPath = Path.Combine(projectRoot, "NEXUS_UNITY_DOCUMENTATION.md");
+            string pointerContent = "# Nexus Unity Documentation\n\n" +
+                                   "The canonical Nexus Unity documentation is maintained in the package root:\n\n" +
+                                   "- [DOCUMENTATION.MD](" + relativeDocPath + ")\n\n" +
+                                   "Keep all edits in the package copy so changes stay with version control.\n";
+
+            File.WriteAllText(pointerPath, pointerContent);
+        }
+
+        private static string GetRelativePath(string fromPath, string toPath)
+        {
+            Uri fromUri = new Uri(AppendDirectorySeparator(Path.GetFullPath(fromPath)));
+            Uri toUri = new Uri(Path.GetFullPath(toPath));
+            Uri relativeUri = fromUri.MakeRelativeUri(toUri);
+            return Uri.UnescapeDataString(relativeUri.ToString());
+        }
+
+        private static string AppendDirectorySeparator(string path)
+        {
+            if (path.EndsWith(Path.DirectorySeparatorChar.ToString()) ||
+                path.EndsWith(Path.AltDirectorySeparatorChar.ToString()))
+            {
+                return path;
+            }
+            return path + Path.DirectorySeparatorChar;
+        }
+
+        private static string FindBridgeScript()
+        {
+            string[] guids = AssetDatabase.FindAssets("nexus_unity_bridge");
+            foreach (string guid in guids)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+                if (path.EndsWith("nexus_unity_bridge.py"))
+                {
+                    return Path.GetFullPath(path);
+                }
+            }
+
+            string manualSearch = Path.Combine(Application.dataPath, "nexus_unity_bridge.py");
+            if (File.Exists(manualSearch))
+            {
+                return manualSearch;
+            }
+
+            foreach (string path in Directory.GetFiles(Application.dataPath, "*.py", SearchOption.AllDirectories))
+            {
+                if (path.EndsWith("nexus_unity_bridge.py")) return Path.GetFullPath(path);
+            }
+            return null;
+        }
+    }
+}
diff --git a/Editor/MCPCliInstaller.Deploy.cs.meta b/Editor/MCPCliInstaller.Deploy.cs.meta
new file mode 100644
index 0000000..a7c88f2
--- /dev/null
+++ b/Editor/MCPCliInstaller.Deploy.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: be5b21cfbca94822a22c7c66930cd272
diff --git a/Editor/MCPCliInstaller.cs b/Editor/MCPCliInstaller.cs
index 47c3e07..24c396a 100644
--- a/Editor/MCPCliInstaller.cs
+++ b/Editor/MCPCliInstaller.cs
@@ -1,9 +1,9 @@
-using UnityEditor;
-using UnityEngine;
-using System.IO;
-using System.Diagnostics;
 using System;
+using System.Diagnostics;
+using System.IO;
 using System.Text;
+using UnityEditor;
+using UnityEngine;
 
 namespace UnityMCP.Editor
 {
@@ -16,226 +16,77 @@ namespace UnityMCP.Editor
     /// </remarks>
     public static partial class MCPCliInstaller
     {
-
-
-        private static bool DeployBridgeScript(out string destinationPath)
-        {
-            destinationPath = null;
-            string sourcePath = FindBridgeScript();
-
-            if (string.IsNullOrEmpty(sourcePath))
-            {
-                NexusEditorLog.Error(NexusLogCategory.Integrations, "[MCP] Could not find 'nexus_unity_bridge.py' in the project.");
-                EditorUtility.DisplayDialog("MCP Error", "Could not find 'nexus_unity_bridge.py'.\n\nEnsure the library is correctly imported.", "OK");
-                return false;
-            }
-
-            string projectRoot = Path.GetDirectoryName(Application.dataPath);
-            destinationPath = Path.Combine(projectRoot, "nexus_unity_bridge.py");
-
-            try
-            {
-                File.Copy(sourcePath, destinationPath, true);
-                DeployBridgeModule(projectRoot, sourcePath);
-                NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Bridge script deployed to stable location: " + destinationPath, true);
-                DeployDocumentationPointer(projectRoot, sourcePath);
-                return true;
-            }
-            catch (Exception e)
-            {
-                NexusEditorLog.Error(NexusLogCategory.Integrations, "[MCP] Failed to deploy bridge or docs: " + e.Message);
-                EditorUtility.DisplayDialog("MCP Error", "Failed to deploy integration files to project root.\n\n" + e.Message, "OK");
-                return false;
-            }
-        }
-
-        private static void DeployBridgeModule(string projectRoot, string sourcePath)
-        {
-            string sourceDir = Path.GetDirectoryName(sourcePath);
-            string sourceModuleDir = Path.Combine(sourceDir, "nexus_bridge");
-            if (!Directory.Exists(sourceModuleDir))
-            {
-                return;
-            }
-
-            string destinationModuleDir = Path.Combine(projectRoot, "nexus_bridge");
-            CopyDirectory(sourceModuleDir, destinationModuleDir);
-            NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Bridge module deployed to stable location: " + destinationModuleDir);
-        }
-
-        private static void CopyDirectory(string sourceDir, string destinationDir)
+        private static string ResolveExecutablePath(string name)
         {
-            Directory.CreateDirectory(destinationDir);
-
-            foreach (string file in Directory.GetFiles(sourceDir))
+            if (Application.platform == RuntimePlatform.WindowsEditor)
             {
-                string fileName = Path.GetFileName(file);
-                if (fileName.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) ||
-                    fileName.EndsWith(".pyc", StringComparison.OrdinalIgnoreCase))
-                {
-                    continue;
-                }
-
-                File.Copy(file, Path.Combine(destinationDir, fileName), true);
+                string fromWhere = GetPathFromWhere(name);
+                return string.IsNullOrEmpty(fromWhere) ? name : fromWhere;
             }
 
-            foreach (string dir in Directory.GetDirectories(sourceDir))
+            if (name == "codex")
             {
-                string dirName = Path.GetFileName(dir);
-                if (dirName == "__pycache__")
-                {
-                    continue;
-                }
-
-                CopyDirectory(dir, Path.Combine(destinationDir, dirName));
+                string nvmCodex = ResolveNvmCodex();
+                if (!string.IsNullOrEmpty(nvmCodex)) return nvmCodex;
             }
-        }
 
-        private static string FindLibraryRoot(string sourcePath)
-        {
-            string dir = Path.GetDirectoryName(sourcePath);
-            while (!string.IsNullOrEmpty(dir))
-            {
-                if (File.Exists(Path.Combine(dir, "package.json")))
-                {
-                    return dir;
-                }
-                dir = Path.GetDirectoryName(dir);
-            }
-            return Path.GetDirectoryName(sourcePath);
-        }
-
-        private static void DeployDocumentationPointer(string projectRoot, string sourcePath)
-        {
-            string libraryRoot = FindLibraryRoot(sourcePath);
-            string[] docFiles = { "API_REFERENCE.MD", "DOCUMENTATION.MD" };
-
-            foreach (string file in docFiles)
+            string pathFromWhich = GetPathFromWhich(name);
+            if (!string.IsNullOrEmpty(pathFromWhich) && pathFromWhich != name && File.Exists(pathFromWhich))
             {
-                string src = Path.Combine(libraryRoot, file);
-                if (File.Exists(src))
+                if (name != "codex" || !pathFromWhich.Contains("homebrew"))
                 {
-                    try
-                    {
-                        string dst = Path.Combine(projectRoot, file);
-                        File.Copy(src, dst, true);
-                        NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Copied documentation to root: " + dst);
-                    }
-                    catch (Exception e)
-                    {
-                        NexusEditorLog.Warning(NexusLogCategory.Integrations, "[MCP] Failed to copy " + file + " to root: " + e.Message);
-                    }
+                    return pathFromWhich;
                 }
             }
 
-            string docPointerPath = Path.Combine(projectRoot, "NEXUS_UNITY_DOCS.md");
-            string docContent = "# Nexus Unity - AI Context\n\n" +
-                               "This project uses **Nexus Unity** for AI Editor automation.\n\n" +
-                               "## 📚 Documentation Access\n" +
-                               "- **Full Tool Reference**: [API_REFERENCE.MD](API_REFERENCE.MD)\n" +
-                               "- **Technical Guide**: [DOCUMENTATION.MD](DOCUMENTATION.MD)\n\n" +
-                               "## 🤖 AI Instructions\n" +
-                               "Before performing any Unity tasks, ALWAYS read `API_REFERENCE.MD` to understand the available tools, their parameters, and the surgical editing patterns required for this project.";
-
-            File.WriteAllText(docPointerPath, docContent);
-            NexusEditorLog.Log(NexusLogCategory.Integrations, "[MCP] Documentation pointer deployed: " + docPointerPath);
+            return ResolveSystemExecutable(name);
         }
 
-
-
-        private static string FindBridgeScript()
+        private static string ResolveNvmCodex()
         {
-            string[] guids = AssetDatabase.FindAssets("MCPCliInstaller t:Script");
-            foreach (var guid in guids)
-            {
-                string path = AssetDatabase.GUIDToAssetPath(guid);
-                if (!path.Contains("NexusUnity")) continue;
-                
-                string dir = Path.GetDirectoryName(path);
-                string potentialBridge = Path.Combine(dir, "nexus_unity_bridge.py");
-                if (File.Exists(Path.GetFullPath(potentialBridge))) return Path.GetFullPath(potentialBridge);
-            }
+            string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            string nvmBase = Path.Combine(home, ".nvm/versions/node");
+            if (!Directory.Exists(nvmBase)) return null;
 
-            foreach (var path in AssetDatabase.GetAllAssetPaths())
+            foreach (var versionDir in Directory.GetDirectories(nvmBase))
             {
-                if (path.EndsWith("nexus_unity_bridge.py")) return Path.GetFullPath(path);
+                string potential = Path.Combine(versionDir, "bin/codex");
+                if (File.Exists(potential)) return potential;
             }
             return null;
         }
 
-        private static string ResolveExecutablePath(string name)
+        private static string ResolveSystemExecutable(string name)
         {
-            if (Application.platform == RuntimePlatform.WindowsEditor)
-            {
-                // 'which' does not exist on Windows; use 'where' to resolve against PATH (and PATHEXT, so
-                // .cmd/.exe shims like gemini.cmd are found). Falls back to the bare name when unresolved.
-                string fromWhere = GetPathFromWhere(name);
-                return string.IsNullOrEmpty(fromWhere) ? name : fromWhere;
-            }
-
-            // 1. Explicit check for NVM/Node paths (High priority for Codex)
-            if (name == "codex")
-            {
-                string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
-                string nvmBase = Path.Combine(home, ".nvm/versions/node");
-                if (Directory.Exists(nvmBase))
-                {
-                    foreach (var versionDir in Directory.GetDirectories(nvmBase))
-                    {
-                        string potential = Path.Combine(versionDir, "bin/codex");
-                        if (File.Exists(potential)) return potential;
-                    }
-                }
-            }
-
-            // 2. Try 'which' (respects shell PATH)
-            string pathFromWhich = GetPathFromWhich(name);
-            if (!string.IsNullOrEmpty(pathFromWhich) && pathFromWhich != name && File.Exists(pathFromWhich))
-            {
-                // Only return if it's not the older homebrew version of codex (if we can tell)
-                if (name == "codex" && pathFromWhich.Contains("homebrew")) {
-                    // Continue to fallback if we prefer NVM
-                } else {
-                    return pathFromWhich;
-                }
-            }
-
-            // 3. Common system paths
-            string[] searchPaths = { 
-                "/usr/local/bin/" + name, 
-                "/opt/homebrew/bin/" + name, 
-                "/usr/bin/" + name, 
-                "/bin/" + name 
+            string[] searchPaths = {
+                "/usr/local/bin/" + name,
+                "/opt/homebrew/bin/" + name,
+                "/usr/bin/" + name,
+                "/bin/" + name
             };
 
             foreach (string path in searchPaths)
             {
                 if (File.Exists(path)) return path;
             }
-
             return name;
         }
 
         private static string GetPathFromWhich(string name)
         {
-            ProcessStartInfo psi = new ProcessStartInfo 
-            { 
-                FileName = "/usr/bin/which", 
-                Arguments = name, 
-                RedirectStandardOutput = true, 
-                UseShellExecute = false, 
-                CreateNoWindow = true 
+            ProcessStartInfo psi = new ProcessStartInfo
+            {
+                FileName = "/usr/bin/which",
+                Arguments = name,
+                RedirectStandardOutput = true,
+                UseShellExecute = false,
+                CreateNoWindow = true
             };
 
             if (Application.platform != RuntimePlatform.WindowsEditor)
             {
                 string pathEnv = "";
                 try { pathEnv = Environment.GetEnvironmentVariable("PATH"); } catch(Exception) {}
-                // Unity launched from Finder/Hub (not a terminal) inherits a stripped PATH
-                // (typically just /usr/bin:/bin:/usr/sbin:/sbin) with no /usr/local/bin or /opt/homebrew/bin.
-                // 'which' would then resolve python3 to the old Xcode-bundled interpreter at /usr/bin/python3
-                // instead of a modern one. Prepend common interpreter locations so they're checked first,
-                // matching the priority order ResolveExecutablePath's own fallback search list already uses.
                 psi.EnvironmentVariables["PATH"] = "/usr/local/bin:/opt/homebrew/bin:" + pathEnv;
             }
 
@@ -269,14 +120,13 @@ private static string GetPathFromWhere(string name)
                 {
                     string output = p.StandardOutput.ReadToEnd();
                     p.WaitForExit();
-                    if (p.ExitCode == 0 && !string.IsNullOrWhiteSpace(output))
+                    if (p.ExitCode != 0 || string.IsNullOrWhiteSpace(output)) return null;
+
+                    string[] lines = output.Split('\n');
+                    for (int i = 0; i < lines.Length; i++)
                     {
-                        // 'where' can list multiple matches, one per line. Take the first that exists on disk.
-                        foreach (string line in output.Split('\n'))
-                        {
-                            string candidate = line.Trim();
-                            if (!string.IsNullOrEmpty(candidate) && File.Exists(candidate)) return candidate;
-                        }
+                        string candidate = lines[i].Trim();
+                        if (!string.IsNullOrEmpty(candidate) && File.Exists(candidate)) return candidate;
                     }
                 }
             }
@@ -284,14 +134,6 @@ private static string GetPathFromWhere(string name)
             return null;
         }
 
-        /// <summary>
-        /// Resolves the Python interpreter to embed in generated MCP configs, preferring a concrete path.
-        /// Tries <c>python3</c>, then <c>python</c>, then the Windows <c>py</c> launcher (which defaults to Python 3).
-        /// </summary>
-        /// <remarks>
-        /// Generated configs previously hardcoded <c>python3</c>, which is frequently absent from PATH on Windows
-        /// (where the interpreter is usually <c>python</c> or the <c>py</c> launcher), so the bridge failed to launch.
-        /// </remarks>
         private static string ResolvePythonPath()
         {
             string python3 = ResolveExecutablePath("python3");
@@ -300,7 +142,6 @@ private static string ResolvePythonPath()
             string python = ResolveExecutablePath("python");
             if (!string.IsNullOrEmpty(python) && python != "python") return python;
 
-            // Windows commonly ships the 'py' launcher instead of a 'python3' alias; 'py <script>' runs Python 3.
             if (Application.platform == RuntimePlatform.WindowsEditor) return "py";
 
             return "python3";
@@ -324,8 +165,6 @@ private static ProcessStartInfo CreateProcessStartInfo(string executable, params
             {
                 string pathEnv = "";
                 try { pathEnv = Environment.GetEnvironmentVariable("PATH"); } catch(Exception) {}
-                
-                // Add common locations but keep existing PATH to support NVM, etc.
                 psi.EnvironmentVariables["PATH"] = pathEnv + ":/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin";
             }
             return psi;
@@ -378,7 +217,6 @@ private static string QuoteWindowsArgument(string argument)
                     backslashes++;
                     continue;
                 }
-
                 if (c == '"')
                 {
                     result.Append('\\', backslashes * 2 + 1);
@@ -397,12 +235,13 @@ private static string QuoteWindowsArgument(string argument)
 
         private static bool RunInstallerProcess(ProcessStartInfo psi, string cliPath, bool showSuccessDialog, string cliName)
         {
-            return RunInstallerProcess(psi, cliPath, showSuccessDialog, cliName, out _, true);
+            return RunInstallerProcess(psi, showSuccessDialog, cliName, out _, true);
         }
 
-        private static bool RunInstallerProcess(ProcessStartInfo psi, string cliPath, bool showSuccessDialog, string cliName, out string error, bool logFailure)
+        private static bool RunInstallerProcess(ProcessStartInfo psi, bool showSuccessDialog, string cliName, out string error, bool logFailure)
         {
             error = string.Empty;
+            string cliPath = psi.FileName;
             try
             {
                 using (Process p = Process.Start(psi))
@@ -414,15 +253,13 @@ private static bool RunInstallerProcess(ProcessStartInfo psi, string cliPath, bo
                     {
                         return true;
                     }
-                    else
+
+                    string msg = "CLI command failed at " + cliPath + ".\n\nExit Code: " + p.ExitCode + "\nError: " + error;
+                    if (logFailure) NexusEditorLog.Warning(NexusLogCategory.Integrations, "[MCP] " + msg);
+
+                    if (showSuccessDialog)
                     {
-                        string msg = "CLI command failed at " + cliPath + ".\n\nExit Code: " + p.ExitCode + "\nError: " + error;
-                        if (logFailure) NexusEditorLog.Warning(NexusLogCategory.Integrations, "[MCP] " + msg);
-                        
-                        if (showSuccessDialog) // If this was supposed to be the final step
-                        {
-                            EditorUtility.DisplayDialog("MCP Error", "Failed to link to " + cliName + " CLI.\n\n" + error, "OK");
-                        }
+                        EditorUtility.DisplayDialog("MCP Error", "Failed to link to " + cliName + " CLI.\n\n" + error, "OK");
                     }
                 }
             }
diff --git a/Editor/MCPServer.Port.cs b/Editor/MCPServer.Port.cs
new file mode 100644
index 0000000..2aaac53
--- /dev/null
+++ b/Editor/MCPServer.Port.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Net.NetworkInformation;
+using UnityEngine;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServer
+    {
+        private static bool IsPortBusy(int port)
+        {
+            try
+            {
+                var listeners = IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpListeners();
+                if (listeners != null && listeners.Any(listener => listener.Port == port)) return true;
+            }
+            catch { }
+
+            try
+            {
+                using (var tcp = new System.Net.Sockets.TcpClient())
+                {
+                    var result = tcp.BeginConnect("127.0.0.1", port, null, null);
+                    if (!result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(200))) return false;
+                    tcp.EndConnect(result);
+                    return true;
+                }
+            }
+            catch { return false; }
+        }
+
+        private static string GetPortOwner(int port)
+        {
+            try
+            {
+                if (IsUnixEditor()) return GetUnixPortOwner(port);
+                if (Application.platform == RuntimePlatform.WindowsEditor) return GetWindowsPortOwner(port);
+            }
+            catch { }
+            return "Unknown Process";
+        }
+
+        private static bool IsUnixEditor()
+        {
+            return Application.platform == RuntimePlatform.OSXEditor ||
+                Application.platform == RuntimePlatform.LinuxEditor;
+        }
+
+        private static string GetUnixPortOwner(int port)
+        {
+            string arguments = $"-c \"lsof -i TCP:{port} -s TCP:LISTEN -P -n || /usr/sbin/lsof -i TCP:{port} -s TCP:LISTEN -P -n\"";
+            var lines = SplitCommandOutput(RunPortCommand("/bin/bash", arguments));
+            if (lines.Length <= 1) return "Unknown Process";
+
+            var parts = lines[1].Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
+            return parts.Length >= 2 ? $"{parts[0]} (PID: {parts[1]})" : "Unknown Process";
+        }
+
+        private static string GetWindowsPortOwner(int port)
+        {
+            string output = RunPortCommand("cmd.exe", $"/c netstat -a -n -o | findstr :{port}");
+            foreach (var line in SplitCommandOutput(output))
+            {
+                var owner = ParseWindowsPortOwner(line);
+                if (owner != null) return owner;
+            }
+            return "Unknown Process";
+        }
+
+        private static string ParseWindowsPortOwner(string line)
+        {
+            if (!line.Contains("LISTENING")) return null;
+            var parts = line.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
+            if (parts.Length == 0) return null;
+
+            string pid = parts[parts.Length - 1];
+            try
+            {
+                using (var process = Process.GetProcessById(int.Parse(pid)))
+                    return $"{process.ProcessName} (PID: {pid})";
+            }
+            catch { return $"PID: {pid}"; }
+        }
+
+        private static string RunPortCommand(string fileName, string arguments)
+        {
+            using (var process = new Process())
+            {
+                process.StartInfo.FileName = fileName;
+                process.StartInfo.Arguments = arguments;
+                process.StartInfo.UseShellExecute = false;
+                process.StartInfo.RedirectStandardOutput = true;
+                process.StartInfo.CreateNoWindow = true;
+                process.Start();
+                string output = process.StandardOutput.ReadToEnd();
+                process.WaitForExit();
+                return output;
+            }
+        }
+
+        private static string[] SplitCommandOutput(string output)
+        {
+            return output.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
+        }
+
+        private static void ParseCommandLineArgs()
+        {
+            string[] args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length - 1; i++)
+            {
+                if (args[i] == "--mcp-port" && int.TryParse(args[i + 1], out int port))
+                    _cliPortOverride = port;
+            }
+        }
+    }
+}
diff --git a/Editor/MCPServer.Port.cs.meta b/Editor/MCPServer.Port.cs.meta
new file mode 100644
index 0000000..4f74156
--- /dev/null
+++ b/Editor/MCPServer.Port.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 80aecc72c415046a49b84074397a98a7
diff --git a/Editor/MCPServer.Utils.cs b/Editor/MCPServer.Utils.cs
deleted file mode 100644
index e2e481a..0000000
--- a/Editor/MCPServer.Utils.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.IO;
-using System.Net;
-using System.Net.WebSockets;
-using System.Net.NetworkInformation;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Linq;
-using UnityEditor;
-using UnityEngine;
-
-namespace UnityMCP.Editor
-{
-    public static partial class MCPServer
-    {
-        private static bool IsPortBusy(int port)
-        {
-            try {
-                var ipProperties = IPGlobalProperties.GetIPGlobalProperties();
-                var tcpListeners = ipProperties.GetActiveTcpListeners();
-                if (tcpListeners != null && tcpListeners.Any(l => l.Port == port)) return true;
-            } catch { }
-
-            try
-            {
-                using (var tcp = new System.Net.Sockets.TcpClient()) {
-                    var result = tcp.BeginConnect("127.0.0.1", port, null, null);
-                    if (result.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(200))) {
-                        tcp.EndConnect(result);
-                        return true;
-                    }
-                }
-            } catch { }
-            return false;
-        }
-
-
-        private static string GetPortOwner(int port)
-        {
-            try
-            {
-                var p = new System.Diagnostics.Process();
-                p.StartInfo.UseShellExecute = false;
-                p.StartInfo.RedirectStandardOutput = true;
-                p.StartInfo.CreateNoWindow = true;
-
-                if (Application.platform == RuntimePlatform.OSXEditor || Application.platform == RuntimePlatform.LinuxEditor)
-                {
-                    p.StartInfo.FileName = "/bin/bash";
-                    p.StartInfo.Arguments = $"-c \"lsof -i TCP:{port} -s TCP:LISTEN -P -n || /usr/sbin/lsof -i TCP:{port} -s TCP:LISTEN -P -n\"";
-                    p.Start();
-                    string output = p.StandardOutput.ReadToEnd();
-                    p.WaitForExit();
-
-                    string[] lines = output.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
-                    if (lines.Length > 1)
-                    {
-                        string[] parts = lines[1].Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
-                        if (parts.Length >= 2) return $"{parts[0]} (PID: {parts[1]})";
-                    }
-                }
-                else if (Application.platform == RuntimePlatform.WindowsEditor)
-                {
-                    p.StartInfo.FileName = "cmd.exe";
-                    p.StartInfo.Arguments = $"/c netstat -a -n -o | findstr :{port}";
-                    p.Start();
-                    string output = p.StandardOutput.ReadToEnd();
-                    p.WaitForExit();
-
-                    string[] lines = output.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
-                    foreach (var line in lines)
-                    {
-                        if (line.Contains("LISTENING"))
-                        {
-                            string[] parts = line.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
-                            if (parts.Length > 0)
-                            {
-                                string pid = parts[parts.Length - 1];
-                                try
-                                {
-                                    var proc = System.Diagnostics.Process.GetProcessById(int.Parse(pid));
-                                    return $"{proc.ProcessName} (PID: {pid})";
-                                }
-                                catch { return $"PID: {pid}"; }
-                            }
-                        }
-                    }
-                }
-            }
-            catch { }
-            return "Unknown Process";
-        }
-
-
-        private static void ParseCommandLineArgs()
-        {
-            string[] args = Environment.GetCommandLineArgs();
-            for (int i = 0; i < args.Length - 1; i++)
-                if (args[i] == "--mcp-port" && int.TryParse(args[i + 1], out int p)) _cliPortOverride = p;
-        }
-    }
-}
diff --git a/Editor/MCPServer.Utils.cs.meta b/Editor/MCPServer.Utils.cs.meta
deleted file mode 100644
index 3cdb783..0000000
--- a/Editor/MCPServer.Utils.cs.meta
+++ /dev/null
@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 80aecc72c415046a49b84074397a98a7
\ No newline at end of file
diff --git a/Editor/MCPServer.cs b/Editor/MCPServer.cs
index 9ea9bdd..ff30299 100644
--- a/Editor/MCPServer.cs
+++ b/Editor/MCPServer.cs
@@ -80,12 +80,9 @@ internal static void RefreshMainThreadCachedState()
             IsUpdatingCached = EditorApplication.isUpdating;
             IsPlayingCached = EditorApplication.isPlaying;
             IsPausedCached = EditorApplication.isPaused;
-            // isPlayingOrWillChangePlaymode stays true for the WHOLE play session,
-            // so using it directly reported a permanent "play_mode_transition":
-            // acceptsWriteCommands stayed false and Initialize threw "editor is
-            // busy" for as long as the game ran. A transition is in progress only
-            // while the two flags disagree (entering: will-change but not yet
-            // playing; exiting: still playing but no longer will-change).
+            // isPlayingOrWillChangePlaymode stays true for the whole play session,
+            // so using it directly would permanently block writes. A transition
+            // is active only while the two flags disagree, for both directions.
             IsPlayModeTransitionCached =
                 EditorApplication.isPlayingOrWillChangePlaymode != EditorApplication.isPlaying;
             UnityVersionCached = Application.unityVersion;
diff --git a/Editor/MCPServerMethods.Context.MissingReferences.cs b/Editor/MCPServerMethods.Context.MissingReferences.cs
new file mode 100644
index 0000000..35bad6e
--- /dev/null
+++ b/Editor/MCPServerMethods.Context.MissingReferences.cs
@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static JToken ShowUnresolvedMissingReferences(JToken p)
+        {
+            var missingReferences = new JArray();
+            var activeScene = SceneManager.GetActiveScene();
+            var sceneObjects = Resources.FindObjectsOfTypeAll<GameObject>()
+                .Where(go => IsSceneObject(go, activeScene));
+
+            using (UnityEngine.Pool.ListPool<Component>.Get(out var components))
+            {
+                foreach (var go in sceneObjects)
+                {
+                    var issues = FindMissingReferenceIssues(go, components);
+                    if (issues.Count > 0)
+                        missingReferences.Add(CreateMissingReferenceObject(go, issues));
+                }
+            }
+
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["missing_references"] = missingReferences
+            };
+        }
+
+        private static bool IsSceneObject(GameObject go, Scene activeScene)
+        {
+            return go.scene == activeScene &&
+                (go.hideFlags == HideFlags.None || go.hideFlags == HideFlags.NotEditable);
+        }
+
+        private static JArray FindMissingReferenceIssues(GameObject go, List<Component> components)
+        {
+            var issues = new JArray();
+            go.GetComponents(components);
+            foreach (var component in components)
+                AddComponentReferenceIssues(issues, component);
+            return issues;
+        }
+
+        private static void AddComponentReferenceIssues(JArray issues, Component component)
+        {
+            if (component == null)
+            {
+                issues.Add(new JObject { ["type"] = "MissingScript" });
+                return;
+            }
+
+            using (var serializedObject = new SerializedObject(component))
+            {
+                var property = serializedObject.GetIterator();
+                var enterChildren = true;
+                while (property.Next(enterChildren))
+                {
+                    enterChildren = true;
+                    AddPropertyReferenceIssue(issues, component, property);
+                }
+            }
+        }
+
+        private static void AddPropertyReferenceIssue(JArray issues, Component component, SerializedProperty property)
+        {
+            if (property.propertyType != SerializedPropertyType.ObjectReference ||
+                GetObjectReferenceId(property) == default || property.objectReferenceValue != null)
+                return;
+
+            issues.Add(new JObject
+            {
+                ["type"] = "MissingReference",
+                ["component"] = GetTypeName(component.GetType()),
+                ["field"] = property.propertyPath
+            });
+        }
+
+        private static JObject CreateMissingReferenceObject(GameObject go, JArray issues)
+        {
+            return new JObject
+            {
+                ["name"] = go.name,
+                ["instance_id"] = go.GetRawId(),
+                ["issues"] = issues
+            };
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.Context.MissingReferences.cs.meta b/Editor/MCPServerMethods.Context.MissingReferences.cs.meta
new file mode 100644
index 0000000..fe684fb
--- /dev/null
+++ b/Editor/MCPServerMethods.Context.MissingReferences.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1b0ecd9dccad427d9d3b79d77afe6885
diff --git a/Editor/MCPServerMethods.Context.Selection.cs b/Editor/MCPServerMethods.Context.Selection.cs
new file mode 100644
index 0000000..dec976b
--- /dev/null
+++ b/Editor/MCPServerMethods.Context.Selection.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static JToken GetSelectedObjectFullContext(JToken p)
+        {
+            var go = Selection.activeGameObject;
+            if (go == null) throw new Exception("No GameObject is currently selected.");
+
+            var result = new JObject { ["status"] = "Success" };
+            AddSelectedObjectDetails(result, go);
+            result["path"] = BuildTransformPath(go.transform);
+            AddPrefabDetails(result, go);
+            result["components"] = SerializeSelectedComponents(go);
+            AddHierarchyDetails(result, go);
+            return result;
+        }
+
+        private static void AddSelectedObjectDetails(JObject result, GameObject go)
+        {
+            result["name"] = go.name;
+            result["instance_id"] = go.GetRawId();
+            result["active"] = go.activeSelf;
+            result["tag"] = go.tag;
+            result["layer"] = LayerMask.LayerToName(go.layer);
+        }
+
+        private static string BuildTransformPath(Transform transform)
+        {
+            var pathParts = new Stack<string>();
+            for (var current = transform; current != null; current = current.parent)
+                pathParts.Push(current.name);
+            return string.Join("/", pathParts);
+        }
+
+        private static void AddPrefabDetails(JObject result, GameObject go)
+        {
+            result["is_prefab_instance"] = PrefabUtility.IsPartOfPrefabInstance(go);
+            result["prefab_asset_type"] = PrefabUtility.GetPrefabAssetType(go).ToString();
+            result["prefab_instance_status"] = PrefabUtility.GetPrefabInstanceStatus(go).ToString();
+        }
+
+        private static JArray SerializeSelectedComponents(GameObject go)
+        {
+            var components = new JArray();
+            foreach (var component in go.GetComponents<Component>())
+                components.Add(component == null ? CreateMissingScriptSnapshot() : SerializeComponentSnapshot(component, true));
+            return components;
+        }
+
+        private static JObject CreateMissingScriptSnapshot()
+        {
+            return new JObject { ["type"] = "MissingScript", ["status"] = "Broken" };
+        }
+
+        private static void AddHierarchyDetails(JObject result, GameObject go)
+        {
+            if (go.transform.parent != null)
+                result["parent"] = CreateObjectReference(go.transform.parent.gameObject);
+
+            var children = new JArray();
+            foreach (Transform child in go.transform)
+                children.Add(CreateObjectReference(child.gameObject));
+            if (children.Count > 0) result["children"] = children;
+        }
+
+        private static JObject CreateObjectReference(GameObject go)
+        {
+            return new JObject
+            {
+                ["name"] = go.name,
+                ["instance_id"] = go.GetRawId()
+            };
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.Context.Selection.cs.meta b/Editor/MCPServerMethods.Context.Selection.cs.meta
new file mode 100644
index 0000000..616e905
--- /dev/null
+++ b/Editor/MCPServerMethods.Context.Selection.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f9a8791be14049c9b73f23e628c3d219
diff --git a/Editor/MCPServerMethods.Context.cs b/Editor/MCPServerMethods.Context.cs
index 6c30550..ed5df3c 100644
--- a/Editor/MCPServerMethods.Context.cs
+++ b/Editor/MCPServerMethods.Context.cs
@@ -1,10 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityEditor;
-using UnityEngine;
-using Newtonsoft.Json.Linq;
-
 namespace UnityMCP.Editor
 {
     public static partial class MCPServerMethods
@@ -14,145 +7,5 @@ private static void RegisterContextMethods()
             _methods["get_selected_object_full_context"] = GetSelectedObjectFullContext;
             _methods["show_unresolved_missing_references"] = ShowUnresolvedMissingReferences;
         }
-
-        private static JToken GetSelectedObjectFullContext(JToken p)
-        {
-            var go = Selection.activeGameObject;
-            if (go == null) throw new Exception("No GameObject is currently selected.");
-
-            JObject result = new JObject
-            {
-                ["status"] = "Success"
-            };
-
-            // Basic Details
-            result["name"] = go.name;
-            result["instance_id"] = go.GetRawId();
-            result["active"] = go.activeSelf;
-            result["tag"] = go.tag;
-            result["layer"] = LayerMask.LayerToName(go.layer);
-
-            // Path
-            var pathParts = new Stack<string>();
-            pathParts.Push(go.name);
-            Transform t = go.transform.parent;
-            while (t != null)
-            {
-                pathParts.Push(t.name);
-                t = t.parent;
-            }
-            result["path"] = string.Join("/", pathParts);
-
-            // Prefab Status
-            result["is_prefab_instance"] = PrefabUtility.IsPartOfPrefabInstance(go);
-            result["prefab_asset_type"] = PrefabUtility.GetPrefabAssetType(go).ToString();
-            result["prefab_instance_status"] = PrefabUtility.GetPrefabInstanceStatus(go).ToString();
-
-            // Components (Full deep dump)
-            JArray components = new JArray();
-            var comps = go.GetComponents<Component>();
-            foreach (var comp in comps)
-            {
-                if (comp == null)
-                {
-                    components.Add(new JObject { ["type"] = "MissingScript", ["status"] = "Broken" });
-                    continue;
-                }
-                
-                // Using the Snapshot serializer
-                components.Add(SerializeComponentSnapshot(comp, true));
-            }
-            result["components"] = components;
-
-            // Hierarchy relationships
-            if (go.transform.parent != null)
-            {
-                result["parent"] = new JObject
-                {
-                    ["name"] = go.transform.parent.name,
-                    ["instance_id"] = go.transform.parent.gameObject.GetRawId()
-                };
-            }
-
-            JArray children = new JArray();
-            foreach (Transform child in go.transform)
-            {
-                children.Add(new JObject
-                {
-                    ["name"] = child.name,
-                    ["instance_id"] = child.gameObject.GetRawId()
-                });
-            }
-            if (children.Count > 0) result["children"] = children;
-
-            return result;
-        }
-
-        private static JToken ShowUnresolvedMissingReferences(JToken p)
-        {
-            var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
-            var allGOs = Resources.FindObjectsOfTypeAll<GameObject>()
-                .Where(go => go.scene == activeScene && (go.hideFlags == HideFlags.None || go.hideFlags == HideFlags.NotEditable));
-
-            JArray missingRefs = new JArray();
-
-            using (UnityEngine.Pool.ListPool<Component>.Get(out var components))
-            {
-                foreach (var go in allGOs)
-                {
-                    go.GetComponents(components);
-                    JArray goIssues = new JArray();
-
-                    foreach (var comp in components)
-                    {
-                        if (comp == null)
-                        {
-                            goIssues.Add(new JObject { ["type"] = "MissingScript" });
-                            continue;
-                        }
-
-                        using (var so = new SerializedObject(comp))
-                        {
-                            var prop = so.GetIterator();
-                            bool enterChildren = true;
-                            while (prop.Next(enterChildren))
-                            {
-                                enterChildren = true;
-                                if (prop.propertyType == SerializedPropertyType.ObjectReference)
-                                {
-                                    // If instance ID is non-zero, it means a reference WAS here.
-                                    // If the objectReferenceValue is null, the target is missing/destroyed.
-                                    if (GetObjectReferenceId(prop) != default && prop.objectReferenceValue == null)
-                                    {
-                                        goIssues.Add(new JObject 
-                                        { 
-                                            ["type"] = "MissingReference",
-                                            ["component"] = GetTypeName(comp.GetType()),
-                                            ["field"] = prop.propertyPath
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    if (goIssues.Count > 0)
-                    {
-                        missingRefs.Add(new JObject
-                        {
-                            ["name"] = go.name,
-                            ["instance_id"] = go.GetRawId(),
-                            ["issues"] = goIssues
-                        });
-                    }
-                }
-            }
-
-            return new JObject 
-            { 
-                ["status"] = "Success",
-                ["missing_references"] = missingRefs 
-            };
-        }
     }
 }
diff --git a/Editor/MCPServerMethods.Core.cs b/Editor/MCPServerMethods.Core.cs
index 783e97c..1baa945 100644
--- a/Editor/MCPServerMethods.Core.cs
+++ b/Editor/MCPServerMethods.Core.cs
@@ -20,6 +20,16 @@ public static partial class MCPServerMethods
         private const int MaxBatchExecuteRequests = 50;
         private static int _batchExecuteDepth;
 
+        private sealed class PrimitiveCreationOptions
+        {
+            internal string Name;
+            internal Transform Parent;
+            internal Material Material;
+            internal Vector3? Position;
+            internal Vector3? Rotation;
+            internal Vector3? Scale;
+        }
+
         private static void RegisterCoreMethods()
         {
             _methods["initialize"] = Initialize;
@@ -74,51 +84,14 @@ private static JToken BatchExecute(JToken p)
 
         private static JToken CreatePrimitive(JToken p)
         {
-            if (p == null || p["primitive_type"] == null) throw new Exception("primitive_type is required");
-            if (!Enum.TryParse(typeof(PrimitiveType), p["primitive_type"].ToString(), true, out var type)) throw new Exception("Invalid primitive");
-
-            string name = p["name"]?.ToString();
-            Transform parentTransform = null;
-            if (p["parent_id"] != null)
-            {
-                var parent = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p, "parent_id")) as GameObject;
-                if (parent == null) throw new Exception("parent_id does not resolve to a GameObject");
-                parentTransform = parent.transform;
-            }
-
-            Vector3? position = p["position"] != null ? ParseVector3(p["position"]) : null;
-            JToken rotationToken = p["rotation"] ?? p["eulerAngles"];
-            Vector3? rotation = rotationToken != null ? ParseVector3(rotationToken) : null;
-            JToken scaleToken = p["scale"] ?? p["localScale"];
-            Vector3? scale = scaleToken != null ? ParseVector3(scaleToken) : null;
-
-            Material material = null;
-            string materialPath = p["material_path"]?.ToString();
-            if (!string.IsNullOrWhiteSpace(materialPath))
-            {
-                materialPath = ValidateAssetPath(materialPath);
-                material = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
-                if (material == null) throw new Exception($"Material not found at {materialPath}");
-            }
+            PrimitiveType type = ParsePrimitiveType(p);
+            var options = ReadPrimitiveOptions(p);
 
             GameObject go = null;
             try
             {
                 go = GameObject.CreatePrimitive((PrimitiveType)type);
-                Undo.RegisterCreatedObjectUndo(go, "Create Primitive");
-
-                if (!string.IsNullOrWhiteSpace(name)) go.name = name;
-
-                if (parentTransform != null) go.transform.SetParent(parentTransform, false);
-
-                if (position.HasValue) go.transform.position = position.Value;
-                if (rotation.HasValue) go.transform.eulerAngles = rotation.Value;
-                if (scale.HasValue) go.transform.localScale = scale.Value;
-
-                var renderer = go.GetComponent<Renderer>();
-                if (renderer != null && material != null) renderer.sharedMaterial = material;
-
-                Selection.activeGameObject = go;
+                ConfigurePrimitive(go, options);
                 return new JObject { ["status"] = "Success", ["data"] = SerializeGameObject(go) };
             }
             catch
@@ -128,6 +101,69 @@ private static JToken CreatePrimitive(JToken p)
             }
         }
 
+        private static PrimitiveCreationOptions ReadPrimitiveOptions(JToken p)
+        {
+            return new PrimitiveCreationOptions
+            {
+                Name = p["name"]?.ToString(),
+                Parent = ResolvePrimitiveParent(p),
+                Material = LoadPrimitiveMaterial(p),
+                Position = ParseOptionalVector3(p["position"]),
+                Rotation = ParseOptionalVector3(p["rotation"] ?? p["eulerAngles"]),
+                Scale = ParseOptionalVector3(p["scale"] ?? p["localScale"])
+            };
+        }
+
+        private static Vector3? ParseOptionalVector3(JToken token)
+        {
+            return token == null ? (Vector3?)null : ParseVector3(token);
+        }
+
+        private static PrimitiveType ParsePrimitiveType(JToken p)
+        {
+            if (p == null || p["primitive_type"] == null) throw new Exception("primitive_type is required");
+            if (!Enum.TryParse(typeof(PrimitiveType), p["primitive_type"].ToString(), true, out var type))
+                throw new Exception("Invalid primitive");
+            return (PrimitiveType)type;
+        }
+
+        private static Transform ResolvePrimitiveParent(JToken p)
+        {
+            if (p["parent_id"] == null) return null;
+            var parent = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p, "parent_id")) as GameObject;
+            if (parent == null) throw new Exception("parent_id does not resolve to a GameObject");
+            return parent.transform;
+        }
+
+        private static Material LoadPrimitiveMaterial(JToken p)
+        {
+            string materialPath = p["material_path"]?.ToString();
+            if (string.IsNullOrWhiteSpace(materialPath)) return null;
+            materialPath = ValidateAssetPath(materialPath);
+            var material = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
+            if (material == null) throw new Exception($"Material not found at {materialPath}");
+            return material;
+        }
+
+        private static void ConfigurePrimitive(GameObject go, PrimitiveCreationOptions options)
+        {
+            Undo.RegisterCreatedObjectUndo(go, "Create Primitive");
+            if (!string.IsNullOrWhiteSpace(options.Name)) go.name = options.Name;
+            if (options.Parent != null) go.transform.SetParent(options.Parent, false);
+
+            ApplyPrimitiveTransform(go, options);
+            var renderer = go.GetComponent<Renderer>();
+            if (renderer != null && options.Material != null) renderer.sharedMaterial = options.Material;
+            Selection.activeGameObject = go;
+        }
+
+        private static void ApplyPrimitiveTransform(GameObject go, PrimitiveCreationOptions options)
+        {
+            if (options.Position.HasValue) go.transform.position = options.Position.Value;
+            if (options.Rotation.HasValue) go.transform.eulerAngles = options.Rotation.Value;
+            if (options.Scale.HasValue) go.transform.localScale = options.Scale.Value;
+        }
+
         private static JToken AttachScript(JToken p)
         {
             RequireScriptWriteConfirmation(p);
diff --git a/Editor/MCPServerMethods.Delta.Events.cs b/Editor/MCPServerMethods.Delta.Events.cs
new file mode 100644
index 0000000..03119d9
--- /dev/null
+++ b/Editor/MCPServerMethods.Delta.Events.cs
@@ -0,0 +1,135 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static SceneChangeEvent CreateSceneChangeEvent(ref ObjectChangeEventStream stream, int index, string timestamp)
+        {
+            switch (stream.GetEventType(index))
+            {
+                case ObjectChangeKind.CreateGameObjectHierarchy:
+                    return CreateGameObjectEvent(ref stream, index, timestamp);
+                case ObjectChangeKind.DestroyGameObjectHierarchy:
+                    return CreateDestroyEvent(ref stream, index, timestamp);
+                case ObjectChangeKind.ChangeGameObjectParent:
+                    return CreateParentEvent(ref stream, index, timestamp);
+                case ObjectChangeKind.ChangeGameObjectOrComponentProperties:
+                    return CreatePropertyChangeEvent(ref stream, index, timestamp);
+                case ObjectChangeKind.ChangeChildrenOrder:
+                    return CreateChildrenOrderEvent(ref stream, index, timestamp);
+                default:
+                    return null;
+            }
+        }
+
+        private static SceneChangeEvent CreateGameObjectEvent(ref ObjectChangeEventStream stream, int index, string timestamp)
+        {
+            stream.GetCreateGameObjectHierarchyEvent(index, out var change);
+#if UNITY_6000_4_OR_NEWER
+            var gameObject = EditorUtility.EntityIdToObject(change.entityId) as GameObject;
+            int instanceId = ConvertEntityIdToLegacyInt(change.entityId);
+#else
+            var gameObject = IdToObject(ConvertLegacyIntToEntityId(change.instanceId)) as GameObject;
+            int instanceId = change.instanceId;
+#endif
+            return new SceneChangeEvent
+            {
+                id = ++_deltaCounter,
+                type = "CreateGameObject",
+                instanceId = instanceId,
+                name = gameObject != null ? gameObject.name : "Unknown",
+                timestamp = timestamp
+            };
+        }
+
+        private static SceneChangeEvent CreateDestroyEvent(ref ObjectChangeEventStream stream, int index, string timestamp)
+        {
+            stream.GetDestroyGameObjectHierarchyEvent(index, out var change);
+#if UNITY_6000_4_OR_NEWER
+            int instanceId = ConvertEntityIdToLegacyInt(change.entityId);
+#else
+            int instanceId = change.instanceId;
+#endif
+            return new SceneChangeEvent
+            {
+                id = ++_deltaCounter,
+                type = "DestroyGameObject",
+                instanceId = instanceId,
+                name = "DestroyedObject",
+                timestamp = timestamp
+            };
+        }
+
+        private static SceneChangeEvent CreateParentEvent(ref ObjectChangeEventStream stream, int index, string timestamp)
+        {
+            stream.GetChangeGameObjectParentEvent(index, out var change);
+#if UNITY_6000_4_OR_NEWER
+            var gameObject = EditorUtility.EntityIdToObject(change.entityId) as GameObject;
+            int instanceId = ConvertEntityIdToLegacyInt(change.entityId);
+            int parentId = ConvertEntityIdToLegacyInt(change.newParentEntityId);
+#else
+            var gameObject = IdToObject(ConvertLegacyIntToEntityId(change.instanceId)) as GameObject;
+            int instanceId = change.instanceId;
+            int parentId = change.newParentInstanceId;
+#endif
+            return new SceneChangeEvent
+            {
+                id = ++_deltaCounter,
+                type = "ReparentGameObject",
+                instanceId = instanceId,
+                parentId = parentId,
+                name = gameObject != null ? gameObject.name : "Unknown",
+                timestamp = timestamp
+            };
+        }
+
+        private static SceneChangeEvent CreatePropertyChangeEvent(ref ObjectChangeEventStream stream, int index, string timestamp)
+        {
+            stream.GetChangeGameObjectOrComponentPropertiesEvent(index, out var change);
+#if UNITY_6000_4_OR_NEWER
+            var changedObject = EditorUtility.EntityIdToObject(change.entityId);
+            int instanceId = ConvertEntityIdToLegacyInt(change.entityId);
+#else
+            var changedObject = IdToObject(ConvertLegacyIntToEntityId(change.instanceId));
+            int instanceId = change.instanceId;
+#endif
+            return new SceneChangeEvent
+            {
+                id = ++_deltaCounter,
+                type = "PropertiesChanged",
+                instanceId = instanceId,
+                name = changedObject != null ? changedObject.name : "Unknown",
+                timestamp = timestamp
+            };
+        }
+
+        private static SceneChangeEvent CreateChildrenOrderEvent(ref ObjectChangeEventStream stream, int index, string timestamp)
+        {
+            stream.GetChangeChildrenOrderEvent(index, out var change);
+#if UNITY_6000_4_OR_NEWER
+            var parentObject = EditorUtility.EntityIdToObject(change.entityId);
+            int instanceId = ConvertEntityIdToLegacyInt(change.entityId);
+#else
+            var parentObject = IdToObject(ConvertLegacyIntToEntityId(change.instanceId));
+            int instanceId = change.instanceId;
+#endif
+            return new SceneChangeEvent
+            {
+                id = ++_deltaCounter,
+                type = "ChildrenOrderChanged",
+                instanceId = instanceId,
+                name = parentObject != null ? parentObject.name : "Unknown",
+                timestamp = timestamp
+            };
+        }
+
+        private static void TrimDeltaBuffer()
+        {
+            if (_deltaBuffer.Count > MAX_DELTA_BUFFER)
+                _deltaBuffer.RemoveRange(0, _deltaBuffer.Count - MAX_DELTA_BUFFER);
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.Delta.Events.cs.meta b/Editor/MCPServerMethods.Delta.Events.cs.meta
new file mode 100644
index 0000000..8ed25c3
--- /dev/null
+++ b/Editor/MCPServerMethods.Delta.Events.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5b28c5a1d1b04ae0a16b1f2e6f80c3d7
diff --git a/Editor/MCPServerMethods.Delta.cs b/Editor/MCPServerMethods.Delta.cs
index e12d7e0..64b49ad 100644
--- a/Editor/MCPServerMethods.Delta.cs
+++ b/Editor/MCPServerMethods.Delta.cs
@@ -83,119 +83,11 @@ private static void OnChangesPublished(ref ObjectChangeEventStream stream)
             {
                 for (int i = 0; i < stream.length; i++)
                 {
-                    var eventType = stream.GetEventType(i);
-                    SceneChangeEvent evt = null;
-
-                    switch (eventType)
-                    {
-                        case ObjectChangeKind.CreateGameObjectHierarchy:
-                            stream.GetCreateGameObjectHierarchyEvent(i, out var createEvt);
-#if UNITY_6000_4_OR_NEWER
-                            var go = EditorUtility.EntityIdToObject(createEvt.entityId) as GameObject;
-                            int createdId = ConvertEntityIdToLegacyInt(createEvt.entityId);
-#else
-                            var go = IdToObject(ConvertLegacyIntToEntityId(createEvt.instanceId)) as GameObject;
-                            int createdId = createEvt.instanceId;
-#endif
-                            evt = new SceneChangeEvent
-                            {
-                                id = ++_deltaCounter,
-                                type = "CreateGameObject",
-                                instanceId = createdId,
-                                name = go != null ? go.name : "Unknown",
-                                timestamp = timestamp
-                            };
-                            break;
-
-                        case ObjectChangeKind.DestroyGameObjectHierarchy:
-                            stream.GetDestroyGameObjectHierarchyEvent(i, out var destroyEvt);
-#if UNITY_6000_4_OR_NEWER
-                            int destroyedId = ConvertEntityIdToLegacyInt(destroyEvt.entityId);
-#else
-                            int destroyedId = destroyEvt.instanceId;
-#endif
-                            evt = new SceneChangeEvent
-                            {
-                                id = ++_deltaCounter,
-                                type = "DestroyGameObject",
-                                instanceId = destroyedId,
-                                name = "DestroyedObject", // Name not available in event args
-                                timestamp = timestamp
-                            };
-                            break;
-
-                        case ObjectChangeKind.ChangeGameObjectParent:
-                            stream.GetChangeGameObjectParentEvent(i, out var parentEvt);
-#if UNITY_6000_4_OR_NEWER
-                            var movedGo = EditorUtility.EntityIdToObject(parentEvt.entityId) as GameObject;
-                            int movedId = ConvertEntityIdToLegacyInt(parentEvt.entityId);
-                            int newParentId = ConvertEntityIdToLegacyInt(parentEvt.newParentEntityId);
-#else
-                            var movedGo = IdToObject(ConvertLegacyIntToEntityId(parentEvt.instanceId)) as GameObject;
-                            int movedId = parentEvt.instanceId;
-                            int newParentId = parentEvt.newParentInstanceId;
-#endif
-                            evt = new SceneChangeEvent
-                            {
-                                id = ++_deltaCounter,
-                                type = "ReparentGameObject",
-                                instanceId = movedId,
-                                parentId = newParentId,
-                                name = movedGo != null ? movedGo.name : "Unknown",
-                                timestamp = timestamp
-                            };
-                            break;
-
-                        case ObjectChangeKind.ChangeGameObjectOrComponentProperties:
-                            stream.GetChangeGameObjectOrComponentPropertiesEvent(i, out var changePropEvt);
-#if UNITY_6000_4_OR_NEWER
-                            var changedObj = EditorUtility.EntityIdToObject(changePropEvt.entityId);
-                            int changedId = ConvertEntityIdToLegacyInt(changePropEvt.entityId);
-#else
-                            var changedObj = IdToObject(ConvertLegacyIntToEntityId(changePropEvt.instanceId));
-                            int changedId = changePropEvt.instanceId;
-#endif
-                            evt = new SceneChangeEvent
-                            {
-                                id = ++_deltaCounter,
-                                type = "PropertiesChanged",
-                                instanceId = changedId,
-                                name = changedObj != null ? changedObj.name : "Unknown",
-                                timestamp = timestamp
-                            };
-                            break;
-
-                        case ObjectChangeKind.ChangeChildrenOrder:
-                            stream.GetChangeChildrenOrderEvent(i, out var orderEvt);
-#if UNITY_6000_4_OR_NEWER
-                            var parentObj = EditorUtility.EntityIdToObject(orderEvt.entityId);
-                            int orderId = ConvertEntityIdToLegacyInt(orderEvt.entityId);
-#else
-                            var parentObj = IdToObject(ConvertLegacyIntToEntityId(orderEvt.instanceId));
-                            int orderId = orderEvt.instanceId;
-#endif
-                            evt = new SceneChangeEvent
-                            {
-                                id = ++_deltaCounter,
-                                type = "ChildrenOrderChanged",
-                                instanceId = orderId,
-                                name = parentObj != null ? parentObj.name : "Unknown",
-                                timestamp = timestamp
-                            };
-                            break;
-                    }
-
+                    SceneChangeEvent evt = CreateSceneChangeEvent(ref stream, i, timestamp);
                     if (evt != null)
-                    {
                         _deltaBuffer.Add(evt);
-                    }
-                }
-
-                // Prune buffer
-                if (_deltaBuffer.Count > MAX_DELTA_BUFFER)
-                {
-                    _deltaBuffer.RemoveRange(0, _deltaBuffer.Count - MAX_DELTA_BUFFER);
                 }
+                TrimDeltaBuffer();
             }
         }
     }
diff --git a/Editor/MCPServerMethods.Editor.cs b/Editor/MCPServerMethods.Editor.cs
index 744e77f..9d6e9e7 100644
--- a/Editor/MCPServerMethods.Editor.cs
+++ b/Editor/MCPServerMethods.Editor.cs
@@ -45,41 +45,7 @@ private static JToken RunTests(JToken p)
             {
                 string filter = p?["filter"]?.ToString();
                 string modeStr = p?["mode"]?.ToString() ?? "EditMode";
-                
-                // Reflection to avoid hard dependency on UnityEditor.TestRunner
-                var apiType = AppDomain.CurrentDomain.GetAssemblies()
-                    .SelectMany(a => a.GetTypes())
-                    .FirstOrDefault(t => t.FullName == "UnityEditor.TestTools.TestRunner.Api.TestRunnerApi");
-
-                if (apiType == null) throw new Exception("UnityEditor.TestRunner.Api not found. Is Test Framework package installed?");
-
-                var settingsType = AppDomain.CurrentDomain.GetAssemblies()
-                    .SelectMany(a => a.GetTypes())
-                    .FirstOrDefault(t => t.FullName == "UnityEditor.TestTools.TestRunner.Api.ExecutionSettings");
-                
-                var filterType = AppDomain.CurrentDomain.GetAssemblies()
-                    .SelectMany(a => a.GetTypes())
-                    .FirstOrDefault(t => t.FullName == "UnityEditor.TestTools.TestRunner.Api.Filter");
-
-                var modeType = AppDomain.CurrentDomain.GetAssemblies()
-                    .SelectMany(a => a.GetTypes())
-                    .FirstOrDefault(t => t.FullName == "UnityEditor.TestTools.TestRunner.Api.TestMode");
-
-                var api = ScriptableObject.CreateInstance(apiType);
-                var filterObj = Activator.CreateInstance(filterType);
-                
-                // Set filter fields
-                var testNamesField = filterType.GetField("testNames");
-                if (!string.IsNullOrEmpty(filter)) testNamesField.SetValue(filterObj, new[] { filter });
-
-                var testModeField = filterType.GetField("testMode");
-                object modeValue = Enum.Parse(modeType, modeStr, true);
-                testModeField.SetValue(filterObj, modeValue);
-
-                var settings = Activator.CreateInstance(settingsType, new[] { filterObj });
-                
-                var executeMethod = apiType.GetMethod("Execute");
-                executeMethod.Invoke(api, new[] { settings });
+                SubmitTests(filter, modeStr);
 
                 return new JObject
                 {
@@ -97,6 +63,31 @@ private static JToken RunTests(JToken p)
             }
         }
 
+        private static void SubmitTests(string filter, string modeStr)
+        {
+            var apiType = FindTestRunnerType("TestRunnerApi");
+            if (apiType == null) throw new Exception("UnityEditor.TestRunner.Api not found. Is Test Framework package installed?");
+
+            var settingsType = FindTestRunnerType("ExecutionSettings");
+            var filterType = FindTestRunnerType("Filter");
+            var modeType = FindTestRunnerType("TestMode");
+            var api = ScriptableObject.CreateInstance(apiType);
+            var filterObject = Activator.CreateInstance(filterType);
+            var testNamesField = filterType.GetField("testNames");
+            if (!string.IsNullOrEmpty(filter)) testNamesField.SetValue(filterObject, new[] { filter });
+            filterType.GetField("testMode").SetValue(filterObject, Enum.Parse(modeType, modeStr, true));
+            var settings = Activator.CreateInstance(settingsType, new[] { filterObject });
+            apiType.GetMethod("Execute").Invoke(api, new[] { settings });
+        }
+
+        private static Type FindTestRunnerType(string typeName)
+        {
+            string fullName = "UnityEditor.TestTools.TestRunner.Api." + typeName;
+            return AppDomain.CurrentDomain.GetAssemblies()
+                .SelectMany(assembly => assembly.GetTypes())
+                .FirstOrDefault(type => type.FullName == fullName);
+        }
+
         private static JToken OpenPrefabStage(JToken p)
         {
             if (p == null || p["path"] == null) throw new System.Exception("path is required");
diff --git a/Editor/MCPServerMethods.Hierarchy.Create.cs b/Editor/MCPServerMethods.Hierarchy.Create.cs
new file mode 100644
index 0000000..421255d
--- /dev/null
+++ b/Editor/MCPServerMethods.Hierarchy.Create.cs
@@ -0,0 +1,101 @@
+using System;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        /// <summary>Creates a full hierarchy of objects and components in one call.</summary>
+        private static JToken CreateHierarchy(JToken p)
+        {
+            var parent = p["parent_id"] != null ? MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p, "parent_id")) as GameObject : null;
+            var tree = p["tree"];
+            if (tree == null) throw new System.Exception("tree required");
+
+            GameObject root = CreateHierarchyRecursive(tree, parent?.transform);
+            return new JObject { ["status"] = "Success", ["data"] = SerializeGameObject(root) };
+        }
+
+        private static GameObject CreateHierarchyRecursive(JToken node, Transform parent)
+        {
+            string name = node["name"]?.ToString() ?? "New GameObject";
+            GameObject go = new GameObject(name);
+            Undo.RegisterCreatedObjectUndo(go, "Create Hierarchy");
+            if (parent != null) go.transform.SetParent(parent, false);
+
+            AddComponentsToHierarchyObject(go, node["components"] as JArray);
+            ApplyPropertiesToHierarchyObject(go, node["properties"] as JObject);
+            AddChildrenToHierarchyObject(go, node["children"] as JArray);
+
+            return go;
+        }
+
+        private static void AddComponentsToHierarchyObject(GameObject go, JArray components)
+        {
+            if (components == null) return;
+            foreach (var c in components)
+            {
+                Type type = FindComponentType(c.ToString());
+                if (type != null) Undo.AddComponent(go, type);
+            }
+        }
+
+        private static void ApplyPropertiesToHierarchyObject(GameObject go, JObject properties)
+        {
+            if (properties == null) return;
+
+            var componentsList = UnityEngine.Pool.ListPool<Component>.Get();
+            try
+            {
+                go.GetComponents(componentsList);
+
+                foreach (var compPair in properties)
+                {
+                    Component comp = FindMatchingComponent(componentsList, compPair.Key);
+                    if (comp == null) continue;
+
+                    var data = compPair.Value as JObject;
+                    if (data == null) continue;
+
+                    SerializedObject so = new SerializedObject(comp);
+                    foreach (var propPair in data)
+                    {
+                        SerializedProperty sp = so.FindProperty(propPair.Key);
+                        if (sp != null) ApplyValueToProperty(sp, propPair.Value);
+                    }
+                    so.ApplyModifiedProperties();
+                }
+            }
+            finally
+            {
+                UnityEngine.Pool.ListPool<Component>.Release(componentsList);
+            }
+        }
+
+        private static Component FindMatchingComponent(System.Collections.Generic.List<Component> components, string targetName)
+        {
+            foreach (var c in components)
+            {
+                if (c == null) continue;
+                var type = c.GetType();
+                string typeName = GetTypeName(type);
+                if (typeName == targetName || type.FullName == targetName)
+                {
+                    return c;
+                }
+            }
+            return null;
+        }
+
+        private static void AddChildrenToHierarchyObject(GameObject go, JArray children)
+        {
+            if (children == null) return;
+            foreach (var childNode in children)
+            {
+                CreateHierarchyRecursive(childNode, go.transform);
+            }
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.Hierarchy.Create.cs.meta b/Editor/MCPServerMethods.Hierarchy.Create.cs.meta
new file mode 100644
index 0000000..d8ae419
--- /dev/null
+++ b/Editor/MCPServerMethods.Hierarchy.Create.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9ddd5d19088342ad845758ff56afa4f5
diff --git a/Editor/MCPServerMethods.Hierarchy.cs b/Editor/MCPServerMethods.Hierarchy.cs
index 8aa0195..7bc2908 100644
--- a/Editor/MCPServerMethods.Hierarchy.cs
+++ b/Editor/MCPServerMethods.Hierarchy.cs
@@ -33,95 +33,6 @@ private static void RegisterHierarchyMethods()
             _methods["write_files_batch"] = WriteFilesBatch;
         }
 
-        /// <summary>Creates a full hierarchy of objects and components in one call.</summary>
-        private static JToken CreateHierarchy(JToken p)
-        {
-            var parent = p["parent_id"] != null ? MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p, "parent_id")) as GameObject : null;
-            var tree = p["tree"];
-            if (tree == null) throw new System.Exception("tree required");
-
-            GameObject root = CreateHierarchyRecursive(tree, parent?.transform);
-            return new JObject { ["status"] = "Success", ["data"] = SerializeGameObject(root) };
-        }
-
-        private static GameObject CreateHierarchyRecursive(JToken node, Transform parent)
-        {
-            string name = node["name"]?.ToString() ?? "New GameObject";
-            GameObject go = new GameObject(name);
-            Undo.RegisterCreatedObjectUndo(go, "Create Hierarchy");
-            if (parent != null) go.transform.SetParent(parent, false);
-
-            AddComponentsToHierarchyObject(go, node["components"] as JArray);
-            ApplyPropertiesToHierarchyObject(go, node["properties"] as JObject);
-            AddChildrenToHierarchyObject(go, node["children"] as JArray);
-
-            return go;
-        }
-
-        private static void AddComponentsToHierarchyObject(GameObject go, JArray components)
-        {
-            if (components == null) return;
-            foreach (var c in components)
-            {
-                Type type = FindComponentType(c.ToString());
-                if (type != null) Undo.AddComponent(go, type);
-            }
-        }
-
-        private static void ApplyPropertiesToHierarchyObject(GameObject go, JObject properties)
-        {
-            if (properties == null) return;
-
-            var componentsList = UnityEngine.Pool.ListPool<Component>.Get();
-            try
-            {
-                go.GetComponents(componentsList);
-
-                foreach (var compPair in properties)
-                {
-                    Component comp = null;
-                    foreach (var c in componentsList)
-                    {
-                        if (c == null) continue;
-                        var type = c.GetType();
-                        string typeName = GetTypeName(type);
-                        if (typeName == compPair.Key || type.FullName == compPair.Key)
-                        {
-                            comp = c;
-                            break;
-                        }
-                    }
-
-                    if (comp == null) continue;
-
-                    SerializedObject so = new SerializedObject(comp);
-                    var data = compPair.Value as JObject;
-                    if (data != null)
-                    {
-                        foreach (var propPair in data)
-                        {
-                            SerializedProperty prop = so.FindProperty(propPair.Key);
-                            if (prop != null) ApplyValueToProperty(prop, propPair.Value);
-                        }
-                    }
-                    so.ApplyModifiedProperties();
-                }
-            }
-            finally
-            {
-                UnityEngine.Pool.ListPool<Component>.Release(componentsList);
-            }
-        }
-
-        private static void AddChildrenToHierarchyObject(GameObject go, JArray children)
-        {
-            if (children == null) return;
-            foreach (var child in children)
-            {
-                CreateHierarchyRecursive(child, go.transform);
-            }
-        }
-
         /// <summary>Returns all direct children of a GameObject.</summary>
         private static JToken GetChildren(JToken p)
         {
@@ -230,13 +141,11 @@ private static JToken WriteFile(JToken p)
             EnsureParentDirectory(fullPath);
             System.IO.File.WriteAllText(fullPath, p["content"].ToString());
 
-            // Convert to relative path for AssetDatabase
             string root = System.IO.Path.GetFullPath(".");
             string relativePath = fullPath.Substring(root.Length).TrimStart(System.IO.Path.DirectorySeparatorChar, System.IO.Path.AltDirectorySeparatorChar).Replace("\\", "/");
 
             if (!isScript)
             {
-                // Non-scripts don't trigger domain reload, safe to run synchronously
                 AssetDatabase.ImportAsset(relativePath);
             }
             else
@@ -324,17 +233,12 @@ private static void TriggerSafeAssetRefresh()
 
             _scriptRefreshBusyUntilUtc = DateTime.UtcNow.AddSeconds(8);
 
-            // Scripts trigger domain reload which blocks the HTTP response.
-            // Unity strictly aborts Domain Reloads if the Editor window is in the background 
-            // to protect external IDE development. We use LaunchServices (open -a) to explicitly
-            // foreground the Editor, and wait for true OS focus before triggering the Refresh.
-            
             #if UNITY_EDITOR_OSX
             AppNapBypass.ScheduleActivation();
             #endif
 
             double startTime = EditorApplication.timeSinceStartup;
-            double timeoutSeconds = 15.0; // Fail-safe fallback timeout
+            double timeoutSeconds = 15.0;
 
             _pendingRefreshCallback = () => {
                 var cb = _pendingRefreshCallback;
@@ -348,8 +252,6 @@ private static void TriggerSafeAssetRefresh()
                     return;
                 }
                 
-                // Trigger refresh immediately. With App Nap bypassed, this is reliable 
-                // even if the focus-switch (open -a) is still in flight.
                 AssetDatabase.Refresh();
             };
             
diff --git a/Editor/MCPServerMethods.HighValue.Screenshots.cs b/Editor/MCPServerMethods.HighValue.Screenshots.cs
new file mode 100644
index 0000000..ceb7a52
--- /dev/null
+++ b/Editor/MCPServerMethods.HighValue.Screenshots.cs
@@ -0,0 +1,117 @@
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static JToken CaptureGameViewScreenshot(JToken p)
+        {
+            var gameView = Resources.FindObjectsOfTypeAll<EditorWindow>()
+                .FirstOrDefault(window => window.GetType().Name == "GameView");
+            if (gameView == null) throw new Exception("Game View window not found or not open.");
+
+            gameView.Focus();
+            gameView.Repaint();
+            Rect position = gameView.position;
+            string tempPath = Path.Combine(Path.GetTempPath(), $"unity_gameview_{DateTime.Now.Ticks}.png");
+            NexusEditorLog.Log(NexusLogCategory.UiAutomation, $"[MCP_SCREENSHOT] Capturing GameView at {position} to {tempPath}");
+            CaptureGameViewImage(tempPath, position);
+            return ReadGameViewImage(tempPath);
+        }
+
+        private static void CaptureGameViewImage(string tempPath, Rect position)
+        {
+#if UNITY_EDITOR_OSX
+            var startInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "screencapture",
+                Arguments = $"-x -R{(int)position.x},{(int)position.y},{(int)position.width},{(int)position.height} \"{tempPath}\"",
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardError = true,
+                RedirectStandardOutput = true
+            };
+            using (var process = System.Diagnostics.Process.Start(startInfo))
+            {
+                process.WaitForExit();
+                string error = process.StandardError.ReadToEnd();
+                if (process.ExitCode != 0)
+                    NexusEditorLog.Error(NexusLogCategory.UiAutomation, $"[MCP_SCREENSHOT] screencapture failed with exit code {process.ExitCode}. Error: {error}");
+            }
+#else
+            ScreenCapture.CaptureScreenshot(tempPath);
+            for (int retries = 0; !File.Exists(tempPath) && retries < 20; retries++)
+                System.Threading.Thread.Sleep(100);
+#endif
+        }
+
+        private static JObject ReadGameViewImage(string tempPath)
+        {
+            if (!File.Exists(tempPath)) throw new Exception("Failed to capture Game View screenshot.");
+            byte[] bytes = File.ReadAllBytes(tempPath);
+            File.Delete(tempPath);
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["image_base64"] = Convert.ToBase64String(bytes),
+                ["format"] = "png"
+            };
+        }
+
+        private static JToken CaptureInspectorScreenshot(JToken p)
+        {
+#if !UNITY_EDITOR_OSX
+            throw new Exception("Inspector screenshot is currently only supported on macOS.");
+#else
+            return CaptureInspectorScreenshotOnMac(p);
+#endif
+        }
+
+#if UNITY_EDITOR_OSX
+        private static JObject CaptureInspectorScreenshotOnMac(JToken p)
+        {
+            SelectInspectorTarget(p);
+            var inspector = Resources.FindObjectsOfTypeAll<EditorWindow>()
+                .FirstOrDefault(window => window.titleContent.text == "Inspector");
+            if (inspector == null) throw new Exception("Inspector window not found or not open.");
+
+            inspector.Focus();
+            inspector.Repaint();
+            var layout = SerializeVisualElement(inspector.rootVisualElement, true);
+            string tempPath = Path.Combine(Path.GetTempPath(), $"unity_inspector_{DateTime.Now.Ticks}.png");
+            CaptureInspectorImage(tempPath, inspector.position);
+            if (!File.Exists(tempPath))
+                return new JObject { ["status"] = "PartialSuccess", ["message"] = "Screenshot failed (permissions?), but UI layout was captured.", ["ui_layout"] = layout };
+
+            byte[] bytes = File.ReadAllBytes(tempPath);
+            File.Delete(tempPath);
+            return new JObject { ["status"] = "Success", ["image_base64"] = Convert.ToBase64String(bytes), ["format"] = "png", ["ui_layout"] = layout };
+        }
+
+        private static void SelectInspectorTarget(JToken p)
+        {
+            if (p?["instance_id"] == null) return;
+            var target = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p));
+            if (target != null) Selection.activeObject = target;
+        }
+
+        private static void CaptureInspectorImage(string tempPath, Rect position)
+        {
+            var startInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "screencapture",
+                Arguments = $"-x -R{(int)position.x},{(int)position.y},{(int)position.width},{(int)position.height} \"{tempPath}\"",
+                UseShellExecute = false,
+                CreateNoWindow = true
+            };
+            using (var process = System.Diagnostics.Process.Start(startInfo))
+                process.WaitForExit();
+        }
+#endif
+    }
+}
diff --git a/Editor/MCPServerMethods.HighValue.Screenshots.cs.meta b/Editor/MCPServerMethods.HighValue.Screenshots.cs.meta
new file mode 100644
index 0000000..f9e8409
--- /dev/null
+++ b/Editor/MCPServerMethods.HighValue.Screenshots.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3cb99e6730b44c66a4bbf4b9b5b7b4d8
diff --git a/Editor/MCPServerMethods.HighValue.Semantic.cs b/Editor/MCPServerMethods.HighValue.Semantic.cs
new file mode 100644
index 0000000..7d3d032
--- /dev/null
+++ b/Editor/MCPServerMethods.HighValue.Semantic.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static JToken SemanticFind(JToken p)
+        {
+            string query = p?["query"]?.ToString();
+            if (string.IsNullOrEmpty(query)) throw new Exception("query parameter required");
+            var matches = FindSemanticMatches(query);
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["matches"] = new JArray(matches.OrderByDescending(match => (int)match["score"]).Take(20))
+            };
+        }
+
+        private static List<JObject> FindSemanticMatches(string query)
+        {
+            var matches = new List<JObject>();
+            var allGameObjects = Resources.FindObjectsOfTypeAll<GameObject>()
+                .Where(go => go.hideFlags == HideFlags.None || go.hideFlags == HideFlags.NotEditable);
+            using (UnityEngine.Pool.ListPool<Component>.Get(out var components))
+            {
+                foreach (var go in allGameObjects)
+                {
+                    var match = CreateSemanticMatch(go, query, components);
+                    if (match != null) matches.Add(match);
+                }
+            }
+            return matches;
+        }
+
+        private static JObject CreateSemanticMatch(GameObject go, string query, List<Component> components)
+        {
+            if (!go.scene.IsValid() || !go.scene.isLoaded) return null;
+            int score = go.name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0 ? 50 : 0;
+            var reasons = new List<string>();
+            if (score > 0) reasons.Add("Name match");
+
+            go.GetComponents(components);
+            foreach (var component in components)
+            {
+                if (component != null) AddComponentMatches(component, query, reasons, ref score);
+            }
+            return score == 0 ? null : new JObject
+            {
+                ["name"] = go.name,
+                ["instance_id"] = go.GetRawId(),
+                ["score"] = score,
+                ["reasons"] = new JArray(reasons.Distinct())
+            };
+        }
+
+        private static void AddComponentMatches(Component component, string query, List<string> reasons, ref int score)
+        {
+            string typeName = GetTypeName(component.GetType());
+            if (typeName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
+            {
+                score += 30;
+                reasons.Add($"Component type match: {typeName}");
+            }
+            AddFieldMatches(component.GetType(), query, typeName, reasons, ref score);
+            AddMethodMatches(component.GetType(), query, typeName, reasons, ref score);
+        }
+
+        private static void AddFieldMatches(Type type, string query, string typeName, List<string> reasons, ref int score)
+        {
+            var fields = type.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
+            foreach (var field in fields)
+            {
+                if (field.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) < 0) continue;
+                score += 10;
+                reasons.Add($"Field match: {typeName}.{field.Name}");
+            }
+        }
+
+        private static void AddMethodMatches(Type type, string query, string typeName, List<string> reasons, ref int score)
+        {
+            var methods = type.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.DeclaredOnly);
+            foreach (var method in methods)
+            {
+                if (method.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) < 0) continue;
+                score += 15;
+                reasons.Add($"Method match: {typeName}.{method.Name}()");
+            }
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.HighValue.Semantic.cs.meta b/Editor/MCPServerMethods.HighValue.Semantic.cs.meta
new file mode 100644
index 0000000..0d9643f
--- /dev/null
+++ b/Editor/MCPServerMethods.HighValue.Semantic.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9a9127d833aa4a1d9e79f9b3c87f8d2a
diff --git a/Editor/MCPServerMethods.HighValue.cs b/Editor/MCPServerMethods.HighValue.cs
index f76f68e..b348003 100644
--- a/Editor/MCPServerMethods.HighValue.cs
+++ b/Editor/MCPServerMethods.HighValue.cs
@@ -19,134 +19,6 @@ private static void RegisterHighValueMethods()
             _methods["semantic_find"] = SemanticFind;
         }
 
-        private static JToken CaptureGameViewScreenshot(JToken p)
-        {
-            var gameView = Resources.FindObjectsOfTypeAll<EditorWindow>()
-                .FirstOrDefault(w => w.GetType().Name == "GameView");
-
-            if (gameView == null) throw new Exception("Game View window not found or not open.");
-
-            gameView.Focus();
-            gameView.Repaint();
-
-            Rect pos = gameView.position;
-            // On macOS, the top bar is offset. screencapture -R uses Screen coordinates.
-            // We need to account for Unity's window header if needed, but usually gameView.position is the whole window.
-            int x = (int)pos.x;
-            int y = (int)pos.y;
-            int w = (int)pos.width;
-            int h = (int)pos.height;
-
-            string tempPath = Path.Combine(Path.GetTempPath(), $"unity_gameview_{DateTime.Now.Ticks}.png");
-            NexusEditorLog.Log(NexusLogCategory.UiAutomation, $"[MCP_SCREENSHOT] Capturing GameView at {x},{y},{w},{h} to {tempPath}");
-
-            #if UNITY_EDITOR_OSX
-            var startInfo = new System.Diagnostics.ProcessStartInfo
-            {
-                FileName = "screencapture",
-                Arguments = $"-x -R{x},{y},{w},{h} \"{tempPath}\"",
-                UseShellExecute = false,
-                CreateNoWindow = true,
-                RedirectStandardError = true,
-                RedirectStandardOutput = true
-            };
-
-            using (var process = System.Diagnostics.Process.Start(startInfo))
-            {
-                process.WaitForExit();
-                string output = process.StandardOutput.ReadToEnd();
-                string error = process.StandardError.ReadToEnd();
-                if (process.ExitCode != 0) NexusEditorLog.Error(NexusLogCategory.UiAutomation, $"[MCP_SCREENSHOT] screencapture failed with exit code {process.ExitCode}. Error: {error}");
-            }
-            #else
-            ScreenCapture.CaptureScreenshot(tempPath);
-            int retries = 0;
-            while (!File.Exists(tempPath) && retries < 20)
-            {
-                System.Threading.Thread.Sleep(100);
-                retries++;
-            }
-            #endif
-
-            if (!File.Exists(tempPath)) throw new Exception("Failed to capture Game View screenshot.");
-
-            byte[] bytes = File.ReadAllBytes(tempPath);
-            File.Delete(tempPath);
-
-            return new JObject 
-            { 
-                ["status"] = "Success", 
-                ["image_base64"] = Convert.ToBase64String(bytes),
-                ["format"] = "png"
-            };
-        }
-
-        private static JToken CaptureInspectorScreenshot(JToken p)
-        {
-            #if !UNITY_EDITOR_OSX
-            throw new Exception("Inspector screenshot is currently only supported on macOS.");
-            #else
-            if (p?["instance_id"] != null)
-            {
-                var target = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p));
-                if (target != null) Selection.activeObject = target;
-            }
-
-            var inspector = Resources.FindObjectsOfTypeAll<EditorWindow>()
-                .FirstOrDefault(w => w.titleContent.text == "Inspector");
-            
-            if (inspector == null) throw new Exception("Inspector window not found or not open.");
-
-            inspector.Focus();
-            inspector.Repaint();
-
-            // Always capture the UI layout as it is higher fidelity for AI
-            var layout = SerializeVisualElement(inspector.rootVisualElement, true);
-
-            Rect pos = inspector.position;
-            int x = (int)pos.x;
-            int y = (int)pos.y;
-            int w = (int)pos.width;
-            int h = (int)pos.height;
-
-            string tempPath = Path.Combine(Path.GetTempPath(), $"unity_inspector_{DateTime.Now.Ticks}.png");
-            
-            var startInfo = new System.Diagnostics.ProcessStartInfo
-            {
-                FileName = "screencapture",
-                Arguments = $"-x -R{x},{y},{w},{h} \"{tempPath}\"",
-                UseShellExecute = false,
-                CreateNoWindow = true
-            };
-
-            using (var process = System.Diagnostics.Process.Start(startInfo))
-            {
-                process.WaitForExit();
-            }
-
-            if (!File.Exists(tempPath))
-            {
-                return new JObject 
-                { 
-                    ["status"] = "PartialSuccess", 
-                    ["message"] = "Screenshot failed (permissions?), but UI layout was captured.",
-                    ["ui_layout"] = layout
-                };
-            }
-
-            byte[] bytes = File.ReadAllBytes(tempPath);
-            File.Delete(tempPath);
-
-            return new JObject 
-            { 
-                ["status"] = "Success", 
-                ["image_base64"] = Convert.ToBase64String(bytes),
-                ["format"] = "png",
-                ["ui_layout"] = layout
-            };
-            #endif
-        }
-
         private static JToken GenerateMermaidDiagram(JToken p)
         {
             StringBuilder sb = new StringBuilder();
@@ -215,85 +87,5 @@ private static void BuildMermaidRecursive(GameObject go, StringBuilder sb, HashS
             }
         }
 
-        private static JToken SemanticFind(JToken p)
-        {
-            string query = p?["query"]?.ToString();
-            if (string.IsNullOrEmpty(query)) throw new Exception("query parameter required");
-
-            var allGOs = Resources.FindObjectsOfTypeAll<GameObject>()
-                .Where(go => go.hideFlags == HideFlags.None || go.hideFlags == HideFlags.NotEditable);
-
-            var matches = new List<JObject>();
-
-            using (UnityEngine.Pool.ListPool<Component>.Get(out var comps))
-            {
-                foreach (var go in allGOs)
-                {
-                    if (go.scene == null || !go.scene.isLoaded) continue;
-
-                    int score = 0;
-                    List<string> reasons = new List<string>();
-
-                    if (go.name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
-                    {
-                        score += 50;
-                        reasons.Add("Name match");
-                    }
-
-                    go.GetComponents(comps);
-                    foreach (var comp in comps)
-                    {
-                        if (comp == null) continue;
-                        var type = comp.GetType();
-                        string typeName = GetTypeName(type);
-
-                        if (typeName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
-                        {
-                            score += 30;
-                            reasons.Add($"Component type match: {typeName}");
-                        }
-
-                        // Scan fields
-                        var fields = type.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
-                        foreach (var f in fields)
-                        {
-                            if (f.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
-                            {
-                                score += 10;
-                                reasons.Add($"Field match: {typeName}.{f.Name}");
-                            }
-                        }
-
-                        // Scan methods (Behavioral scanning)
-                        var methods = type.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.DeclaredOnly);
-                        foreach (var m in methods)
-                        {
-                            if (m.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
-                            {
-                                score += 15;
-                                reasons.Add($"Method match: {typeName}.{m.Name}()");
-                            }
-                        }
-                    }
-
-                    if (score > 0)
-                    {
-                        matches.Add(new JObject
-                        {
-                            ["name"] = go.name,
-                            ["instance_id"] = go.GetRawId(),
-                            ["score"] = score,
-                            ["reasons"] = new JArray(reasons.Distinct())
-                        });
-                    }
-                }
-            }
-
-            return new JObject 
-            { 
-                ["status"] = "Success", 
-                ["matches"] = new JArray(matches.OrderByDescending(m => (int)m["score"]).Take(20)) 
-            };
-        }
     }
 }
diff --git a/Editor/MCPServerMethods.Prefab.cs b/Editor/MCPServerMethods.Prefab.cs
index 59899dd..dec826e 100644
--- a/Editor/MCPServerMethods.Prefab.cs
+++ b/Editor/MCPServerMethods.Prefab.cs
@@ -111,44 +111,13 @@ private static JToken EditPrefabAsset(JToken p)
 
             try
             {
-                UnityEngine.Object target = go;
-                if (!string.IsNullOrEmpty(compName))
-                {
-                    target = go.GetComponent(compName);
-                    if (target == null) throw new Exception($"Component {compName} not found on prefab");
-                }
-
+                UnityEngine.Object target = ResolvePrefabEditTarget(go, compName);
                 SerializedObject so = new SerializedObject(target);
                 JArray errors = new JArray();
-                int updatedCount = 0;
-
-                foreach (var propPair in data)
-                {
-                    SerializedProperty prop = so.FindProperty(propPair.Key);
-                    if (prop == null)
-                    {
-                        string cleanName = propPair.Key.StartsWith("m_") ? propPair.Key : "m_" + char.ToUpper(propPair.Key[0]) + propPair.Key.Substring(1);
-                        prop = so.FindProperty(cleanName);
-                    }
-
-                    if (prop != null)
-                    {
-                        try { ApplySimpleJTokenValue(prop, propPair.Value, "Value type not supported for surgical asset edit yet"); updatedCount++; }
-                        catch (Exception e) { errors.Add(new JObject { ["field"] = propPair.Key, ["error"] = e.Message }); }
-                    }
-                    else { errors.Add(new JObject { ["field"] = propPair.Key, ["error"] = "Property not found" }); }
-                }
-
+                int updatedCount = ApplyPrefabPropertyEdits(so, data, errors);
                 so.ApplyModifiedPropertiesWithoutUndo();
                 PrefabUtility.SaveAsPrefabAsset(go, path);
-
-                return new JObject
-                {
-                    ["status"] = errors.Count == 0 ? "Success" : (updatedCount > 0 ? "Partial" : "Failed"),
-                    ["updated_count"] = updatedCount,
-                    ["errors"] = errors,
-                    ["message"] = "Prefab asset updated directly"
-                };
+                return CreatePrefabEditResult(errors, updatedCount);
             }
             finally
             {
@@ -156,5 +125,57 @@ private static JToken EditPrefabAsset(JToken p)
             }
         }
 
+        private static UnityEngine.Object ResolvePrefabEditTarget(GameObject prefab, string componentName)
+        {
+            if (string.IsNullOrEmpty(componentName)) return prefab;
+            var component = prefab.GetComponent(componentName);
+            if (component == null) throw new Exception($"Component {componentName} not found on prefab");
+            return component;
+        }
+
+        private static int ApplyPrefabPropertyEdits(SerializedObject serializedObject, JObject data, JArray errors)
+        {
+            int updatedCount = 0;
+            foreach (var propPair in data)
+            {
+                var property = FindPrefabProperty(serializedObject, propPair.Key);
+                if (property == null)
+                {
+                    errors.Add(new JObject { ["field"] = propPair.Key, ["error"] = "Property not found" });
+                    continue;
+                }
+
+                try
+                {
+                    ApplySimpleJTokenValue(property, propPair.Value, "Value type not supported for surgical asset edit yet");
+                    updatedCount++;
+                }
+                catch (Exception e)
+                {
+                    errors.Add(new JObject { ["field"] = propPair.Key, ["error"] = e.Message });
+                }
+            }
+            return updatedCount;
+        }
+
+        private static SerializedProperty FindPrefabProperty(SerializedObject serializedObject, string propertyName)
+        {
+            var property = serializedObject.FindProperty(propertyName);
+            if (property != null || propertyName.StartsWith("m_")) return property;
+            string cleanName = "m_" + char.ToUpper(propertyName[0]) + propertyName.Substring(1);
+            return serializedObject.FindProperty(cleanName);
+        }
+
+        private static JObject CreatePrefabEditResult(JArray errors, int updatedCount)
+        {
+            return new JObject
+            {
+                ["status"] = errors.Count == 0 ? "Success" : (updatedCount > 0 ? "Partial" : "Failed"),
+                ["updated_count"] = updatedCount,
+                ["errors"] = errors,
+                ["message"] = "Prefab asset updated directly"
+            };
+        }
+
     }
 }
diff --git a/Editor/MCPServerMethods.References.cs b/Editor/MCPServerMethods.References.cs
index 111fd26..3cffd3c 100644
--- a/Editor/MCPServerMethods.References.cs
+++ b/Editor/MCPServerMethods.References.cs
@@ -144,20 +144,22 @@ private static JArray InspectGameObjectReferences(List<Component> components, Ha
                             bool directMatch = targetInstanceIds.Contains(propId);
                             bool indirectMatch = objRef != null && targetInstanceIds.Contains(objRef.GetId());
 
-                            if (directMatch || indirectMatch)
-                            {
-                                var matchDetail = new JObject
-                                {
-                                    ["component"] = GetTypeName(comp.GetType()),
-                                    ["field"] = prop.propertyPath
-                                };
-                                goMatches.Add(matchDetail);
-                            }
+                            AddReferenceMatch(goMatches, directMatch || indirectMatch, comp, prop);
                         }
                     }
                 }
             }
             return goMatches;
         }
+
+        private static void AddReferenceMatch(JArray matches, bool isMatch, Component component, SerializedProperty property)
+        {
+            if (!isMatch) return;
+            matches.Add(new JObject
+            {
+                ["component"] = GetTypeName(component.GetType()),
+                ["field"] = property.propertyPath
+            });
+        }
     }
 }
diff --git a/Editor/MCPServerMethods.Reflection.Symbols.cs b/Editor/MCPServerMethods.Reflection.Symbols.cs
new file mode 100644
index 0000000..1c9463a
--- /dev/null
+++ b/Editor/MCPServerMethods.Reflection.Symbols.cs
@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Threading;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static void StartIndexing()
+        {
+            lock (_indexLock)
+            {
+                if (_isIndexing) return;
+                _isIndexing = true;
+            }
+
+            ThreadPool.QueueUserWorkItem(_ => {
+                try
+                {
+                    var newIndex = BuildSymbolIndex();
+                    lock (_indexLock)
+                    {
+                        _symbolIndex = newIndex;
+                        _isIndexing = false;
+                    }
+                }
+                catch (Exception)
+                {
+                    lock (_indexLock) { _isIndexing = false; }
+                }
+            });
+        }
+
+        private static List<SymbolInfo> BuildSymbolIndex()
+        {
+            var newIndex = new List<SymbolInfo>(100000);
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+            foreach (var assembly in assemblies)
+            {
+                AddAssemblySymbols(assembly, newIndex);
+            }
+            return newIndex;
+        }
+
+        private static void AddAssemblySymbols(Assembly assembly, List<SymbolInfo> index)
+        {
+            string asmName = assembly.GetName().Name;
+            if (asmName.StartsWith("System") || asmName.StartsWith("Microsoft") || asmName.StartsWith("mscorlib") || asmName.StartsWith("netstandard"))
+                return;
+
+            Type[] types;
+            try { types = assembly.GetTypes(); }
+            catch { return; }
+
+            foreach (var type in types)
+            {
+                if (type == null) continue;
+                AddTypeSymbols(type, index);
+            }
+        }
+
+        private static void AddTypeSymbols(Type type, List<SymbolInfo> index)
+        {
+            index.Add(new SymbolInfo
+            {
+                Name = type.Name,
+                Namespace = type.Namespace,
+                DeclaringType = type.FullName,
+                Type = SymbolType.Class,
+                Metadata = type.BaseType?.Name
+            });
+
+            var flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
+
+            foreach (var method in type.GetMethods(flags))
+            {
+                if (method.IsSpecialName) continue;
+                var parameters = string.Join(", ", method.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
+                index.Add(new SymbolInfo
+                {
+                    Name = method.Name,
+                    Namespace = type.Namespace,
+                    DeclaringType = type.FullName,
+                    Type = SymbolType.Method,
+                    Metadata = $"({parameters})"
+                });
+            }
+
+            foreach (var field in type.GetFields(flags))
+            {
+                index.Add(new SymbolInfo
+                {
+                    Name = field.Name,
+                    Namespace = type.Namespace,
+                    DeclaringType = type.FullName,
+                    Type = SymbolType.Field,
+                    Metadata = field.FieldType.Name
+                });
+            }
+        }
+
+        private static JToken SymbolIndex(JToken p)
+        {
+            string query = p?["query"]?.ToString();
+            string typeFilterStr = p?["type_filter"]?.ToString();
+            SymbolType? typeFilter = ParseSymbolTypeFilter(typeFilterStr);
+
+            List<SymbolInfo> currentSnapshot;
+            lock (_indexLock) { currentSnapshot = _symbolIndex; }
+
+            if (currentSnapshot == null || currentSnapshot.Count == 0)
+            {
+                return new JObject { 
+                    ["status"] = "Success", 
+                    ["symbols"] = new JArray(),
+                    ["message"] = _isIndexing ? "Index is being built..." : "Index is empty"
+                };
+            }
+
+            IEnumerable<SymbolInfo> results = currentSnapshot;
+            if (typeFilter.HasValue) results = results.Where(s => s.Type == typeFilter.Value);
+            if (!string.IsNullOrEmpty(query)) results = FilterSymbolsByQuery(results, query);
+
+            var resultList = results.Take(500).Select(s => new JObject {
+                ["name"] = s.Name,
+                ["namespace"] = s.Namespace,
+                ["declaring_type"] = s.DeclaringType,
+                ["type"] = s.Type.ToString(),
+                ["metadata"] = s.Metadata
+            }).ToList();
+
+            return new JObject { 
+                ["status"] = "Success", 
+                ["symbols"] = new JArray(resultList),
+                ["count"] = resultList.Count,
+                ["is_indexing"] = _isIndexing
+            };
+        }
+
+        private static SymbolType? ParseSymbolTypeFilter(string filter)
+        {
+            if (!string.IsNullOrEmpty(filter) && Enum.TryParse<SymbolType>(filter, true, out var result))
+            {
+                return result;
+            }
+            return null;
+        }
+
+        private static IEnumerable<SymbolInfo> FilterSymbolsByQuery(IEnumerable<SymbolInfo> source, string query)
+        {
+            try
+            {
+                var regex = new Regex(query, RegexOptions.IgnoreCase);
+                return source.Where(s => regex.IsMatch(s.Name) || (s.Namespace != null && regex.IsMatch(s.Namespace)));
+            }
+            catch (ArgumentException)
+            {
+                return source.Where(s => s.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0 || 
+                                       (s.Namespace != null && s.Namespace.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0));
+            }
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.Reflection.Symbols.cs.meta b/Editor/MCPServerMethods.Reflection.Symbols.cs.meta
new file mode 100644
index 0000000..c029397
--- /dev/null
+++ b/Editor/MCPServerMethods.Reflection.Symbols.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a0dd97cb67cd4b168fff3c3ae029c706
diff --git a/Editor/MCPServerMethods.Reflection.cs b/Editor/MCPServerMethods.Reflection.cs
index 187af84..ac6b1c9 100644
--- a/Editor/MCPServerMethods.Reflection.cs
+++ b/Editor/MCPServerMethods.Reflection.cs
@@ -3,10 +3,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Threading;
-using UnityEditor;
-using UnityEngine;
 using Newtonsoft.Json.Linq;
+using UnityEngine;
 
 namespace UnityMCP.Editor
 {
@@ -18,32 +16,6 @@ public static partial class MCPServerMethods
         private static bool _isIndexing = false;
         private static object _indexLock = new object();
 
-        /// <summary>
-        /// Identifies the kind of reflected C# symbol returned by the Unity editor symbol index.
-        /// </summary>
-        /// <remarks>
-        /// Class entries describe compiled types, Method entries describe invocable members exposed for editor inspection,
-        /// and Field entries describe reflected fields discovered while scanning Unity assemblies and project scripts.
-        /// </remarks>
-        public enum SymbolType { Class, Method, Field }
-
-        /// <summary>
-        /// Carries reflected C# symbol metadata used by Nexus Unity search and method invocation tools.
-        /// </summary>
-        /// <remarks>
-        /// Values are populated from Unity's loaded assemblies on a background indexing task. Metadata stores serialized
-        /// reflection details used by editor search results and JSON-RPC method invocation, so consumers should treat it
-        /// as protocol data rather than user-authored text.
-        /// </remarks>
-        public struct SymbolInfo
-        {
-            public string Name;
-            public string Namespace;
-            public string DeclaringType;
-            public SymbolType Type;
-            public string Metadata;
-        }
-
         private static void RegisterReflectionMethods()
         {
             _methods["symbol_index"] = SymbolIndex;
@@ -74,160 +46,6 @@ private static void AddReflectionTools(JArray tools)
             }, "instance_id", "method_name"));
         }
 
-        private static void StartIndexing()
-        {
-            lock (_indexLock)
-            {
-                if (_isIndexing) return;
-                _isIndexing = true;
-            }
-
-            ThreadPool.QueueUserWorkItem(_ => {
-                try
-                {
-                    var newIndex = BuildSymbolIndex();
-                    lock (_indexLock)
-                    {
-                        _symbolIndex = newIndex;
-                        _isIndexing = false;
-                    }
-                }
-                catch (Exception)
-                {
-                    lock (_indexLock) { _isIndexing = false; }
-                }
-            });
-        }
-
-        private static List<SymbolInfo> BuildSymbolIndex()
-        {
-            var newIndex = new List<SymbolInfo>(100000);
-            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
-
-            foreach (var assembly in assemblies)
-            {
-                AddAssemblySymbols(assembly, newIndex);
-            }
-            return newIndex;
-        }
-
-        private static void AddAssemblySymbols(Assembly assembly, List<SymbolInfo> index)
-        {
-            string asmName = assembly.GetName().Name;
-            if (asmName.StartsWith("System") || asmName.StartsWith("Microsoft") || asmName.StartsWith("mscorlib") || asmName.StartsWith("netstandard"))
-                return;
-
-            Type[] types;
-            try { types = assembly.GetTypes(); }
-            catch { return; }
-
-            foreach (var type in types)
-            {
-                if (type == null) continue;
-
-                index.Add(new SymbolInfo
-                {
-                    Name = type.Name,
-                    Namespace = type.Namespace,
-                    DeclaringType = type.FullName,
-                    Type = SymbolType.Class,
-                    Metadata = type.BaseType?.Name
-                });
-
-                var flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
-
-                foreach (var method in type.GetMethods(flags))
-                {
-                    if (method.IsSpecialName) continue;
-                    
-                    var parameters = string.Join(", ", method.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
-                    index.Add(new SymbolInfo
-                    {
-                        Name = method.Name,
-                        Namespace = type.Namespace,
-                        DeclaringType = type.FullName,
-                        Type = SymbolType.Method,
-                        Metadata = $"({parameters})"
-                    });
-                }
-
-                foreach (var field in type.GetFields(flags))
-                {
-                    index.Add(new SymbolInfo
-                    {
-                        Name = field.Name,
-                        Namespace = type.Namespace,
-                        DeclaringType = type.FullName,
-                        Type = SymbolType.Field,
-                        Metadata = field.FieldType.Name
-                    });
-                }
-            }
-        }
-
-        private static JToken SymbolIndex(JToken p)
-        {
-            string query = p?["query"]?.ToString();
-            string typeFilterStr = p?["type_filter"]?.ToString();
-            
-            SymbolType? typeFilter = null;
-            if (!string.IsNullOrEmpty(typeFilterStr))
-            {
-                if (Enum.TryParse<SymbolType>(typeFilterStr, true, out var result))
-                    typeFilter = result;
-            }
-
-            List<SymbolInfo> currentSnapshot;
-            lock (_indexLock)
-            {
-                currentSnapshot = _symbolIndex;
-            }
-
-            if (currentSnapshot == null || currentSnapshot.Count == 0)
-            {
-                return new JObject { 
-                    ["status"] = "Success", 
-                    ["symbols"] = new JArray(),
-                    ["message"] = _isIndexing ? "Index is being built..." : "Index is empty"
-                };
-            }
-
-            IEnumerable<SymbolInfo> results = currentSnapshot;
-
-            if (typeFilter.HasValue)
-                results = results.Where(s => s.Type == typeFilter.Value);
-
-            if (!string.IsNullOrEmpty(query))
-            {
-                try
-                {
-                    var regex = new System.Text.RegularExpressions.Regex(query, System.Text.RegularExpressions.RegexOptions.IgnoreCase);
-                    results = results.Where(s => regex.IsMatch(s.Name) || (s.Namespace != null && regex.IsMatch(s.Namespace)));
-                }
-                catch (ArgumentException)
-                {
-                    // Fallback to simple contains if regex is invalid
-                    results = results.Where(s => s.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0 || 
-                                               (s.Namespace != null && s.Namespace.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0));
-                }
-            }
-
-            var resultList = results.Take(500).Select(s => new JObject {
-                ["name"] = s.Name,
-                ["namespace"] = s.Namespace,
-                ["declaring_type"] = s.DeclaringType,
-                ["type"] = s.Type.ToString(),
-                ["metadata"] = s.Metadata
-            }).ToList();
-
-            return new JObject { 
-                ["status"] = "Success", 
-                ["symbols"] = new JArray(resultList),
-                ["count"] = resultList.Count,
-                ["is_indexing"] = _isIndexing
-            };
-        }
-
         internal static string GetTypeName(Type type)
         {
             if (type == null) return "Unknown";
@@ -288,7 +106,6 @@ private static MethodInfo ResolveMethod(object target, string methodName, JArray
 
             if (candidates.Count > 1)
             {
-                // Try to narrow down by type matching
                 var filtered = candidates.Where(m => CanMapArguments(m.GetParameters(), argsArray)).ToList();
                 if (filtered.Count == 1) return filtered[0];
                 if (filtered.Count > 1) candidates = filtered;
@@ -312,25 +129,28 @@ private static bool CanMapArguments(ParameterInfo[] parameters, JArray argsArray
                     continue;
                 }
 
-                switch (jsonValue.Type)
-                {
-                    case JTokenType.Integer:
-                        if (paramType != typeof(int) && paramType != typeof(long) && paramType != typeof(float) && paramType != typeof(double) && paramType != typeof(short) && paramType != typeof(byte)) return false;
-                        break;
-                    case JTokenType.Float:
-                        if (paramType != typeof(float) && paramType != typeof(double)) return false;
-                        break;
-                    case JTokenType.Boolean:
-                        if (paramType != typeof(bool)) return false;
-                        break;
-                    case JTokenType.String:
-                        if (paramType != typeof(string) && !paramType.IsEnum) return false;
-                        break;
-                }
+                if (!IsMatchingJsonType(paramType, jsonValue.Type)) return false;
             }
             return true;
         }
 
+        private static bool IsMatchingJsonType(Type paramType, JTokenType jsonType)
+        {
+            switch (jsonType)
+            {
+                case JTokenType.Integer:
+                    return paramType == typeof(int) || paramType == typeof(long) || paramType == typeof(float) || paramType == typeof(double) || paramType == typeof(short) || paramType == typeof(byte);
+                case JTokenType.Float:
+                    return paramType == typeof(float) || paramType == typeof(double);
+                case JTokenType.Boolean:
+                    return paramType == typeof(bool);
+                case JTokenType.String:
+                    return paramType == typeof(string) || paramType.IsEnum;
+                default:
+                    return true;
+            }
+        }
+
         private static object[] PrepareArguments(MethodInfo method, JArray argsArray)
         {
             var parameters = method.GetParameters();
@@ -344,19 +164,7 @@ private static object[] PrepareArguments(MethodInfo method, JArray argsArray)
 
                 try
                 {
-                    if (jsonValue.Type == JTokenType.Null)
-                    {
-                        invokeArgs[i] = null;
-                    }
-                    else if (expectedType == typeof(int)) invokeArgs[i] = (int)jsonValue;
-                    else if (expectedType == typeof(float)) invokeArgs[i] = (float)jsonValue;
-                    else if (expectedType == typeof(double)) invokeArgs[i] = (double)jsonValue;
-                    else if (expectedType == typeof(bool)) invokeArgs[i] = (bool)jsonValue;
-                    else if (expectedType == typeof(string)) invokeArgs[i] = (string)jsonValue;
-                    else
-                    {
-                        invokeArgs[i] = jsonValue.ToObject(expectedType);
-                    }
+                    invokeArgs[i] = ConvertJsonArgument(expectedType, jsonValue);
                 }
                 catch (Exception ex)
                 {
@@ -366,6 +174,17 @@ private static object[] PrepareArguments(MethodInfo method, JArray argsArray)
             return invokeArgs;
         }
 
+        private static object ConvertJsonArgument(Type expectedType, JToken jsonValue)
+        {
+            if (jsonValue.Type == JTokenType.Null) return null;
+            if (expectedType == typeof(int)) return (int)jsonValue;
+            if (expectedType == typeof(float)) return (float)jsonValue;
+            if (expectedType == typeof(double)) return (double)jsonValue;
+            if (expectedType == typeof(bool)) return (bool)jsonValue;
+            if (expectedType == typeof(string)) return (string)jsonValue;
+            return jsonValue.ToObject(expectedType);
+        }
+
         private static JToken FormatResult(MethodInfo method, object result)
         {
             if (method.ReturnType == typeof(void))
diff --git a/Editor/MCPServerMethods.Serialization.Properties.cs b/Editor/MCPServerMethods.Serialization.Properties.cs
new file mode 100644
index 0000000..38b87dc
--- /dev/null
+++ b/Editor/MCPServerMethods.Serialization.Properties.cs
@@ -0,0 +1,99 @@
+using UnityEditor;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static JToken SerializeProperty(SerializedProperty prop, bool detailed = false)
+        {
+            JToken value = JValue.CreateNull();
+            switch (prop.propertyType)
+            {
+                case SerializedPropertyType.Integer: value = prop.intValue; break;
+                case SerializedPropertyType.Boolean: value = prop.boolValue; break;
+                case SerializedPropertyType.Float: value = prop.floatValue; break;
+                case SerializedPropertyType.String: value = prop.stringValue; break;
+                case SerializedPropertyType.Color: value = "#" + ColorUtility.ToHtmlStringRGBA(prop.colorValue); break;
+                case SerializedPropertyType.Enum: value = prop.enumNames.Length > 0 && prop.enumValueIndex >= 0 && prop.enumValueIndex < prop.enumNames.Length ? prop.enumNames[prop.enumValueIndex] : prop.enumValueIndex.ToString(); break;
+                case SerializedPropertyType.Vector2: value = new JObject { ["x"] = prop.vector2Value.x, ["y"] = prop.vector2Value.y }; break;
+                case SerializedPropertyType.Vector3: value = new JObject { ["x"] = prop.vector3Value.x, ["y"] = prop.vector3Value.y, ["z"] = prop.vector3Value.z }; break;
+                case SerializedPropertyType.Vector4: value = new JObject { ["x"] = prop.vector4Value.x, ["y"] = prop.vector4Value.y, ["z"] = prop.vector4Value.z, ["w"] = prop.vector4Value.w }; break;
+                case SerializedPropertyType.Quaternion: value = new JObject { ["x"] = prop.quaternionValue.x, ["y"] = prop.quaternionValue.y, ["z"] = prop.quaternionValue.z, ["w"] = prop.quaternionValue.w }; break;
+                case SerializedPropertyType.Rect: value = new JObject { ["x"] = prop.rectValue.x, ["y"] = prop.rectValue.y, ["width"] = prop.rectValue.width, ["height"] = prop.rectValue.height }; break;
+                case SerializedPropertyType.Bounds: value = new JObject { ["center"] = new JObject { ["x"] = prop.boundsValue.center.x, ["y"] = prop.boundsValue.center.y, ["z"] = prop.boundsValue.center.z }, ["size"] = new JObject { ["x"] = prop.boundsValue.size.x, ["y"] = prop.boundsValue.size.y, ["z"] = prop.boundsValue.size.z } }; break;
+                case SerializedPropertyType.ObjectReference:
+                    var obj = prop.objectReferenceValue;
+                    if (obj != null) value = new JObject { ["instance_id"] = obj.GetRawId(), ["name"] = obj.name, ["type"] = obj.GetType().Name };
+                    break;
+                case SerializedPropertyType.ManagedReference:
+                    value = SerializeManagedReference(prop, detailed);
+                    break;
+                default: value = SerializeComplexProperty(prop, detailed); break;
+            }
+
+            if (detailed)
+            {
+                return new JObject
+                {
+                    ["value"] = value,
+                    ["type"] = prop.type,
+                    ["propertyType"] = prop.propertyType.ToString(),
+                    ["displayName"] = prop.displayName,
+                    ["tooltip"] = prop.tooltip
+                };
+            }
+            return value;
+        }
+
+        private static JToken SerializeManagedReference(SerializedProperty prop, bool detailed)
+        {
+            if (prop.managedReferenceValue == null) return JValue.CreateNull();
+            
+            JObject result = new JObject();
+            result["_type"] = prop.managedReferenceFullTypename;
+            
+            SerializedProperty child = prop.Copy();
+            SerializedProperty end = prop.GetEndProperty();
+            if (child.Next(true))
+            {
+                while (!SerializedProperty.EqualContents(child, end))
+                {
+                    result[child.name] = SerializeProperty(child, detailed);
+                    if (!child.Next(false)) break;
+                }
+            }
+            return result;
+        }
+
+        private static JToken SerializeComplexProperty(SerializedProperty prop, bool detailed)
+        {
+            if (prop.isArray && prop.propertyType != SerializedPropertyType.String)
+            {
+                JArray arr = new JArray();
+                for (int i = 0; i < prop.arraySize; i++)
+                {
+                    arr.Add(SerializeProperty(prop.GetArrayElementAtIndex(i), detailed));
+                }
+                return arr;
+            }
+
+            if (prop.propertyType == SerializedPropertyType.Generic)
+            {
+                JObject dict = new JObject();
+                SerializedProperty childProp = prop.Copy();
+                SerializedProperty endProp = childProp.GetEndProperty();
+                bool enter = true;
+                while (childProp.Next(enter) && !SerializedProperty.EqualContents(childProp, endProp))
+                {
+                    enter = false;
+                    dict[childProp.name] = SerializeProperty(childProp, detailed);
+                }
+                return dict;
+            }
+
+            return prop.propertyType.ToString();
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.Serialization.Properties.cs.meta b/Editor/MCPServerMethods.Serialization.Properties.cs.meta
new file mode 100644
index 0000000..29d9c8d
--- /dev/null
+++ b/Editor/MCPServerMethods.Serialization.Properties.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4a72811a2a454195be739dfe9058f133
diff --git a/Editor/MCPServerMethods.Serialization.cs b/Editor/MCPServerMethods.Serialization.cs
index c0531d1..0dab483 100644
--- a/Editor/MCPServerMethods.Serialization.cs
+++ b/Editor/MCPServerMethods.Serialization.cs
@@ -48,96 +48,6 @@ private static JToken InspectObject(JToken p)
             return result;
         }
 
-        private static JToken SerializeProperty(SerializedProperty prop, bool detailed = false)
-        {
-            JToken value = JValue.CreateNull();
-            switch (prop.propertyType)
-            {
-                case SerializedPropertyType.Integer: value = prop.intValue; break;
-                case SerializedPropertyType.Boolean: value = prop.boolValue; break;
-                case SerializedPropertyType.Float: value = prop.floatValue; break;
-                case SerializedPropertyType.String: value = prop.stringValue; break;
-                case SerializedPropertyType.Color: value = "#" + ColorUtility.ToHtmlStringRGBA(prop.colorValue); break;
-                case SerializedPropertyType.Enum: value = prop.enumNames.Length > 0 && prop.enumValueIndex >= 0 && prop.enumValueIndex < prop.enumNames.Length ? prop.enumNames[prop.enumValueIndex] : prop.enumValueIndex.ToString(); break;
-                case SerializedPropertyType.Vector2: value = new JObject { ["x"] = prop.vector2Value.x, ["y"] = prop.vector2Value.y }; break;
-                case SerializedPropertyType.Vector3: value = new JObject { ["x"] = prop.vector3Value.x, ["y"] = prop.vector3Value.y, ["z"] = prop.vector3Value.z }; break;
-                case SerializedPropertyType.Vector4: value = new JObject { ["x"] = prop.vector4Value.x, ["y"] = prop.vector4Value.y, ["z"] = prop.vector4Value.z, ["w"] = prop.vector4Value.w }; break;
-                case SerializedPropertyType.Quaternion: value = new JObject { ["x"] = prop.quaternionValue.x, ["y"] = prop.quaternionValue.y, ["z"] = prop.quaternionValue.z, ["w"] = prop.quaternionValue.w }; break;
-                case SerializedPropertyType.Rect: value = new JObject { ["x"] = prop.rectValue.x, ["y"] = prop.rectValue.y, ["width"] = prop.rectValue.width, ["height"] = prop.rectValue.height }; break;
-                case SerializedPropertyType.Bounds: value = new JObject { ["center"] = new JObject { ["x"] = prop.boundsValue.center.x, ["y"] = prop.boundsValue.center.y, ["z"] = prop.boundsValue.center.z }, ["size"] = new JObject { ["x"] = prop.boundsValue.size.x, ["y"] = prop.boundsValue.size.y, ["z"] = prop.boundsValue.size.z } }; break;
-                case SerializedPropertyType.ObjectReference:
-                    var obj = prop.objectReferenceValue;
-                    if (obj != null) value = new JObject { ["instance_id"] = obj.GetRawId(), ["name"] = obj.name, ["type"] = obj.GetType().Name };
-                    break;
-                case SerializedPropertyType.ManagedReference:
-                    value = SerializeManagedReference(prop, detailed);
-                    break;
-                default: value = SerializeComplexProperty(prop, detailed); break;
-            }
-
-            if (detailed)
-            {
-                return new JObject
-                {
-                    ["value"] = value,
-                    ["type"] = prop.type,
-                    ["propertyType"] = prop.propertyType.ToString(),
-                    ["displayName"] = prop.displayName,
-                    ["tooltip"] = prop.tooltip
-                };
-            }
-            return value;
-        }
-
-        private static JToken SerializeManagedReference(SerializedProperty prop, bool detailed)
-        {
-            if (prop.managedReferenceValue == null) return JValue.CreateNull();
-            
-            JObject result = new JObject();
-            result["_type"] = prop.managedReferenceFullTypename;
-            
-            SerializedProperty child = prop.Copy();
-            SerializedProperty end = prop.GetEndProperty();
-            if (child.Next(true))
-            {
-                while (!SerializedProperty.EqualContents(child, end))
-                {
-                    result[child.name] = SerializeProperty(child, detailed);
-                    if (!child.Next(false)) break;
-                }
-            }
-            return result;
-        }
-
-        private static JToken SerializeComplexProperty(SerializedProperty prop, bool detailed)
-        {
-            if (prop.isArray && prop.propertyType != SerializedPropertyType.String)
-            {
-                JArray arr = new JArray();
-                for (int i = 0; i < prop.arraySize; i++)
-                {
-                    arr.Add(SerializeProperty(prop.GetArrayElementAtIndex(i), detailed));
-                }
-                return arr;
-            }
-
-            if (prop.propertyType == SerializedPropertyType.Generic)
-            {
-                JObject dict = new JObject();
-                SerializedProperty childProp = prop.Copy();
-                SerializedProperty endProp = childProp.GetEndProperty();
-                bool enter = true;
-                while (childProp.Next(enter) && !SerializedProperty.EqualContents(childProp, endProp))
-                {
-                    enter = false;
-                    dict[childProp.name] = SerializeProperty(childProp, detailed);
-                }
-                return dict;
-            }
-
-            return prop.propertyType.ToString();
-        }
-
         private static int UpdateComponentProperties(SerializedObject so, JObject data, JArray errors)
         {
             int updatedCount = 0;
@@ -241,21 +151,22 @@ private static void ApplyObjectReferenceValue(SerializedProperty prop, JToken va
             else if (value.Type == JTokenType.String) prop.objectReferenceValue = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(value.ToString());
             else if (value.Type == JTokenType.Object)
             {
-                if (value["instance_id"] != null) prop.objectReferenceValue = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(value));
-                else if (value["guid"] != null && value["file_id"] != null)
+                if (value["instance_id"] != null)
+                {
+                    prop.objectReferenceValue = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(value));
+                    return;
+                }
+                if (value["guid"] == null || value["file_id"] == null) return;
+                string path = AssetDatabase.GUIDToAssetPath(value["guid"].ToString());
+                if (string.IsNullOrEmpty(path)) return;
+
+                long fileId = (long)value["file_id"];
+                var all = AssetDatabase.LoadAllAssetsAtPath(path);
+                foreach (var asset in all)
                 {
-                    string path = AssetDatabase.GUIDToAssetPath(value["guid"].ToString());
-                    if (!string.IsNullOrEmpty(path))
-                    {
-                        long fileId = (long)value["file_id"];
-                        var all = AssetDatabase.LoadAllAssetsAtPath(path);
-                        foreach (var asset in all)
-                        {
-                            if (asset == null) continue;
-                            AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out _, out long id);
-                            if (id == fileId) { prop.objectReferenceValue = asset; break; }
-                        }
-                    }
+                    if (asset == null) continue;
+                    AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out _, out long id);
+                    if (id == fileId) { prop.objectReferenceValue = asset; break; }
                 }
             }
         }
diff --git a/Editor/MCPServerMethods.SerializationUtils.cs b/Editor/MCPServerMethods.SerializationUtils.cs
index 3eacdbf..88ca849 100644
--- a/Editor/MCPServerMethods.SerializationUtils.cs
+++ b/Editor/MCPServerMethods.SerializationUtils.cs
@@ -30,8 +30,28 @@ private static VisualElement FindElementByName(VisualElement root, string name)
             return root.Q(name);
         }
 
-        private static JToken SerializeVisualElement(VisualElement el, bool deep = false)
+        private sealed class VisualElementSerializationState
         {
+            internal int VisitedCount;
+            internal int CurrentDepth;
+            internal readonly int MaxElements;
+            internal readonly int MaxDepth;
+            internal readonly bool Deep;
+            internal bool IsTruncated;
+
+            internal VisualElementSerializationState(int maxDepth, int maxElements, bool deep = false, int currentDepth = 0)
+            {
+                MaxDepth = maxDepth < 0 ? 0 : maxDepth;
+                MaxElements = maxElements <= 0 ? 1 : maxElements;
+                Deep = deep;
+                CurrentDepth = currentDepth;
+            }
+        }
+
+        internal static JObject SerializeVisualElementNode(VisualElement el, bool deep = false)
+        {
+            if (el == null) return null;
+
             var obj = new JObject
             {
                 ["name"] = el.name,
@@ -60,10 +80,57 @@ private static JToken SerializeVisualElement(VisualElement el, bool deep = false
                 obj["computed_style"] = style;
             }
 
-            var children = new JArray();
-            foreach (var child in el.Children()) children.Add(SerializeVisualElement(child, deep));
-            if (children.Count > 0) obj["children"] = children;
             return obj;
         }
+
+        private static JToken SerializeVisualElement(VisualElement el, VisualElementSerializationState state)
+        {
+            if (el == null) return JValue.CreateNull();
+
+            state.VisitedCount++;
+            var obj = SerializeVisualElementNode(el, state.Deep);
+            if (obj == null) return JValue.CreateNull();
+
+            int childCount = el.childCount;
+            if (childCount > 0)
+            {
+                if (state.CurrentDepth >= state.MaxDepth)
+                {
+                    obj["children_truncated"] = true;
+                    state.IsTruncated = true;
+                }
+                else
+                {
+                    var children = new JArray();
+                    state.CurrentDepth++;
+                    for (int i = 0; i < childCount; i++)
+                    {
+                        if (state.VisitedCount >= state.MaxElements)
+                        {
+                            obj["children_truncated"] = true;
+                            state.IsTruncated = true;
+                            break;
+                        }
+                        children.Add(SerializeVisualElement(el[i], state));
+                    }
+                    state.CurrentDepth--;
+                    if (children.Count > 0) obj["children"] = children;
+                }
+            }
+
+            if (state.CurrentDepth == 0 && state.IsTruncated)
+            {
+                obj["truncated"] = true;
+            }
+
+            return obj;
+        }
+
+        private static JToken SerializeVisualElement(VisualElement el, bool deep = false, int maxDepth = 30, int maxElements = 1000)
+        {
+            if (el == null) return JValue.CreateNull();
+            var state = new VisualElementSerializationState(maxDepth, maxElements, deep, 0);
+            return SerializeVisualElement(el, state);
+        }
     }
 }
diff --git a/Editor/MCPServerMethods.TestResults.cs b/Editor/MCPServerMethods.TestResults.cs
index c4911e7..c8191c9 100644
--- a/Editor/MCPServerMethods.TestResults.cs
+++ b/Editor/MCPServerMethods.TestResults.cs
@@ -14,14 +14,7 @@ private static JToken GetTestResults(JToken p)
         {
             string resultPath = ResolveTestResultsPath(p);
             if (string.IsNullOrEmpty(resultPath) || !File.Exists(resultPath))
-            {
-                return new JObject
-                {
-                    ["status"] = "NotFound",
-                    ["result_path"] = resultPath ?? GetDefaultTestResultsPath(),
-                    ["message"] = "No Unity TestResults XML file was found."
-                };
-            }
+                return CreateMissingTestResults(resultPath);
 
             try
             {
@@ -29,42 +22,7 @@ private static JToken GetTestResults(JToken p)
                 XElement root = document.Root;
                 if (root == null)
                     return new JObject { ["status"] = "Error", ["result_path"] = resultPath, ["message"] = "TestResults XML is empty." };
-
-                var failedTests = new JArray();
-                foreach (XElement testCase in document.Descendants("test-case"))
-                {
-                    string result = Attr(testCase, "result");
-                    if (string.Equals(result, "Passed", StringComparison.OrdinalIgnoreCase) ||
-                        string.Equals(result, "Skipped", StringComparison.OrdinalIgnoreCase))
-                        continue;
-
-                    string message = testCase.Element("failure")?.Element("message")?.Value
-                        ?? testCase.Element("reason")?.Element("message")?.Value
-                        ?? testCase.Element("output")?.Value
-                        ?? result;
-                    failedTests.Add(new JObject
-                    {
-                        ["name"] = Attr(testCase, "name"),
-                        ["fullname"] = Attr(testCase, "fullname"),
-                        ["result"] = result,
-                        ["message"] = message
-                    });
-                }
-
-                return new JObject
-                {
-                    ["status"] = "Success",
-                    ["result_path"] = resultPath,
-                    ["timestamp_utc"] = File.GetLastWriteTimeUtc(resultPath).ToString("o"),
-                    ["result"] = Attr(root, "result"),
-                    ["total"] = IntAttr(root, "total"),
-                    ["passed"] = IntAttr(root, "passed"),
-                    ["failed"] = IntAttr(root, "failed"),
-                    ["inconclusive"] = IntAttr(root, "inconclusive"),
-                    ["skipped"] = IntAttr(root, "skipped"),
-                    ["duration"] = DoubleAttr(root, "duration"),
-                    ["failed_tests"] = failedTests
-                };
+                return BuildTestResultsResponse(document, root, resultPath);
             }
             catch (Exception e)
             {
@@ -77,6 +35,66 @@ private static JToken GetTestResults(JToken p)
             }
         }
 
+        private static JObject CreateMissingTestResults(string resultPath)
+        {
+            return new JObject
+            {
+                ["status"] = "NotFound",
+                ["result_path"] = resultPath ?? GetDefaultTestResultsPath(),
+                ["message"] = "No Unity TestResults XML file was found."
+            };
+        }
+
+        private static JObject BuildTestResultsResponse(XDocument document, XElement root, string resultPath)
+        {
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["result_path"] = resultPath,
+                ["timestamp_utc"] = File.GetLastWriteTimeUtc(resultPath).ToString("o"),
+                ["result"] = Attr(root, "result"),
+                ["total"] = IntAttr(root, "total"),
+                ["passed"] = IntAttr(root, "passed"),
+                ["failed"] = IntAttr(root, "failed"),
+                ["inconclusive"] = IntAttr(root, "inconclusive"),
+                ["skipped"] = IntAttr(root, "skipped"),
+                ["duration"] = DoubleAttr(root, "duration"),
+                ["failed_tests"] = CollectFailedTests(document)
+            };
+        }
+
+        private static JArray CollectFailedTests(XDocument document)
+        {
+            var failedTests = new JArray();
+            foreach (XElement testCase in document.Descendants("test-case"))
+            {
+                string result = Attr(testCase, "result");
+                if (!IsSuccessfulTestResult(result)) failedTests.Add(CreateFailedTest(testCase, result));
+            }
+            return failedTests;
+        }
+
+        private static bool IsSuccessfulTestResult(string result)
+        {
+            return string.Equals(result, "Passed", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(result, "Skipped", StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static JObject CreateFailedTest(XElement testCase, string result)
+        {
+            string message = testCase.Element("failure")?.Element("message")?.Value
+                ?? testCase.Element("reason")?.Element("message")?.Value
+                ?? testCase.Element("output")?.Value
+                ?? result;
+            return new JObject
+            {
+                ["name"] = Attr(testCase, "name"),
+                ["fullname"] = Attr(testCase, "fullname"),
+                ["result"] = result,
+                ["message"] = message
+            };
+        }
+
         private static string ResolveTestResultsPath(JToken p)
         {
             string requested = p?["result_path"]?.ToString();
diff --git a/Editor/MCPServerMethods.ToolsExtended.cs b/Editor/MCPServerMethods.ToolsExtended.cs
index 29655ac..908a758 100644
--- a/Editor/MCPServerMethods.ToolsExtended.cs
+++ b/Editor/MCPServerMethods.ToolsExtended.cs
@@ -69,7 +69,13 @@ private static void AddDiscoveryTools(JArray tools)
         private static void AddUITools(JArray tools)
         {
             tools.Add(CreateTool("ui_list_windows", "List Editor Windows", new JObject { }));
-            tools.Add(CreateTool("ui_get_hierarchy", "Inspect Window UI", new JObject { ["window_title"] = new JObject { ["type"] = "string" } }, "window_title"));
+            tools.Add(CreateTool("ui_get_hierarchy", "Inspect Window UI", new JObject
+            {
+                ["window_title"] = new JObject { ["type"] = "string" },
+                ["deep"] = new JObject { ["type"] = "boolean" },
+                ["max_depth"] = new JObject { ["type"] = "integer" },
+                ["max_elements"] = new JObject { ["type"] = "integer" }
+            }, "window_title"));
             tools.Add(CreateTool("ui_get_window_rect", "Get an EditorWindow position and size for layout QA", new JObject { ["window_title"] = new JObject { ["type"] = "string" } }, "window_title"));
             tools.Add(CreateTool("ui_set_window_rect", "Set an EditorWindow position and size for layout QA", new JObject
             {
@@ -83,14 +89,18 @@ private static void AddUITools(JArray tools)
             {
                 ["window_title"] = new JObject { ["type"] = "string" },
                 ["include_image"] = new JObject { ["type"] = "boolean" },
-                ["include_hierarchy"] = new JObject { ["type"] = "boolean" }
+                ["include_hierarchy"] = new JObject { ["type"] = "boolean" },
+                ["max_depth"] = new JObject { ["type"] = "integer" },
+                ["max_elements"] = new JObject { ["type"] = "integer" }
             }, "window_title"));
             tools.Add(CreateTool("ui_query_elements", "Find UI Toolkit elements by text, name, or USS class", new JObject
             {
                 ["window_title"] = new JObject { ["type"] = "string" },
                 ["name"] = new JObject { ["type"] = "string" },
                 ["text"] = new JObject { ["type"] = "string" },
-                ["class_name"] = new JObject { ["type"] = "string" }
+                ["class_name"] = new JObject { ["type"] = "string" },
+                ["max_depth"] = new JObject { ["type"] = "integer" },
+                ["max_results"] = new JObject { ["type"] = "integer" }
             }, "window_title"));
             tools.Add(CreateTool("ui_click", "Simulate UI Click", new JObject { ["window_title"] = new JObject { ["type"] = "string" }, ["element_name"] = new JObject { ["type"] = "string" } }, "window_title", "element_name"));
             tools.Add(CreateTool("ui_input_text", "Type into UI field", new JObject { ["window_title"] = new JObject { ["type"] = "string" }, ["element_name"] = new JObject { ["type"] = "string" }, ["text"] = new JObject { ["type"] = "string" } }, "window_title", "element_name", "text"));
diff --git a/Editor/MCPServerMethods.TypeResolution.cs b/Editor/MCPServerMethods.TypeResolution.cs
index 2782193..d2cb517 100644
--- a/Editor/MCPServerMethods.TypeResolution.cs
+++ b/Editor/MCPServerMethods.TypeResolution.cs
@@ -81,61 +81,48 @@ internal static Type FindType(string name)
             if (_typeCache.TryGetValue(name, out var cachedType)) return cachedType;
 
             var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(IsAllowedAssembly).ToList();
-            Type resultType = null;
-            
-            // Priority 1: Check Assembly-CSharp
-            var mainAsm = assemblies.FirstOrDefault(a => a.GetName().Name == "Assembly-CSharp");
-            if (mainAsm != null)
-            {
-                resultType = GetTypeFromAssembly(mainAsm, name);
-            }
+            Type resultType = FindTypeInPriorityAssemblies(assemblies, name);
 
-            // Priority 2: Check UnityEngine CoreModule (Component, Camera, BoxCollider, etc.)
-            if (resultType == null)
+            if (resultType != null && IsAllowedType(resultType))
             {
-                var coreAsm = typeof(Component).Assembly;
-                if (IsAllowedAssembly(coreAsm))
-                {
-                    resultType = GetTypeFromAssembly(coreAsm, name);
-                }
+                _typeCache[name] = resultType;
+                return resultType;
             }
 
-            // Priority 3: Check UnityEngine.UI module if loaded
-            if (resultType == null)
-            {
-                var uiAsm = assemblies.FirstOrDefault(a => a.GetName().Name == "UnityEngine.UI");
-                if (uiAsm != null)
-                {
-                    resultType = GetTypeFromAssembly(uiAsm, name);
-                }
-            }
+            return null;
+        }
 
-            // Priority 4: Check Assembly-CSharp-firstpass
-            if (resultType == null)
-            {
-                var firstPassAsm = assemblies.FirstOrDefault(a => a.GetName().Name == "Assembly-CSharp-firstpass");
-                if (firstPassAsm != null)
-                {
-                    resultType = GetTypeFromAssembly(firstPassAsm, name);
-                }
-            }
+        private static Type FindTypeInPriorityAssemblies(List<Assembly> assemblies, string name)
+        {
+            Type result = FindTypeInNamedAssembly(assemblies, "Assembly-CSharp", name);
+            if (result != null) return result;
 
-            // Priority 5: Check all other allowed assemblies
-            if (resultType == null)
+            var coreAssembly = typeof(Component).Assembly;
+            if (IsAllowedAssembly(coreAssembly))
             {
-                foreach (var a in assemblies)
-                {
-                    resultType = GetTypeFromAssembly(a, name);
-                    if (resultType != null) break;
-                }
+                result = GetTypeFromAssembly(coreAssembly, name);
+                if (result != null) return result;
             }
 
-            if (resultType != null && IsAllowedType(resultType))
+            result = FindTypeInNamedAssembly(assemblies, "UnityEngine.UI", name);
+            if (result != null) return result;
+            result = FindTypeInNamedAssembly(assemblies, "Assembly-CSharp-firstpass", name);
+            return result ?? FindTypeInAssemblies(assemblies, name);
+        }
+
+        private static Type FindTypeInNamedAssembly(List<Assembly> assemblies, string assemblyName, string name)
+        {
+            var assembly = assemblies.FirstOrDefault(item => item.GetName().Name == assemblyName);
+            return assembly == null ? null : GetTypeFromAssembly(assembly, name);
+        }
+
+        private static Type FindTypeInAssemblies(List<Assembly> assemblies, string name)
+        {
+            foreach (var assembly in assemblies)
             {
-                _typeCache[name] = resultType;
-                return resultType;
+                var result = GetTypeFromAssembly(assembly, name);
+                if (result != null) return result;
             }
-
             return null;
         }
 
diff --git a/Editor/MCPServerMethods.UI.cs b/Editor/MCPServerMethods.UI.cs
index 9b7dca4..b5cb543 100644
--- a/Editor/MCPServerMethods.UI.cs
+++ b/Editor/MCPServerMethods.UI.cs
@@ -36,13 +36,36 @@ private static JToken UIListWindows(JToken p)
             return new JObject { ["windows"] = arr };
         }
 
+        private const int DefaultMaxHierarchyDepth = 30;
+        private const int DefaultMaxHierarchyElements = 1000;
+        private const int DefaultMaxQueryResults = 100;
+        private const int DefaultMaxQueryTraversedElements = 2000;
+
         private static JToken UIGetHierarchy(JToken p)
         {
             if (p == null || p["window_title"] == null) throw new Exception("window_title is required");
             var w = FindWindow(p["window_title"].ToString());
             if (w == null) throw new Exception("Window not found");
             bool deep = p["deep"] != null && (bool)p["deep"];
-            return SerializeVisualElement(w.rootVisualElement, deep);
+            int maxDepth = p["max_depth"] != null ? Mathf.Max(0, p["max_depth"].Value<int>()) : DefaultMaxHierarchyDepth;
+            int maxElements = p["max_elements"] != null ? Mathf.Max(1, p["max_elements"].Value<int>()) :
+                (p["max_results"] != null ? Mathf.Max(1, p["max_results"].Value<int>()) : DefaultMaxHierarchyElements);
+            return SerializeVisualElement(w.rootVisualElement, deep, maxDepth, maxElements);
+        }
+
+        private sealed class UIElementQueryContext
+        {
+            internal string TextMatch;
+            internal string NameMatch;
+            internal string ClassMatch;
+            internal int MaxResults;
+            internal int MaxTraversed;
+            internal int MaxDepth;
+            internal JArray Results;
+            internal int VisitedCount;
+
+            internal bool ShouldStop(int currentDepth) =>
+                Results.Count >= MaxResults || VisitedCount >= MaxTraversed || currentDepth > MaxDepth;
         }
 
         private static JToken UIQueryElements(JToken p)
@@ -51,13 +74,24 @@ private static JToken UIQueryElements(JToken p)
             var w = FindWindow(p["window_title"].ToString());
             if (w == null) throw new Exception("Window not found");
 
-            string textMatch = p["text"]?.ToString();
-            string nameMatch = p["name"]?.ToString();
-            string classMatch = p["class_name"]?.ToString();
+            int maxDepth = p["max_depth"] != null ? Mathf.Max(0, p["max_depth"].Value<int>()) : DefaultMaxHierarchyDepth;
+            int maxResults = p["max_results"] != null ? Mathf.Max(1, p["max_results"].Value<int>()) : DefaultMaxQueryResults;
+            int maxTraversed = p["max_elements"] != null ? Mathf.Max(1, p["max_elements"].Value<int>()) :
+                (p["max_traversed"] != null ? Mathf.Max(1, p["max_traversed"].Value<int>()) : DefaultMaxQueryTraversedElements);
+
+            var ctx = new UIElementQueryContext
+            {
+                TextMatch = p["text"]?.ToString(),
+                NameMatch = p["name"]?.ToString(),
+                ClassMatch = p["class_name"]?.ToString(),
+                MaxDepth = maxDepth,
+                MaxResults = maxResults,
+                MaxTraversed = maxTraversed,
+                Results = new JArray()
+            };
 
-            var results = new JArray();
-            QueryVisualElementRecursive(w.rootVisualElement, textMatch, nameMatch, classMatch, results);
-            return results;
+            QueryVisualElementRecursive(w.rootVisualElement, ctx, 0);
+            return ctx.Results;
         }
 
         private static JToken UIGetWindowRect(JToken p)
@@ -118,47 +152,52 @@ private static bool HasNonNullParam(JToken p, string name)
             return p?[name] != null && p[name].Type != JTokenType.Null;
         }
 
-        private static void QueryVisualElementRecursive(VisualElement el, string textMatch, string nameMatch, string classMatch, JArray results)
+        private static void QueryVisualElementRecursive(VisualElement el, UIElementQueryContext ctx, int currentDepth)
         {
-            if (el == null) return;
-
-            bool matches = true;
+            if (el == null || ctx.ShouldStop(currentDepth)) return;
 
-            if (!string.IsNullOrEmpty(nameMatch) && el.name != nameMatch)
-                matches = false;
+            ctx.VisitedCount++;
 
-            if (matches && !string.IsNullOrEmpty(classMatch) && !el.ClassListContains(classMatch))
-                matches = false;
+            if (MatchesQuery(el, ctx))
+            {
+                var obj = SerializeVisualElementNode(el, deep: true);
+                if (obj != null) ctx.Results.Add(obj);
+                if (ctx.Results.Count >= ctx.MaxResults) return;
+            }
 
-            if (matches && !string.IsNullOrEmpty(textMatch))
+            if (currentDepth < ctx.MaxDepth)
             {
-                if (el is TextElement te)
-                {
-                    if (string.IsNullOrEmpty(te.text) || !te.text.Contains(textMatch, StringComparison.OrdinalIgnoreCase))
-                        matches = false;
-                }
-                else
+                int childCount = el.childCount;
+                for (int i = 0; i < childCount; i++)
                 {
-                    matches = false; // Not a text element
+                    if (ctx.Results.Count >= ctx.MaxResults || ctx.VisitedCount >= ctx.MaxTraversed) break;
+                    QueryVisualElementRecursive(el[i], ctx, currentDepth + 1);
                 }
             }
+        }
+
+        private static bool MatchesQuery(VisualElement el, UIElementQueryContext ctx)
+        {
+            if (!string.IsNullOrEmpty(ctx.NameMatch) && el.name != ctx.NameMatch)
+                return false;
+
+            if (!string.IsNullOrEmpty(ctx.ClassMatch) && !el.ClassListContains(ctx.ClassMatch))
+                return false;
 
-            // We only add to results if at least one query parameter was provided AND it matched
-            if (matches && (!string.IsNullOrEmpty(textMatch) || !string.IsNullOrEmpty(nameMatch) || !string.IsNullOrEmpty(classMatch)))
+            if (!string.IsNullOrEmpty(ctx.TextMatch))
             {
-                // We serialize this element deeply but without its full children tree to avoid massive payloads
-                var obj = SerializeVisualElement(el, true);
-                if (obj is JObject jobj && jobj.ContainsKey("children"))
+                if (el is TextElement te)
+                {
+                    if (string.IsNullOrEmpty(te.text) || !te.text.Contains(ctx.TextMatch, StringComparison.OrdinalIgnoreCase))
+                        return false;
+                }
+                else
                 {
-                    jobj.Remove("children"); // Remove deep children for the query result, we just want the matched node
+                    return false;
                 }
-                results.Add(obj);
             }
 
-            foreach (var child in el.Children())
-            {
-                QueryVisualElementRecursive(child, textMatch, nameMatch, classMatch, results);
-            }
+            return !string.IsNullOrEmpty(ctx.TextMatch) || !string.IsNullOrEmpty(ctx.NameMatch) || !string.IsNullOrEmpty(ctx.ClassMatch);
         }
 
         private static JToken UIClick(JToken p)
diff --git a/Editor/MCPServerMethods.UISnapshot.cs b/Editor/MCPServerMethods.UISnapshot.cs
index 53cb8e3..db1b130 100644
--- a/Editor/MCPServerMethods.UISnapshot.cs
+++ b/Editor/MCPServerMethods.UISnapshot.cs
@@ -28,7 +28,12 @@ private static JToken UICaptureWindowSnapshot(JToken p)
             };
 
             if (includeHierarchy)
-                result["ui_hierarchy"] = SerializeVisualElement(window.rootVisualElement, true);
+            {
+                int maxDepth = p["max_depth"] != null ? Mathf.Max(0, p["max_depth"].Value<int>()) : DefaultMaxHierarchyDepth;
+                int maxElements = p["max_elements"] != null ? Mathf.Max(1, p["max_elements"].Value<int>()) :
+                    (p["max_results"] != null ? Mathf.Max(1, p["max_results"].Value<int>()) : DefaultMaxHierarchyElements);
+                result["ui_hierarchy"] = SerializeVisualElement(window.rootVisualElement, true, maxDepth, maxElements);
+            }
 
             if (includeImage)
                 AddWindowImage(window, result);
@@ -39,6 +44,16 @@ private static JToken UICaptureWindowSnapshot(JToken p)
         private static void AddWindowImage(EditorWindow window, JObject result)
         {
 #if UNITY_EDITOR_OSX
+            CaptureOSXWindowScreenshot(window, result);
+#else
+            result["status"] = "PartialSuccess";
+            result["message"] = "Window image capture is currently supported on macOS only.";
+#endif
+        }
+
+#if UNITY_EDITOR_OSX
+        private static void CaptureOSXWindowScreenshot(EditorWindow window, JObject result)
+        {
             string tempPath = Path.Combine(Path.GetTempPath(), $"nexus_window_{DateTime.UtcNow.Ticks}.png");
             try
             {
@@ -84,10 +99,7 @@ private static void AddWindowImage(EditorWindow window, JObject result)
             {
                 if (File.Exists(tempPath)) File.Delete(tempPath);
             }
-#else
-            result["status"] = "PartialSuccess";
-            result["message"] = "Window image capture is currently supported on macOS only.";
-#endif
         }
+#endif
     }
 }
diff --git a/Editor/MCPServerMethods.Utils.cs b/Editor/MCPServerMethods.Utils.cs
index 715c727..156b983 100644
--- a/Editor/MCPServerMethods.Utils.cs
+++ b/Editor/MCPServerMethods.Utils.cs
@@ -28,8 +28,8 @@ public static partial class MCPServerMethods
         [DllImport("libc", EntryPoint = "free")]
         private static extern void sys_free(IntPtr ptr);
 
-        [DllImport("kernel32.dll", EntryPoint = "CreateFileW", CharSet = CharSet.Unicode, SetLastError = true)]
-        private static extern SafeFileHandle CreateFile(
+        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Unicode)]
+        private delegate IntPtr CreateFileDelegate(
             string lpFileName,
             uint dwDesiredAccess,
             uint dwShareMode,
@@ -38,6 +38,12 @@ private static extern SafeFileHandle CreateFile(
             uint dwFlagsAndAttributes,
             IntPtr hTemplateFile);
 
+        [DllImport("kernel32.dll", EntryPoint = "LoadLibraryW", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern IntPtr LoadLibrary(string libraryName);
+
+        [DllImport("kernel32.dll", EntryPoint = "GetProcAddress", CharSet = CharSet.Ansi, SetLastError = true)]
+        private static extern IntPtr GetProcAddress(IntPtr module, string procedureName);
+
         [DllImport("kernel32.dll", EntryPoint = "GetFinalPathNameByHandleW", CharSet = CharSet.Unicode, SetLastError = true)]
         private static extern uint GetFinalPathNameByHandle(
             SafeFileHandle hFile,
@@ -51,6 +57,8 @@ private static extern uint GetFinalPathNameByHandle(
         private const uint OPEN_EXISTING = 3;
         private const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
         private const uint VOLUME_NAME_DOS = 0x0;
+        private static CreateFileDelegate _createFile;
+        private static IntPtr _kernel32;
 
         private static string ResolveUnixPath(string path)
         {
@@ -71,14 +79,18 @@ private static string ResolveUnixPath(string path)
 
         private static string ResolveWindowsPath(string path)
         {
-            using (SafeFileHandle hFile = CreateFile(
+            var createFile = GetCreateFileDelegate();
+            if (createFile == null) return path;
+
+            IntPtr rawHandle = createFile(
                 path,
                 0,
                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                 IntPtr.Zero,
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS,
-                IntPtr.Zero))
+                IntPtr.Zero);
+            using (var hFile = new SafeFileHandle(rawHandle, true))
             {
                 if (hFile.IsInvalid)
                 {
@@ -105,6 +117,17 @@ private static string ResolveWindowsPath(string path)
             }
         }
 
+        private static CreateFileDelegate GetCreateFileDelegate()
+        {
+            if (_createFile != null) return _createFile;
+            _kernel32 = LoadLibrary("kernel32.dll");
+            if (_kernel32 == IntPtr.Zero) return null;
+            IntPtr address = GetProcAddress(_kernel32, "CreateFileW");
+            if (address == IntPtr.Zero) return null;
+            _createFile = (CreateFileDelegate)Marshal.GetDelegateForFunctionPointer(address, typeof(CreateFileDelegate));
+            return _createFile;
+        }
+
         private static string ResolveRealPathInternal(string path)
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
diff --git a/Editor/MCPServerWindow.Integrations.cs b/Editor/MCPServerWindow.Integrations.cs
index 6229a1c..5d1fbb3 100644
--- a/Editor/MCPServerWindow.Integrations.cs
+++ b/Editor/MCPServerWindow.Integrations.cs
@@ -43,32 +43,49 @@ private void DrawIntegrationsTabRefresh()
         private VisualElement BuildIntegrationCard(NexusMcpClientInfo client)
         {
             var card = NexusEditorUi.Panel("NexusIntegrationCard" + client.ElementKey);
+            StyleIntegrationCard(card);
+            card.Add(CreateIntegrationTitle(client));
+            AddIntegrationDetails(card, client);
+            card.Add(CreateIntegrationActions(client));
+            return card;
+        }
+
+        private static void StyleIntegrationCard(VisualElement card)
+        {
             card.style.flexBasis = 260;
             card.style.flexGrow = 1;
             card.style.flexShrink = 1;
             card.style.minWidth = 240;
             card.style.marginRight = 6;
+        }
 
+        private static VisualElement CreateIntegrationTitle(NexusMcpClientInfo client)
+        {
             var titleRow = NexusEditorUi.Row(true, "NexusIntegrationTitle" + client.ElementKey);
             var title = NexusEditorUi.Label(client.DisplayName, 13, true, null, "NexusIntegrationName" + client.ElementKey);
             title.style.flexGrow = 1;
             title.style.minWidth = 130;
             titleRow.Add(title);
             titleRow.Add(NexusEditorUi.Pill(GetIntegrationStatusText(client.Status), GetIntegrationStatusColor(client.Status), "NexusIntegrationStatus" + client.ElementKey));
-            card.Add(titleRow);
-
-            var detail = NexusEditorUi.Label(client.StatusDetail, 10, false, NexusEditorUi.Muted, "NexusIntegrationDetail" + client.ElementKey);
-            detail.style.marginTop = 4;
-            card.Add(detail);
+            return titleRow;
+        }
 
-            var instruction = NexusEditorUi.Label(client.Instruction, 10, false, null, "NexusIntegrationInstruction" + client.ElementKey);
-            instruction.style.marginTop = 4;
-            card.Add(instruction);
+        private static void AddIntegrationDetails(VisualElement card, NexusMcpClientInfo client)
+        {
+            AddIntegrationLabel(card, client.StatusDetail, NexusEditorUi.Muted, "NexusIntegrationDetail" + client.ElementKey);
+            AddIntegrationLabel(card, client.Instruction, null, "NexusIntegrationInstruction" + client.ElementKey);
+            AddIntegrationLabel(card, "Config: " + client.ConfigPath, NexusEditorUi.Muted, "NexusIntegrationConfigPath" + client.ElementKey);
+        }
 
-            var path = NexusEditorUi.Label("Config: " + client.ConfigPath, 10, false, NexusEditorUi.Muted, "NexusIntegrationConfigPath" + client.ElementKey);
-            path.style.marginTop = 4;
-            card.Add(path);
+        private static void AddIntegrationLabel(VisualElement card, string text, Color? color, string name)
+        {
+            var label = NexusEditorUi.Label(text, 10, false, color, name);
+            label.style.marginTop = 4;
+            card.Add(label);
+        }
 
+        private VisualElement CreateIntegrationActions(NexusMcpClientInfo client)
+        {
             var actions = NexusEditorUi.Row(true, "NexusIntegrationActions" + client.ElementKey);
             var autoButton = NexusEditorUi.Button("Auto Setup", () => AutoSetupIntegration(client),
                 client.SupportsAutoSetup ? "Write the Nexus Unity MCP config for this client." : client.AutoSetupDisabledReason,
@@ -90,8 +107,7 @@ private VisualElement BuildIntegrationCard(NexusMcpClientInfo client)
             if (!canOpen) openButton.tooltip = "This integration is managed by CLI or manual copy/paste.";
             actions.Add(openButton);
 
-            card.Add(actions);
-            return card;
+            return actions;
         }
 
         private void AutoSetupIntegration(NexusMcpClientInfo client)
diff --git a/Editor/MCPServerWindow.Logs.cs b/Editor/MCPServerWindow.Logs.cs
index 0141d08..b5b3e31 100644
--- a/Editor/MCPServerWindow.Logs.cs
+++ b/Editor/MCPServerWindow.Logs.cs
@@ -17,7 +17,14 @@ private void DrawServerControl()
         {
             var section = NexusEditorUi.Section("Server", "Local HTTP bridge status and lifecycle controls.", "NexusServerSection");
             var panel = NexusEditorUi.Panel("NexusServerControl");
+            AddServerStatus(panel);
+            AddServerActions(panel);
+            section.Add(panel);
+            _content.Add(section);
+        }
 
+        private void AddServerStatus(VisualElement panel)
+        {
             var statusRow = NexusEditorUi.Row(true, "NexusServerStatusRow");
             _stateLabel = NexusEditorUi.Label("State: Unknown", 12, true, null, "NexusServerStateLabel");
             _stateLabel.style.marginRight = 12;
@@ -42,7 +49,10 @@ private void DrawServerControl()
             _errorLabel.style.marginTop = 4;
             _errorLabel.style.whiteSpace = WhiteSpace.Normal;
             panel.Add(_errorLabel);
+        }
 
+        private void AddServerActions(VisualElement panel)
+        {
             var actions = NexusEditorUi.Row(true, "NexusServerActions");
             _startButton = NexusEditorUi.Button("Start Server", () =>
             {
@@ -69,9 +79,6 @@ private void DrawServerControl()
             actions.Add(NexusEditorUi.Button("Copy URL", CopyServerUrl, "Copy the local server URL to clipboard", false, "NexusServerCopyUrlButton"));
             StretchActionButtons(actions, 84);
             panel.Add(actions);
-
-            section.Add(panel);
-            _content.Add(section);
         }
 
         private void DrawBridgeSummary()
diff --git a/Editor/NexusConsoleLogMode.cs b/Editor/NexusConsoleLogMode.cs
new file mode 100644
index 0000000..096bb08
--- /dev/null
+++ b/Editor/NexusConsoleLogMode.cs
@@ -0,0 +1,16 @@
+namespace UnityMCP.Editor
+{
+    /// <summary>
+    /// Controls which Nexus Unity service messages are forwarded to Unity's Console through UnityEngine.Debug.
+    /// </summary>
+    /// <remarks>
+    /// Important writes warnings/errors and explicitly important messages; All writes every Nexus service message;
+    /// Custom writes warnings/errors plus info messages whose categories are enabled in MCPSettings.EnabledLogCategories.
+    /// </remarks>
+    public enum NexusConsoleLogMode
+    {
+        Important = 0,
+        All = 1,
+        Custom = 2
+    }
+}
diff --git a/Editor/NexusConsoleLogMode.cs.meta b/Editor/NexusConsoleLogMode.cs.meta
new file mode 100644
index 0000000..9036582
--- /dev/null
+++ b/Editor/NexusConsoleLogMode.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d5dc1de462604649a9e1079361dfc6af
diff --git a/Editor/NexusEditorLog.cs b/Editor/NexusEditorLog.cs
index 91018a3..6f63812 100644
--- a/Editor/NexusEditorLog.cs
+++ b/Editor/NexusEditorLog.cs
@@ -1,44 +1,7 @@
-using System;
 using UnityEngine;
 
 namespace UnityMCP.Editor
 {
-    /// <summary>
-    /// Controls which Nexus Unity service messages are forwarded to Unity's Console through <see cref="Debug"/>.
-    /// </summary>
-    /// <remarks>
-    /// <c>Important</c> writes warnings/errors and explicitly important messages; <c>All</c> writes every Nexus service message;
-    /// <c>Custom</c> writes warnings/errors plus info messages whose categories are enabled in <see cref="MCPSettings.EnabledLogCategories"/>.
-    /// </remarks>
-    public enum NexusConsoleLogMode
-    {
-        Important = 0,
-        All = 1,
-        Custom = 2
-    }
-
-    /// <summary>
-    /// Groups Nexus Unity service logs by subsystem for custom Unity Console filtering.
-    /// </summary>
-    /// <remarks>
-    /// Categories correspond to server lifecycle, CLI integrations, JSON-RPC API calls, UI automation, diagnostics,
-    /// project audit output, and runtime log bridging. The <see cref="FlagsAttribute"/> allows multiple subsystems to
-    /// be enabled together in <see cref="MCPSettings.EnabledLogCategories"/>.
-    /// </remarks>
-    [Flags]
-    public enum NexusLogCategory
-    {
-        None = 0,
-        Server = 1 << 0,
-        Integrations = 1 << 1,
-        Api = 1 << 2,
-        UiAutomation = 1 << 3,
-        Diagnostics = 1 << 4,
-        Audit = 1 << 5,
-        Runtime = 1 << 6,
-        All = Server | Integrations | Api | UiAutomation | Diagnostics | Audit | Runtime
-    }
-
     internal static class NexusEditorLog
     {
         internal static bool ShouldWriteToConsole(NexusLogCategory category, bool important, LogType type)
diff --git a/Editor/NexusLogCategory.cs b/Editor/NexusLogCategory.cs
new file mode 100644
index 0000000..1c37637
--- /dev/null
+++ b/Editor/NexusLogCategory.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace UnityMCP.Editor
+{
+    /// <summary>
+    /// Groups Nexus Unity service logs by subsystem for custom Unity Console filtering.
+    /// </summary>
+    /// <remarks>
+    /// Categories correspond to server lifecycle, CLI integrations, JSON-RPC API calls, UI automation, diagnostics,
+    /// project audit output, and runtime log bridging. The FlagsAttribute allows multiple subsystems to
+    /// be enabled together in MCPSettings.EnabledLogCategories.
+    /// </remarks>
+    [Flags]
+    public enum NexusLogCategory
+    {
+        None = 0,
+        Server = 1 << 0,
+        Integrations = 1 << 1,
+        Api = 1 << 2,
+        UiAutomation = 1 << 3,
+        Diagnostics = 1 << 4,
+        Audit = 1 << 5,
+        Runtime = 1 << 6,
+        All = Server | Integrations | Api | UiAutomation | Diagnostics | Audit | Runtime
+    }
+}
diff --git a/Editor/NexusLogCategory.cs.meta b/Editor/NexusLogCategory.cs.meta
new file mode 100644
index 0000000..693cc14
--- /dev/null
+++ b/Editor/NexusLogCategory.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6e3e218838b44db9884906909c4e5ad8
diff --git a/Editor/NexusMcpClientEnums.cs b/Editor/NexusMcpClientEnums.cs
new file mode 100644
index 0000000..589c09b
--- /dev/null
+++ b/Editor/NexusMcpClientEnums.cs
@@ -0,0 +1,27 @@
+namespace UnityMCP.Editor
+{
+    internal enum NexusMcpClientKind
+    {
+        Codex,
+        ClaudeDesktop,
+        ClaudeCode,
+        Gemini,
+        Antigravity,
+        Cursor,
+        VsCode,
+        Cline,
+        RooCode,
+        Windsurf,
+        GenericJson
+    }
+
+    internal enum NexusMcpClientStatus
+    {
+        Detected,
+        NotFound,
+        Configured,
+        Outdated,
+        NeedsRestart,
+        Error
+    }
+}
diff --git a/Editor/NexusMcpClientEnums.cs.meta b/Editor/NexusMcpClientEnums.cs.meta
new file mode 100644
index 0000000..2e71028
--- /dev/null
+++ b/Editor/NexusMcpClientEnums.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cda68386bb5c44348245d42e82a01293
diff --git a/Editor/NexusMcpConfigFormat.cs b/Editor/NexusMcpConfigFormat.cs
new file mode 100644
index 0000000..ad36dc1
--- /dev/null
+++ b/Editor/NexusMcpConfigFormat.cs
@@ -0,0 +1,11 @@
+namespace UnityMCP.Editor
+{
+    internal enum NexusMcpConfigFormat
+    {
+        CodexToml,
+        JsonMcpServers,
+        JsonServers,
+        ManualOnly,
+        CliManaged
+    }
+}
diff --git a/Editor/NexusMcpConfigFormat.cs.meta b/Editor/NexusMcpConfigFormat.cs.meta
new file mode 100644
index 0000000..91018fb
--- /dev/null
+++ b/Editor/NexusMcpConfigFormat.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4d01a92f2d244a1b911bc4beeb66bc20
diff --git a/Editor/NexusMcpConfigGenerator.Clients.cs b/Editor/NexusMcpConfigGenerator.Clients.cs
new file mode 100644
index 0000000..d164b96
--- /dev/null
+++ b/Editor/NexusMcpConfigGenerator.Clients.cs
@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace UnityMCP.Editor
+{
+    internal static partial class NexusMcpConfigGenerator
+    {
+        internal readonly struct JsonClientDescriptor
+        {
+            internal readonly NexusMcpClientKind Kind;
+            internal readonly string Name;
+            internal readonly string Path;
+            internal readonly string Instruction;
+            internal readonly string RootKey;
+
+            internal JsonClientDescriptor(NexusMcpClientKind kind, string name, string path, string instruction, string rootKey)
+            {
+                Kind = kind;
+                Name = name;
+                Path = path;
+                Instruction = instruction;
+                RootKey = rootKey;
+            }
+        }
+
+        internal static List<NexusMcpClientInfo> BuildAll(string bridgePath, string pythonPath, string projectRoot, string homeDir, string sourceBridgePath = null)
+        {
+            string normBridge = NormalizePath(bridgePath);
+            string normSourceBridge = NormalizePath(sourceBridgePath);
+            string sourceVer = ReadBridgeVersion(normSourceBridge);
+            string deployedVer = ReadBridgeVersion(normBridge);
+
+            var clients = CreateCoreClients(normBridge, pythonPath, projectRoot, homeDir);
+            AppendJsonClients(clients, projectRoot, homeDir, normBridge, pythonPath);
+            clients.Add(CreateManual(normBridge, pythonPath));
+
+            foreach (var client in clients)
+            {
+                ApplyBridgeVersions(client, normSourceBridge, sourceVer, deployedVer);
+                ApplyDeploymentDriftStatus(client);
+            }
+
+            return clients;
+        }
+
+        internal readonly struct CliClientDescriptor
+        {
+            internal readonly NexusMcpClientKind Kind;
+            internal readonly string Name;
+            internal readonly string Command;
+            internal readonly string Instruction;
+
+            internal CliClientDescriptor(NexusMcpClientKind kind, string name, string command, string instruction)
+            {
+                Kind = kind;
+                Name = name;
+                Command = command;
+                Instruction = instruction;
+            }
+        }
+
+        private static List<NexusMcpClientInfo> CreateCoreClients(string bridgePath, string pythonPath, string projectRoot, string homeDir)
+        {
+            var geminiDesc = new CliClientDescriptor(NexusMcpClientKind.Gemini, "Gemini", "gemini",
+                "Run Auto Setup, then restart or reopen Gemini CLI sessions.");
+            var gemini = CreateCliClient(in geminiDesc, bridgePath, pythonPath);
+            gemini.CustomAutoSetup = MCPCliInstaller.LinkToGemini;
+
+            var claudeCode = CreateClaudeCode(projectRoot, bridgePath, pythonPath);
+            claudeCode.CustomAutoSetup = MCPCliInstaller.LinkToClaudeCode;
+
+            return new List<NexusMcpClientInfo>
+            {
+                CreateCodex(bridgePath, pythonPath, homeDir),
+                CreateClaude(bridgePath, pythonPath),
+                claudeCode,
+                gemini
+            };
+        }
+
+        private static void AppendJsonClients(List<NexusMcpClientInfo> clients, string projectRoot, string homeDir, string bridgePath, string pythonPath)
+        {
+            var descriptors = new[]
+            {
+                new JsonClientDescriptor(NexusMcpClientKind.Antigravity, "Antigravity", Path.Combine(projectRoot, ".agents", "mcp_config.json"),
+                    "Paste into .agents/mcp_config.json, then restart or reload Antigravity sessions.", "mcpServers"),
+                new JsonClientDescriptor(NexusMcpClientKind.Cursor, "Cursor", Path.Combine(projectRoot, ".cursor", "mcp.json"),
+                    "Paste into .cursor/mcp.json or use Auto Setup for this Unity project.", "mcpServers"),
+                new JsonClientDescriptor(NexusMcpClientKind.VsCode, "VS Code", Path.Combine(projectRoot, ".vscode", "mcp.json"),
+                    "Paste into .vscode/mcp.json, then restart VS Code's built-in MCP support.", "servers"),
+                new JsonClientDescriptor(NexusMcpClientKind.RooCode, "Roo Code", Path.Combine(projectRoot, ".roo", "mcp.json"),
+                    "Paste into .roo/mcp.json, then restart Roo Code.", "mcpServers"),
+                new JsonClientDescriptor(NexusMcpClientKind.Cline, "Cline", GetClineConfigPath(homeDir),
+                    "Paste into Cline's global MCP settings, then restart Cline.", "mcpServers"),
+                new JsonClientDescriptor(NexusMcpClientKind.Windsurf, "Windsurf", Path.Combine(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+                    "Paste into the Windsurf MCP config, then restart Windsurf.", "mcpServers"),
+            };
+
+            foreach (var desc in descriptors)
+            {
+                clients.Add(CreateJsonClient(desc, bridgePath, pythonPath));
+            }
+        }
+
+        private static NexusMcpClientInfo CreateCodex(string bridgePath, string pythonPath, string homeDir)
+        {
+            string path = Path.Combine(homeDir, ".codex", "config.toml");
+            var info = BaseInfo(NexusMcpClientKind.Codex, "Codex", bridgePath, pythonPath);
+            info.Format = NexusMcpConfigFormat.CodexToml;
+            info.ConfigPath = path;
+            info.ConfigText = BuildCodexToml(bridgePath, pythonPath);
+            info.Instruction = "Paste into ~/.codex/config.toml, then restart Codex CLI sessions.";
+            info.SupportsAutoSetup = true;
+            ApplyTomlStatus(info, "codex");
+            return info;
+        }
+
+        private static NexusMcpClientInfo CreateClaude(string bridgePath, string pythonPath)
+        {
+            string path = GetClaudeDesktopConfigPath();
+            var desc = new JsonClientDescriptor(NexusMcpClientKind.ClaudeDesktop, "Claude Desktop", path,
+                "Paste into claude_desktop_config.json, then restart Claude Desktop.", "mcpServers");
+            var info = CreateJsonClient(desc, bridgePath, pythonPath);
+            bool supportedPlatform = RuntimeInformation.IsOSPlatform(OSPlatform.OSX) || RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+            if (supportedPlatform)
+            {
+                info.SupportsAutoSetup = true;
+            }
+            else
+            {
+                info.SupportsAutoSetup = false;
+                info.AutoSetupDisabledReason = "Claude Desktop Auto Setup is only supported on macOS and Windows. Use Copy Config and paste it into Claude Desktop's settings manually.";
+            }
+            return info;
+        }
+
+        private static NexusMcpClientInfo CreateClaudeCode(string projectRoot, string bridgePath, string pythonPath)
+        {
+            string path = Path.Combine(projectRoot, ".mcp.json");
+            var desc = new JsonClientDescriptor(NexusMcpClientKind.ClaudeCode, "Claude Code", path,
+                "Writes .mcp.json in the project root (uses the claude CLI when available). Run /mcp or restart Claude Code afterwards.", "mcpServers");
+            return CreateJsonClient(desc, bridgePath, pythonPath);
+        }
+
+        private static NexusMcpClientInfo CreateJsonClient(in JsonClientDescriptor desc, string bridgePath, string pythonPath)
+        {
+            var info = BaseInfo(desc.Kind, desc.Name, bridgePath, pythonPath);
+            info.Format = desc.RootKey == "servers" ? NexusMcpConfigFormat.JsonServers : NexusMcpConfigFormat.JsonMcpServers;
+            info.ConfigPath = desc.Path;
+            info.RootKey = desc.RootKey;
+            info.Instruction = desc.Instruction;
+            info.ConfigText = BuildJsonConfig(desc.RootKey, bridgePath, pythonPath);
+            info.SupportsAutoSetup = true;
+            ApplyJsonStatus(info);
+            return info;
+        }
+
+        private static NexusMcpClientInfo CreateCliClient(in CliClientDescriptor desc, string bridgePath, string pythonPath)
+        {
+            var info = BaseInfo(desc.Kind, desc.Name, bridgePath, pythonPath);
+            info.Format = NexusMcpConfigFormat.CliManaged;
+            info.Instruction = desc.Instruction;
+            info.ConfigPath = "Managed by " + desc.Command + " CLI";
+            info.ConfigText = BuildJsonConfig("mcpServers", bridgePath, pythonPath);
+            bool found = IsExecutableResolved(desc.Command);
+            info.SupportsAutoSetup = found;
+            info.Status = found ? NexusMcpClientStatus.Detected : NexusMcpClientStatus.NotFound;
+            info.StatusDetail = found ? desc.Command + " CLI detected." : desc.Command + " CLI was not found on PATH.";
+            if (!found) info.AutoSetupDisabledReason = info.StatusDetail;
+            return info;
+        }
+
+        private static NexusMcpClientInfo CreateManual(string bridgePath, string pythonPath)
+        {
+            var info = BaseInfo(NexusMcpClientKind.GenericJson, "Generic MCP JSON", bridgePath, pythonPath);
+            info.Format = NexusMcpConfigFormat.ManualOnly;
+            info.Instruction = "Paste this JSON into any MCP client that accepts mcpServers.";
+            info.ConfigPath = "Manual setup";
+            info.ConfigText = BuildJsonConfig("mcpServers", bridgePath, pythonPath);
+            info.Status = NexusMcpClientStatus.Detected;
+            info.StatusDetail = "Manual config is always available.";
+            info.SupportsAutoSetup = false;
+            info.AutoSetupDisabledReason = "Generic MCP JSON is manual copy/paste only.";
+            return info;
+        }
+
+        private static NexusMcpClientInfo BaseInfo(NexusMcpClientKind kind, string name, string bridgePath, string pythonPath)
+        {
+            return new NexusMcpClientInfo
+            {
+                Kind = kind,
+                ElementKey = kind.ToString(),
+                DisplayName = name,
+                BridgePath = NormalizePath(bridgePath),
+                PythonPath = NormalizePath(pythonPath)
+            };
+        }
+    }
+}
diff --git a/Editor/NexusMcpConfigGenerator.Clients.cs.meta b/Editor/NexusMcpConfigGenerator.Clients.cs.meta
new file mode 100644
index 0000000..b2633cd
--- /dev/null
+++ b/Editor/NexusMcpConfigGenerator.Clients.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8002f328f00f461290ce815f0b808c01
diff --git a/Editor/NexusMcpConfigGenerator.Models.cs b/Editor/NexusMcpConfigGenerator.Models.cs
index c85bc2c..acf9219 100644
--- a/Editor/NexusMcpConfigGenerator.Models.cs
+++ b/Editor/NexusMcpConfigGenerator.Models.cs
@@ -2,40 +2,6 @@
 
 namespace UnityMCP.Editor
 {
-    internal enum NexusMcpClientKind
-    {
-        Codex,
-        ClaudeDesktop,
-        ClaudeCode,
-        Gemini,
-        Antigravity,
-        Cursor,
-        VsCode,
-        Cline,
-        RooCode,
-        Windsurf,
-        GenericJson
-    }
-
-    internal enum NexusMcpClientStatus
-    {
-        Detected,
-        NotFound,
-        Configured,
-        Outdated,
-        NeedsRestart,
-        Error
-    }
-
-    internal enum NexusMcpConfigFormat
-    {
-        CodexToml,
-        JsonMcpServers,
-        JsonServers,
-        ManualOnly,
-        CliManaged
-    }
-
     internal sealed class NexusMcpClientInfo
     {
         internal NexusMcpClientKind Kind { get; set; }
diff --git a/Editor/NexusMcpConfigGenerator.cs b/Editor/NexusMcpConfigGenerator.cs
index 349c39a..5ae55c1 100644
--- a/Editor/NexusMcpConfigGenerator.cs
+++ b/Editor/NexusMcpConfigGenerator.cs
@@ -19,64 +19,6 @@ internal static List<NexusMcpClientInfo> BuildAllForCurrentProject()
                 MCPCliInstaller.GetProjectRootForUi(), GetHomeDirectory(), MCPCliInstaller.GetSourceBridgePathForUi());
         }
 
-        internal static List<NexusMcpClientInfo> BuildAll(string bridgePath, string pythonPath, string projectRoot, string homeDir, string sourceBridgePath = null)
-        {
-            string normalizedBridgePath = NormalizePath(bridgePath);
-            string normalizedSourceBridgePath = NormalizePath(sourceBridgePath);
-            string sourceBridgeVersion = ReadBridgeVersion(normalizedSourceBridgePath);
-            string deployedBridgeVersion = ReadBridgeVersion(normalizedBridgePath);
-
-            var geminiClient = CreateCliClient(NexusMcpClientKind.Gemini, "Gemini", "gemini",
-                "Run Auto Setup, then restart or reopen Gemini CLI sessions.", normalizedBridgePath, pythonPath);
-            geminiClient.CustomAutoSetup = MCPCliInstaller.LinkToGemini;
-
-            var claudeCodeClient = CreateClaudeCode(projectRoot, normalizedBridgePath, pythonPath);
-            claudeCodeClient.CustomAutoSetup = MCPCliInstaller.LinkToClaudeCode;
-
-            var clients = new List<NexusMcpClientInfo>
-            {
-                CreateCodex(normalizedBridgePath, pythonPath, homeDir),
-                CreateClaude(normalizedBridgePath, pythonPath),
-                claudeCodeClient,
-                geminiClient
-            };
-
-            // Plain JSON-config clients - one row per tool, no client-specific behavior beyond path/format.
-            var jsonClients = new[]
-            {
-                (NexusMcpClientKind.Antigravity, "Antigravity", Path.Combine(projectRoot, ".agents", "mcp_config.json"),
-                    "Paste into .agents/mcp_config.json, then restart or reload Antigravity sessions.", "mcpServers"),
-                (NexusMcpClientKind.Cursor, "Cursor", Path.Combine(projectRoot, ".cursor", "mcp.json"),
-                    "Paste into .cursor/mcp.json or use Auto Setup for this Unity project.", "mcpServers"),
-                (NexusMcpClientKind.VsCode, "VS Code", Path.Combine(projectRoot, ".vscode", "mcp.json"),
-                    "Paste into .vscode/mcp.json, then restart VS Code's built-in MCP support.", "servers"),
-                (NexusMcpClientKind.RooCode, "Roo Code", Path.Combine(projectRoot, ".roo", "mcp.json"),
-                    "Paste into .roo/mcp.json, then restart Roo Code.", "mcpServers"),
-                (NexusMcpClientKind.Cline, "Cline", GetClineConfigPath(homeDir),
-                    "Paste into Cline's global MCP settings, then restart Cline.", "mcpServers"),
-                (NexusMcpClientKind.Windsurf, "Windsurf", Path.Combine(homeDir, ".codeium", "windsurf", "mcp_config.json"),
-                    "Paste into the Windsurf MCP config, then restart Windsurf.", "mcpServers"),
-            };
-            foreach (var (kind, name, path, instruction, rootKey) in jsonClients)
-            {
-                clients.Add(CreateJsonClient(kind, name, path, instruction, normalizedBridgePath, pythonPath, rootKey));
-            }
-
-            clients.Add(CreateManual(normalizedBridgePath, pythonPath));
-
-            foreach (var client in clients)
-            {
-                ApplyBridgeVersions(client, normalizedSourceBridgePath, sourceBridgeVersion, deployedBridgeVersion);
-            }
-
-            foreach (var client in clients)
-            {
-                ApplyDeploymentDriftStatus(client);
-            }
-
-            return clients;
-        }
-
         internal static NexusMcpSetupResult WriteConfig(NexusMcpClientInfo info)
         {
             if (info == null)
@@ -133,102 +75,6 @@ internal static string BackupFileIfExists(string path)
             return backup;
         }
 
-        private static NexusMcpClientInfo CreateCodex(string bridgePath, string pythonPath, string homeDir)
-        {
-            string path = Path.Combine(homeDir, ".codex", "config.toml");
-            var info = BaseInfo(NexusMcpClientKind.Codex, "Codex", bridgePath, pythonPath);
-            info.Format = NexusMcpConfigFormat.CodexToml;
-            info.ConfigPath = path;
-            info.ConfigText = BuildCodexToml(bridgePath, pythonPath);
-            info.Instruction = "Paste into ~/.codex/config.toml, then restart Codex CLI sessions.";
-            info.SupportsAutoSetup = true;
-            ApplyTomlStatus(info, "codex");
-            return info;
-        }
-
-        private static NexusMcpClientInfo CreateClaude(string bridgePath, string pythonPath)
-        {
-            string path = GetClaudeDesktopConfigPath();
-            var info = CreateJsonClient(NexusMcpClientKind.ClaudeDesktop, "Claude Desktop", path,
-                "Paste into claude_desktop_config.json, then restart Claude Desktop.", bridgePath, pythonPath, "mcpServers");
-            bool supportedPlatform = RuntimeInformation.IsOSPlatform(OSPlatform.OSX) || RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-            if (supportedPlatform)
-            {
-                info.SupportsAutoSetup = true;
-            }
-            else
-            {
-                info.SupportsAutoSetup = false;
-                info.AutoSetupDisabledReason = "Claude Desktop Auto Setup is only supported on macOS and Windows. Use Copy Config and paste it into Claude Desktop's settings manually.";
-            }
-            return info;
-        }
-
-        private static NexusMcpClientInfo CreateClaudeCode(string projectRoot, string bridgePath, string pythonPath)
-        {
-            string path = Path.Combine(projectRoot, ".mcp.json");
-            var info = CreateJsonClient(NexusMcpClientKind.ClaudeCode, "Claude Code", path,
-                "Writes .mcp.json in the project root (uses the claude CLI when available). Run /mcp or restart Claude Code afterwards.",
-                bridgePath, pythonPath, "mcpServers");
-            return info;
-        }
-
-        private static NexusMcpClientInfo CreateJsonClient(NexusMcpClientKind kind, string name, string path,
-            string instruction, string bridgePath, string pythonPath, string rootKey)
-        {
-            var info = BaseInfo(kind, name, bridgePath, pythonPath);
-            info.Format = rootKey == "servers" ? NexusMcpConfigFormat.JsonServers : NexusMcpConfigFormat.JsonMcpServers;
-            info.ConfigPath = path;
-            info.RootKey = rootKey;
-            info.Instruction = instruction;
-            info.ConfigText = BuildJsonConfig(rootKey, bridgePath, pythonPath);
-            info.SupportsAutoSetup = true;
-            ApplyJsonStatus(info);
-            return info;
-        }
-
-        private static NexusMcpClientInfo CreateCliClient(NexusMcpClientKind kind, string name, string command,
-            string instruction, string bridgePath, string pythonPath)
-        {
-            var info = BaseInfo(kind, name, bridgePath, pythonPath);
-            info.Format = NexusMcpConfigFormat.CliManaged;
-            info.Instruction = instruction;
-            info.ConfigPath = "Managed by " + command + " CLI";
-            info.ConfigText = BuildJsonConfig("mcpServers", bridgePath, pythonPath);
-            bool found = IsExecutableResolved(command);
-            info.SupportsAutoSetup = found;
-            info.Status = found ? NexusMcpClientStatus.Detected : NexusMcpClientStatus.NotFound;
-            info.StatusDetail = found ? command + " CLI detected." : command + " CLI was not found on PATH.";
-            if (!found) info.AutoSetupDisabledReason = info.StatusDetail;
-            return info;
-        }
-
-        private static NexusMcpClientInfo CreateManual(string bridgePath, string pythonPath)
-        {
-            var info = BaseInfo(NexusMcpClientKind.GenericJson, "Generic MCP JSON", bridgePath, pythonPath);
-            info.Format = NexusMcpConfigFormat.ManualOnly;
-            info.Instruction = "Paste this JSON into any MCP client that accepts mcpServers.";
-            info.ConfigPath = "Manual setup";
-            info.ConfigText = BuildJsonConfig("mcpServers", bridgePath, pythonPath);
-            info.Status = NexusMcpClientStatus.Detected;
-            info.StatusDetail = "Manual config is always available.";
-            info.SupportsAutoSetup = false;
-            info.AutoSetupDisabledReason = "Generic MCP JSON is manual copy/paste only.";
-            return info;
-        }
-
-        private static NexusMcpClientInfo BaseInfo(NexusMcpClientKind kind, string name, string bridgePath, string pythonPath)
-        {
-            return new NexusMcpClientInfo
-            {
-                Kind = kind,
-                ElementKey = kind.ToString(),
-                DisplayName = name,
-                BridgePath = NormalizePath(bridgePath),
-                PythonPath = NormalizePath(pythonPath)
-            };
-        }
-
         private static void ApplyTomlStatus(NexusMcpClientInfo info, string executable)
         {
             if (File.Exists(info.ConfigPath))
@@ -417,8 +263,6 @@ private static string GetHomeDirectory()
             return Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
         }
 
-        // Claude Desktop reads ~/Library/Application Support/Claude on macOS and %APPDATA%\Claude on Windows.
-        // SpecialFolder.ApplicationData maps to ~/.config (XDG) under Mono on macOS, so resolve macOS explicitly.
         private static string GetClaudeDesktopConfigPath()
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
@@ -429,8 +273,6 @@ private static string GetClaudeDesktopConfigPath()
             return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Claude", "claude_desktop_config.json");
         }
 
-        // Cline (VS Code extension saoudrizwan.claude-dev) stores MCP settings in VS Code's global storage,
-        // not in the workspace - same layout on macOS/Windows/Linux, rooted at the OS config dir for VS Code.
         private static string GetClineConfigPath(string homeDir)
         {
             return Path.Combine(homeDir, ".cline", "data", "settings", "cline_mcp_settings.json");
diff --git a/Editor/ProjectAuditorFinal.SceneHealth.cs b/Editor/ProjectAuditorFinal.SceneHealth.cs
new file mode 100644
index 0000000..5286b68
--- /dev/null
+++ b/Editor/ProjectAuditorFinal.SceneHealth.cs
@@ -0,0 +1,105 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class ProjectAuditorWrapper
+    {
+        private static readonly List<Renderer> _rendererCache = new List<Renderer>();
+        private static readonly List<Material> _materialCache = new List<Material>();
+        private static readonly Stack<string> _pathStackCache = new Stack<string>();
+
+        private static void ScanSceneHealth(JArray issues)
+        {
+            var allGOs = Resources.FindObjectsOfTypeAll<GameObject>()
+                .Where(go => (go.hideFlags & (HideFlags.HideInInspector | HideFlags.HideAndDontSave)) == 0);
+
+            foreach (var go in allGOs)
+            {
+                if (!go.scene.IsValid() || !go.scene.isLoaded) continue;
+                AddMissingScriptIssues(issues, go);
+                AddRendererIssues(issues, go);
+                AddBrokenPrefabIssue(issues, go);
+            }
+        }
+
+        private static void AddMissingScriptIssues(JArray issues, GameObject go)
+        {
+            int missingScripts = GameObjectUtility.GetMonoBehavioursWithMissingScriptCount(go);
+            for (int i = 0; i < missingScripts; i++)
+            {
+                issues.Add(new JObject {
+                    ["type"] = "MissingScript",
+                    ["object"] = go.name,
+                    ["path"] = GetGameObjectPath(go),
+                    ["description"] = "GameObject has a missing script reference."
+                });
+            }
+        }
+
+        private static void AddRendererIssues(JArray issues, GameObject go)
+        {
+            go.GetComponents<Renderer>(_rendererCache);
+            foreach (var renderer in _rendererCache)
+            {
+                renderer.GetSharedMaterials(_materialCache);
+                foreach (var material in _materialCache)
+                    AddMaterialIssue(issues, go, material);
+            }
+        }
+
+        private static void AddMaterialIssue(JArray issues, GameObject go, Material material)
+        {
+            if (material == null)
+            {
+                issues.Add(new JObject {
+                    ["type"] = "MissingMaterial",
+                    ["object"] = go.name,
+                    ["path"] = GetGameObjectPath(go),
+                    ["description"] = "Renderer has a null material entry."
+                });
+                return;
+            }
+
+            if (material.shader != null && material.shader.name == "Hidden/InternalErrorShader")
+            {
+                issues.Add(new JObject {
+                    ["type"] = "PinkMaterial",
+                    ["object"] = go.name,
+                    ["path"] = GetGameObjectPath(go),
+                    ["description"] = "Material is using the error shader (Pink)."
+                });
+            }
+        }
+
+        private static void AddBrokenPrefabIssue(JArray issues, GameObject go)
+        {
+            if (!PrefabUtility.IsPartOfPrefabInstance(go) ||
+                PrefabUtility.GetPrefabInstanceStatus(go) != PrefabInstanceStatus.MissingAsset)
+                return;
+
+            issues.Add(new JObject {
+                ["type"] = "BrokenPrefab",
+                ["object"] = go.name,
+                ["path"] = GetGameObjectPath(go),
+                ["description"] = "Prefab instance is missing its source asset."
+            });
+        }
+
+        private static string GetGameObjectPath(GameObject obj)
+        {
+            _pathStackCache.Clear();
+            _pathStackCache.Push(obj.name);
+            var current = obj.transform;
+            while (current.parent != null)
+            {
+                current = current.parent;
+                _pathStackCache.Push(current.name);
+            }
+            return string.Join("/", _pathStackCache);
+        }
+    }
+}
diff --git a/Editor/ProjectAuditorFinal.SceneHealth.cs.meta b/Editor/ProjectAuditorFinal.SceneHealth.cs.meta
new file mode 100644
index 0000000..c451f81
--- /dev/null
+++ b/Editor/ProjectAuditorFinal.SceneHealth.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6b4fc92e4f70434a8d9df4ce4b6a7e21
diff --git a/Editor/ProjectAuditorFinal.cs b/Editor/ProjectAuditorFinal.cs
index 486c6c9..f8347fd 100644
--- a/Editor/ProjectAuditorFinal.cs
+++ b/Editor/ProjectAuditorFinal.cs
@@ -15,14 +15,16 @@ namespace UnityMCP.Editor
     /// Audit execution dynamically locates ProjectAuditor assemblies, filters issues for the package or user project,
     /// scans active scene objects for missing scripts/materials, writes Nexus audit logs, and returns a JSON report.
     /// </remarks>
-    public static class ProjectAuditorWrapper
+    public static partial class ProjectAuditorWrapper
     {
         private const string ProjectAuditorRulesPackageName = "com.unity.project-auditor-rules";
 
-        private static readonly List<Component> _componentCache = new List<Component>();
-        private static readonly List<Renderer> _rendererCache = new List<Renderer>();
-        private static readonly List<Material> _materialCache = new List<Material>();
-        private static readonly Stack<string> _pathStackCache = new Stack<string>();
+        private sealed class AuditorScope
+        {
+            internal bool IsSandbox;
+            internal string TargetPath;
+            internal string[] IgnorePatterns;
+        }
 
         /// <summary>
         /// Runs the full audit from a Unity menu context and writes the JSON report to the Nexus audit log channel.
@@ -135,17 +137,22 @@ private static JArray CollectProjectAuditorIssues(System.Collections.IEnumerable
                 return codeIssues;
             }
 
-            string[] sandboxIgnorePatterns = { "Newtonsoft.Json", "allocation", "usage", "System.Reflection", "System.Linq", "System.String.Concat", "ref type", "Closure", "UnityEngine.Object.name", "Debug.Log", "Implicit", "GetEntityId" };
+            var scope = new AuditorScope
+            {
+                IsSandbox = isSandbox,
+                TargetPath = targetPath,
+                IgnorePatterns = new[] { "Newtonsoft.Json", "allocation", "usage", "System.Reflection", "System.Linq", "System.String.Concat", "ref type", "Closure", "UnityEngine.Object.name", "Debug.Log", "Implicit", "GetEntityId" }
+            };
 
             foreach (var issue in allIssues)
             {
-                AddProjectAuditorIssue(codeIssues, issue, isSandbox, targetPath, sandboxIgnorePatterns);
+                AddProjectAuditorIssue(codeIssues, issue, scope);
             }
 
             return codeIssues;
         }
 
-        private static void AddProjectAuditorIssue(JArray codeIssues, object issue, bool isSandbox, string targetPath, string[] sandboxIgnorePatterns)
+        private static void AddProjectAuditorIssue(JArray codeIssues, object issue, AuditorScope scope)
         {
             var t = issue.GetType();
             string category = t.GetProperty("Category")?.GetValue(issue)?.ToString() ?? "Unknown";
@@ -153,7 +160,7 @@ private static void AddProjectAuditorIssue(JArray codeIssues, object issue, bool
             var location = t.GetProperty("Location")?.GetValue(issue);
             string filePath = GetAuditorIssuePath(location);
 
-            if (ShouldSkipAuditorIssue(category, description, filePath, isSandbox, targetPath, sandboxIgnorePatterns))
+            if (ShouldSkipAuditorIssue(category, description, filePath, scope))
             {
                 return;
             }
@@ -173,19 +180,19 @@ private static string GetAuditorIssuePath(object location)
             return location?.GetType().GetProperty("Path")?.GetValue(location)?.ToString() ?? "";
         }
 
-        private static bool ShouldSkipAuditorIssue(string category, string description, string filePath, bool isSandbox, string targetPath, string[] sandboxIgnorePatterns)
+        private static bool ShouldSkipAuditorIssue(string category, string description, string filePath, AuditorScope scope)
         {
             if (category.Contains("Code"))
             {
-                if (string.IsNullOrEmpty(filePath) || !filePath.StartsWith(targetPath))
+                if (string.IsNullOrEmpty(filePath) || !filePath.StartsWith(scope.TargetPath))
                 {
                     return true;
                 }
 
-                return isSandbox && sandboxIgnorePatterns.Any(pattern => description.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0);
+                return scope.IsSandbox && scope.IgnorePatterns.Any(pattern => description.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0);
             }
 
-            return isSandbox && (string.IsNullOrEmpty(filePath) || (!filePath.Contains("com.forkhorizon.nexus.unity") && !filePath.Contains("Assets/NexusUnity")));
+            return scope.IsSandbox && (string.IsNullOrEmpty(filePath) || (!filePath.Contains("com.forkhorizon.nexus.unity") && !filePath.Contains("Assets/NexusUnity")));
         }
 
         private static void RunNexusStyleAudit(JObject result)
@@ -216,81 +223,5 @@ private static void RunNexusStyleAudit(JObject result)
             NexusEditorLog.Log(NexusLogCategory.Audit, $"[Nexus Style Audit] Added {styleIssuesAdded} style issues. Total: {codeIssuesList.Count}", true);
         }
 
-        private static void ScanSceneHealth(JArray issues)
-        {
-            var allGOs = Resources.FindObjectsOfTypeAll<GameObject>()
-                .Where(go => (go.hideFlags & (HideFlags.HideInInspector | HideFlags.HideAndDontSave)) == 0);
-
-            foreach (var go in allGOs)
-            {
-                // In Unity 6, go.scene is a struct. Check for validity and if it's loaded to only scan active scene objects.
-                if (!go.scene.IsValid() || !go.scene.isLoaded) continue;
-
-                int missingScripts = GameObjectUtility.GetMonoBehavioursWithMissingScriptCount(go);
-                for (int i = 0; i < missingScripts; i++)
-                {
-                    issues.Add(new JObject {
-                        ["type"] = "MissingScript",
-                        ["object"] = go.name,
-                        ["path"] = GetGameObjectPath(go),
-                        ["description"] = "GameObject has a missing script reference."
-                    });
-                }
-
-                go.GetComponents<Renderer>(_rendererCache);
-                foreach (var renderer in _rendererCache)
-                {
-                    renderer.GetSharedMaterials(_materialCache);
-                    foreach (var mat in _materialCache)
-                    {
-                        if (mat == null)
-                        {
-                            issues.Add(new JObject {
-                                ["type"] = "MissingMaterial",
-                                ["object"] = go.name,
-                                ["path"] = GetGameObjectPath(go),
-                                ["description"] = "Renderer has a null material entry."
-                            });
-                        }
-                        else if (mat.shader != null && mat.shader.name == "Hidden/InternalErrorShader")
-                        {
-                            issues.Add(new JObject {
-                                ["type"] = "PinkMaterial",
-                                ["object"] = go.name,
-                                ["path"] = GetGameObjectPath(go),
-                                ["description"] = "Material is using the error shader (Pink)."
-                            });
-                        }
-                    }
-                }
-
-                if (PrefabUtility.IsPartOfPrefabInstance(go))
-                {
-                    var status = PrefabUtility.GetPrefabInstanceStatus(go);
-                    if (status == PrefabInstanceStatus.MissingAsset)
-                    {
-                        issues.Add(new JObject {
-                            ["type"] = "BrokenPrefab",
-                            ["object"] = go.name,
-                            ["path"] = GetGameObjectPath(go),
-                            ["description"] = "Prefab instance is missing its source asset."
-                        });
-                    }
-                }
-            }
-        }
-
-        private static string GetGameObjectPath(GameObject obj)
-        {
-            _pathStackCache.Clear();
-            _pathStackCache.Push(obj.name);
-            var current = obj.transform;
-            while (current.parent != null)
-            {
-                current = current.parent;
-                _pathStackCache.Push(current.name);
-            }
-            return string.Join("/", _pathStackCache);
-        }
     }
 }
diff --git a/Editor/SymbolInfo.cs b/Editor/SymbolInfo.cs
new file mode 100644
index 0000000..ba559d0
--- /dev/null
+++ b/Editor/SymbolInfo.cs
@@ -0,0 +1,30 @@
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        /// <summary>
+        /// Identifies the kind of reflected C# symbol returned by the Unity editor symbol index.
+        /// </summary>
+        /// <remarks>
+        /// Class entries describe compiled types, Method entries describe invocable members exposed for editor inspection,
+        /// and Field entries describe reflected fields discovered while scanning Unity assemblies and project scripts.
+        /// </remarks>
+        public enum SymbolType { Class, Method, Field }
+
+        /// <summary>
+        /// Carries reflected C# symbol metadata used by Nexus Unity search and method invocation tools.
+        /// </summary>
+        /// <remarks>
+        /// Values are populated from Unity's loaded assemblies on a background indexing task. Metadata stores serialized
+        /// reflection details used by editor search results and JSON-RPC method invocation.
+        /// </remarks>
+        public struct SymbolInfo
+        {
+            public string Name;
+            public string Namespace;
+            public string DeclaringType;
+            public SymbolType Type;
+            public string Metadata;
+        }
+    }
+}
diff --git a/Editor/SymbolInfo.cs.meta b/Editor/SymbolInfo.cs.meta
new file mode 100644
index 0000000..ef0000e
--- /dev/null
+++ b/Editor/SymbolInfo.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7abda757a7fb4dbcb88841e15e022e89
diff --git a/Editor/nexus_bridge/_transport.py b/Editor/nexus_bridge/_transport.py
index ee76f0d..d2331cb 100644
--- a/Editor/nexus_bridge/_transport.py
+++ b/Editor/nexus_bridge/_transport.py
@@ -53,19 +53,26 @@ def _read_timeout() -> float:
 UNITY_TIMEOUT_SECONDS: float = _read_timeout()
 
 
+def _try_read_token(candidate: str) -> str | None:
+    if not os.path.isfile(candidate):
+        return None
+    try:
+        with open(candidate, encoding="utf-8") as handle:
+            val = handle.read().strip()
+            return val or None
+    except Exception:
+        return None
+
+
 def _read_token_file() -> str | None:
-    for candidate in (
+    candidates = (
         os.path.join(os.getcwd(), "Library", "NexusUnityAuthToken.txt"),
         os.path.join(os.getcwd(), "..", "..", "Library", "NexusUnityAuthToken.txt"),
-    ):
-        if os.path.isfile(candidate):
-            try:
-                with open(candidate, encoding="utf-8") as handle:
-                    val = handle.read().strip()
-                    if val:
-                        return val
-            except Exception:
-                pass
+    )
+    for candidate in candidates:
+        token = _try_read_token(candidate)
+        if token:
+            return token
     return None
 
 
diff --git a/Editor/nexus_bridge/routes_base.py b/Editor/nexus_bridge/routes_base.py
new file mode 100644
index 0000000..a93f772
--- /dev/null
+++ b/Editor/nexus_bridge/routes_base.py
@@ -0,0 +1,78 @@
+"""Routing base helpers and types for NexusUnity Python bridge."""
+
+from __future__ import annotations
+
+from typing import Any
+from collections.abc import Mapping, Sequence
+
+from . import _transport
+
+JsonObject = dict[str, Any]
+JsonRpcResponse = dict[str, Any]
+
+
+def _compact(params: JsonObject) -> JsonObject:
+    return {key: value for key, value in params.items() if value is not None}
+
+
+def _first_present(*values: Any) -> Any:
+    for value in values:
+        if value is not None:
+            return value
+    return None
+
+
+def _alias(action_name: str | None, aliases: Mapping[str, str]) -> str | None:
+    if action_name is None:
+        return None
+    return aliases.get(action_name, action_name)
+
+
+def _invalid_action(action_name: str | None, valid_actions: Sequence[str]) -> JsonRpcResponse:
+    valid = ", ".join(valid_actions)
+    error_payload = {
+        "code": -32602,
+        "message": f"Invalid action: {action_name}. Valid actions: {valid}",
+    }
+    return {"error": error_payload}
+
+
+def _result_object(response: JsonRpcResponse | None) -> JsonObject:
+    if not response:
+        return {}
+    result_payload = response.get("result")
+    return result_payload if isinstance(result_payload, dict) else {}
+
+
+def _error_object(response: JsonRpcResponse | None) -> JsonObject | None:
+    if not response:
+        return None
+    return response.get("error")
+
+
+def _transform_params(args: JsonObject, instance_id: int | None = None) -> JsonObject:
+    params: JsonObject = {"instance_id": instance_id if instance_id is not None else args.get("instance_id")}
+    for key in ["position", "rotation", "scale", "eulerAngles", "localScale"]:
+        params[key] = args.get(key)
+    return _compact(params)
+
+
+def _extract_created_instance_id(response: JsonRpcResponse) -> int | None:
+    if "error" in response:
+        return None
+    result_payload = _result_object(response)
+    data = result_payload.get("data", {})
+    return data.get("instance_id") if isinstance(data, dict) else None
+
+
+def _apply_created_transform(response: JsonRpcResponse, args: JsonObject) -> JsonRpcResponse:
+    instance_id = _extract_created_instance_id(response)
+    if instance_id is None:
+        return response
+    params = _transform_params(args, instance_id)
+    if len(params) <= 1:
+        return response
+    transform_response = _transport.call_unity("set_transform", params)
+    if transform_response and "error" in transform_response:
+        return transform_response
+    return response
diff --git a/Editor/tests/test_schemas.py.meta b/Editor/nexus_bridge/routes_base.py.meta
similarity index 74%
rename from Editor/tests/test_schemas.py.meta
rename to Editor/nexus_bridge/routes_base.py.meta
index 910a12a..194b0e7 100644
--- a/Editor/tests/test_schemas.py.meta
+++ b/Editor/nexus_bridge/routes_base.py.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 9046bb8bd125460690905034f6644fcf
+guid: 7539e4c40e5de427297b8ddf645d3023
 DefaultImporter:
   externalObjects: {}
   userData: 
diff --git a/Editor/nexus_bridge/routes_editor.py b/Editor/nexus_bridge/routes_editor.py
new file mode 100644
index 0000000..932ce79
--- /dev/null
+++ b/Editor/nexus_bridge/routes_editor.py
@@ -0,0 +1,272 @@
+"""Editor controller, execution, and utility routing for NexusUnity."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from . import _transport
+from .routes_base import (
+    JsonObject,
+    JsonRpcResponse,
+    _compact,
+    _error_object,
+    _invalid_action,
+    _result_object,
+)
+from .schemas import STATIC_TOOLS
+
+
+def _poll_test_results(
+    start_time: float, timeout: float, poll_interval: float, prev_time: str | None, result_path: str | None
+) -> JsonRpcResponse | None:
+    while time.time() - start_time < timeout:
+        params = {"result_path": result_path} if result_path else {}
+        current_resp = _transport.call_unity("get_test_results", params)
+        if current_resp and "error" in current_resp:
+            return current_resp
+
+        payload = _result_object(current_resp)
+        if payload.get("status") == "Success" and payload.get("timestamp_utc") != prev_time:
+            test_results = dict(payload)
+            test_results["time_waited_seconds"] = round(time.time() - start_time, 2)
+            return {"result": test_results}
+
+        time.sleep(poll_interval)
+    return None
+
+
+def _run_tests_wait(args: JsonObject) -> JsonRpcResponse:
+    timeout = args.get("timeout_seconds", 180)
+    poll_interval = args.get("poll_interval_seconds", 1.0)
+    start_time = time.time()
+
+    prev_resp = _transport.call_unity("get_test_results")
+    prev_payload = _result_object(prev_resp)
+    prev_time = prev_payload.get("timestamp_utc") if prev_payload.get("status") == "Success" else None
+
+    run_params = _compact({"mode": args.get("mode", "EditMode"), "filter": args.get("filter")})
+    trigger_resp = _transport.call_unity("run_tests", run_params)
+    if trigger_resp and "error" in trigger_resp:
+        return trigger_resp
+
+    trigger_payload = _result_object(trigger_resp)
+    if trigger_payload.get("status") not in ("Submitted", "Success"):
+        return {"result": trigger_payload}
+
+    result_path = trigger_payload.get("result_path")
+    polled = _poll_test_results(start_time, timeout, poll_interval, prev_time, result_path)
+    if polled is not None:
+        return polled
+
+    timeout_result = {
+        "status": "Timeout",
+        "message": "Timed out waiting for a new Unity TestResults XML file.",
+        "time_waited_seconds": round(time.time() - start_time, 2),
+        "trigger": trigger_payload,
+    }
+    if isinstance(result_path, str):
+        timeout_result["result_path"] = result_path
+    return {"result": timeout_result}
+
+
+def _wait_for_compilation(timeout: float, start_time: float | None = None) -> JsonRpcResponse:
+    start_time = time.time() if start_time is None else start_time
+    status: str = "Ready"
+
+    reload_started: bool = False
+    reload_wait_timeout = min(20.0, timeout)
+    while time.time() - start_time < reload_wait_timeout:
+        init_resp = _transport.call_unity("initialize")
+        if init_resp is None or "error" in init_resp:
+            reload_started = True
+            break
+        time.sleep(0.5)
+
+    if not reload_started:
+        _transport.call_unity("refresh_asset_database")
+
+    while time.time() - start_time < timeout:
+        init_resp = _transport.call_unity("initialize")
+        if init_resp and "result" in init_resp:
+            time.sleep(2.0)
+            state_resp = _transport.call_unity("get_editor_state")
+            state = _result_object(state_resp)
+            if state_resp and "result" in state_resp and not state.get("is_compiling") and not state.get("is_updating"):
+                break
+        time.sleep(1.0)
+    else:
+        status = "Timeout"
+
+    return {"result": {"status": status, "time_waited_seconds": round(time.time() - start_time, 2)}}
+
+
+def _route_list_tools(_: JsonObject) -> JsonRpcResponse:
+    return {"result": {"tools": STATIC_TOOLS}}
+
+
+def _route_write_and_compile(args: JsonObject) -> JsonRpcResponse:
+    files = args.get("files", [])
+    confirm = args.get("confirm", True)
+    start_time: float = time.time()
+    _transport.call_unity("clear_logs")
+
+    write_errors: list[JsonObject] = []
+    for file_info in files:
+        write_resp = _transport.call_unity(
+            "write_file",
+            _compact({"path": file_info["path"], "content": file_info["content"], "confirm": confirm}),
+        )
+        write_error = _error_object(write_resp)
+        if write_error is not None:
+            write_errors.append({"path": file_info["path"], "error": write_error})
+
+    if write_errors:
+        return {"result": {"status": "Failed", "message": "Failed to write some files", "errors": write_errors}}
+
+    wait_resp = _wait_for_compilation(timeout=90, start_time=start_time)
+    wait_result = _result_object(wait_resp)
+    wait_status: str = wait_result["status"]
+    time_waited: float = wait_result["time_waited_seconds"]
+
+    compiler_errors: list[JsonObject] = []
+    if wait_status == "Ready":
+        log_resp = _transport.call_unity("read_logs", {"count": 200})
+        log_payload = _result_object(log_resp)
+        if log_resp and "result" in log_resp:
+            for log_entry in log_payload.get("logs", []):
+                entry_type = str(log_entry.get("Type", log_entry.get("type", ""))).lower()
+                if entry_type in ["error", "exception", "assert"]:
+                    compiler_errors.append(log_entry)
+
+    return {
+        "result": {
+            "status": "Failed" if compiler_errors else wait_status,
+            "time_waited_seconds": time_waited,
+            "compiler_errors": compiler_errors,
+        }
+    }
+
+
+def _dispatch_editor_action(action: str | None, args: JsonObject) -> JsonRpcResponse | None:
+    if action == "undo":
+        return _transport.call_unity("undo")
+    if action == "redo":
+        return _transport.call_unity("redo")
+    if action == "play":
+        return _transport.call_unity("toggle_play_mode", {"value": args.get("state")})
+    if action == "pause":
+        return _transport.call_unity("pause_play_mode", {"value": args.get("state")})
+    if action == "step":
+        return _transport.call_unity("step_frame")
+    if action == "menu":
+        return _transport.call_unity("execute_menu_item", {"item_path": args.get("item_path")})
+    if action == "read_logs":
+        return _transport.call_unity("read_logs", {"count": args.get("count", 100)})
+    if action == "clear_logs":
+        return _transport.call_unity("clear_logs")
+    if action == "get_state":
+        return _transport.call_unity("get_editor_state")
+    if action == "get_server_status":
+        return _transport.call_unity("get_server_status")
+    if action == "refresh_assets":
+        return _transport.call_unity("refresh_asset_database")
+    if action == "run_tests":
+        return _transport.call_unity(
+            "run_tests", _compact({"mode": args.get("mode", "EditMode"), "filter": args.get("filter")})
+        )
+    if action == "get_test_results":
+        return _transport.call_unity("get_test_results", _compact({"result_path": args.get("result_path")}))
+    if action == "run_tests_wait":
+        return _run_tests_wait(args)
+    if action == "get_tool_usage_stats":
+        return _transport.call_unity("get_tool_usage_stats")
+    if action == "reset_tool_usage_stats":
+        return _transport.call_unity("reset_tool_usage_stats")
+    return None
+
+
+def _route_editor_controller(args: JsonObject) -> JsonRpcResponse:
+    action = args.get("action")
+    result = _dispatch_editor_action(action, args)
+    if result is not None:
+        return result
+    return _invalid_action(
+        action,
+        [
+            "undo",
+            "redo",
+            "play",
+            "pause",
+            "step",
+            "menu",
+            "read_logs",
+            "clear_logs",
+            "get_state",
+            "get_server_status",
+            "refresh_assets",
+            "run_tests",
+            "get_test_results",
+            "run_tests_wait",
+            "get_tool_usage_stats",
+            "reset_tool_usage_stats",
+        ],
+    )
+
+
+def _is_condition_ready(condition: str, target_state: bool) -> bool:
+    if condition == "play_mode":
+        resp = _transport.call_unity("get_editor_state")
+        state = _result_object(resp)
+        return bool(resp and "result" in resp and state.get("is_playing") == target_state)
+    if condition == "import":
+        resp = _transport.call_unity("is_asset_import_idle")
+        state = _result_object(resp)
+        return bool(resp and "result" in resp and state.get("is_idle"))
+    if condition == "editor_idle":
+        resp = _transport.call_unity("is_editor_idle")
+        state = _result_object(resp)
+        return bool(resp and "result" in resp and state.get("is_idle"))
+    return False
+
+
+def _wait_for_condition_loop(condition: str, timeout: float, start_time: float, target_state: bool) -> str:
+    while time.time() - start_time < timeout:
+        if _is_condition_ready(condition, target_state):
+            return "Ready"
+        time.sleep(1.0)
+    return "Timeout"
+
+
+def _route_wait(args: JsonObject) -> JsonRpcResponse:
+    condition: Any = args.get("condition")
+    timeout: float = args.get("timeout_seconds", 60)
+    start_time: float = time.time()
+
+    if condition == "compilation":
+        return _wait_for_compilation(timeout=timeout, start_time=start_time)
+    if condition in ("play_mode", "import", "editor_idle"):
+        target_state = args.get("state", True)
+        status = _wait_for_condition_loop(condition, timeout, start_time, target_state)
+        return {"result": {"status": status, "time_waited_seconds": round(time.time() - start_time, 2)}}
+    return _invalid_action(condition, ["compilation", "play_mode", "import", "editor_idle"])
+
+
+def _route_playerprefs_manager(args: JsonObject) -> JsonRpcResponse:
+    action = args.get("action")
+    if action == "get":
+        return _transport.call_unity(
+            "get_player_pref", _compact({"key": args.get("key"), "type": args.get("type", "string")})
+        )
+    if action == "set":
+        return _transport.call_unity(
+            "set_player_pref",
+            _compact({"key": args.get("key"), "value": args.get("value"), "type": args.get("type", "string")}),
+        )
+    if action == "delete":
+        return _transport.call_unity(
+            "delete_player_pref", _compact({"key": args.get("key"), "confirm": args.get("confirm")})
+        )
+    if action == "list":
+        return _transport.call_unity("list_player_prefs")
+    return _invalid_action(action, ["get", "set", "delete", "list"])
diff --git a/Editor/tests/test_transport.py.meta b/Editor/nexus_bridge/routes_editor.py.meta
similarity index 74%
rename from Editor/tests/test_transport.py.meta
rename to Editor/nexus_bridge/routes_editor.py.meta
index c7f8bab..c0da8ed 100644
--- a/Editor/tests/test_transport.py.meta
+++ b/Editor/nexus_bridge/routes_editor.py.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 8a2b2ea69da94bffad2722e0436f81d8
+guid: 0c7be7ae32b2a4d2ca7596f67ce621d1
 DefaultImporter:
   externalObjects: {}
   userData: 
diff --git a/Editor/nexus_bridge/routes_managers.py b/Editor/nexus_bridge/routes_managers.py
new file mode 100644
index 0000000..3bfc499
--- /dev/null
+++ b/Editor/nexus_bridge/routes_managers.py
@@ -0,0 +1,253 @@
+"""Manager routing (scene, hierarchy, component, search, asset) for NexusUnity."""
+
+from __future__ import annotations
+
+from . import _transport
+from .routes_base import (
+    JsonObject,
+    JsonRpcResponse,
+    _alias,
+    _apply_created_transform,
+    _compact,
+    _invalid_action,
+    _transform_params,
+)
+
+
+def _route_scene_manager(args: JsonObject) -> JsonRpcResponse:
+    aliases = {"create_scene": "create", "open_scene": "open", "save_scene": "save", "list_scenes": "list"}
+    action = _alias(args.get("action"), aliases)
+    if action == "create":
+        return _transport.call_unity(
+            "create_scene",
+            _compact(
+                {"name": args.get("name"), "path": args.get("path"), "open_if_exists": args.get("open_if_exists")}
+            ),
+        )
+    if action == "open":
+        return _transport.call_unity("open_scene", {"path": args.get("path")})
+    if action == "save":
+        return _transport.call_unity("save_scene", {"path": args.get("path")})
+    if action == "list":
+        return _transport.call_unity("list_scenes")
+    return _invalid_action(
+        args.get("action"),
+        ["create", "create_scene", "open", "open_scene", "save", "save_scene", "list", "list_scenes"],
+    )
+
+
+def _dispatch_hierarchy_create(action: str | None, args: JsonObject) -> JsonRpcResponse | None:
+    if action == "create_empty":
+        response = _transport.call_unity(
+            "create_game_object", _compact({"name": args.get("name"), "parent_id": args.get("parent_id")})
+        )
+        return _apply_created_transform(response, args)
+    if action == "create_primitive":
+        return _transport.call_unity(
+            "create_primitive",
+            _compact(
+                {
+                    "primitive_type": args.get("primitive_type"),
+                    "name": args.get("name"),
+                    "parent_id": args.get("parent_id"),
+                    "position": args.get("position"),
+                    "rotation": args.get("rotation"),
+                    "scale": args.get("scale"),
+                    "material_path": args.get("material_path"),
+                }
+            ),
+        )
+    if action == "create_hierarchy":
+        return _transport.call_unity(
+            "create_hierarchy", _compact({"tree": args.get("tree"), "parent_id": args.get("parent_id")})
+        )
+    return None
+
+
+def _dispatch_hierarchy_modify(action: str | None, args: JsonObject) -> JsonRpcResponse | None:
+    if action == "set_name":
+        return _transport.call_unity(
+            "set_property",
+            {
+                "instance_id": args.get("instance_id"),
+                "property_name": "m_Name",
+                "value": args.get("name") or args.get("new_name"),
+            },
+        )
+    if action == "set_transform":
+        return _transport.call_unity("set_transform", _transform_params(args))
+    if action == "destroy":
+        return _transport.call_unity("destroy_game_object", {"instance_id": args.get("instance_id")})
+    if action == "duplicate":
+        return _transport.call_unity("duplicate_object", {"instance_id": args.get("instance_id")})
+    if action == "set_active":
+        return _transport.call_unity(
+            "set_active", {"instance_id": args.get("instance_id"), "active": args.get("active")}
+        )
+    if action == "set_parent":
+        return _transport.call_unity(
+            "set_parent", {"instance_id": args.get("instance_id"), "parent_id": args.get("parent_id")}
+        )
+    if action == "set_sibling_index":
+        return _transport.call_unity(
+            "set_sibling_index", {"instance_id": args.get("instance_id"), "index": args.get("index")}
+        )
+    return None
+
+
+def _route_hierarchy_manager(args: JsonObject) -> JsonRpcResponse:
+    aliases = {
+        "create": "create_empty",
+        "create_gameobject": "create_empty",
+        "create_game_object": "create_empty",
+        "rename": "set_name",
+        "transform": "set_transform",
+    }
+    action = _alias(args.get("action"), aliases)
+    created = _dispatch_hierarchy_create(action, args)
+    if created is not None:
+        return created
+    modified = _dispatch_hierarchy_modify(action, args)
+    if modified is not None:
+        return modified
+    return _invalid_action(
+        args.get("action"),
+        [
+            "create_empty",
+            "create",
+            "create_gameobject",
+            "create_game_object",
+            "create_primitive",
+            "create_hierarchy",
+            "destroy",
+            "duplicate",
+            "rename",
+            "set_name",
+            "set_transform",
+            "set_active",
+            "set_parent",
+            "set_sibling_index",
+        ],
+    )
+
+
+def _route_component_manager(args: JsonObject) -> JsonRpcResponse:
+    action = args.get("action")
+    if action == "add":
+        return _transport.call_unity(
+            "add_component", {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")}
+        )
+    if action == "remove":
+        return _transport.call_unity(
+            "remove_component", {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")}
+        )
+    if action == "inspect":
+        return _transport.call_unity(
+            "inspect_component", {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")}
+        )
+    if action == "get_schema":
+        return _transport.call_unity(
+            "get_component_schema",
+            {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")},
+        )
+    if action == "update_properties":
+        return _transport.call_unity(
+            "update_component",
+            {
+                "instance_id": args.get("instance_id"),
+                "component_name": args.get("component_name"),
+                "properties": args.get("properties"),
+            },
+        )
+    if action == "set_property":
+        return _transport.call_unity(
+            "set_property",
+            {
+                "instance_id": args.get("instance_id"),
+                "property_name": "m_Name",
+                "value": args.get("value"),
+            },
+        )
+    if action == "set_enabled":
+        return _transport.call_unity(
+            "set_enabled",
+            {
+                "instance_id": args.get("instance_id"),
+                "component_name": args.get("component_name"),
+                "enabled": args.get("enabled"),
+            },
+        )
+    return _invalid_action(
+        action, ["add", "remove", "inspect", "get_schema", "update_properties", "set_property", "set_enabled"]
+    )
+
+
+def _route_search_manager(args: JsonObject) -> JsonRpcResponse:
+    strategy = args.get("strategy")
+    if strategy == "regex":
+        return _transport.call_unity(
+            "find_objects", {"name": args.get("query"), "tag": args.get("tag"), "type": args.get("type")}
+        )
+    if strategy == "path":
+        return _transport.call_unity("find_by_path", {"path": args.get("query")})
+    if strategy == "semantic":
+        return _transport.call_unity("semantic_find", {"query": args.get("query")})
+    if strategy == "references":
+        return _transport.call_unity(
+            "find_references", {"target_id": args.get("target_id"), "target_guid": args.get("target_guid")}
+        )
+    return {
+        "error": {
+            "code": -32602,
+            "message": f"Invalid strategy: {strategy}. Valid strategies: regex, path, semantic, references",
+        }
+    }
+
+
+def _route_asset_manager(args: JsonObject) -> JsonRpcResponse:
+    action = args.get("action")
+    if action == "search":
+        return _transport.call_unity("list_assets", {"filter": args.get("filter")})
+    if action == "explore":
+        return _transport.call_unity("explore_asset", {"path": args.get("path")})
+    if action == "create_material":
+        return _transport.call_unity(
+            "create_material",
+            _compact(
+                {
+                    "name": args.get("name"),
+                    "shader": args.get("shader"),
+                    "path": args.get("path"),
+                    "base_color": args.get("base_color") or args.get("color"),
+                    "emission_color": args.get("emission_color") or args.get("emission"),
+                }
+            ),
+        )
+    if action == "import":
+        return _transport.call_unity("import_asset", {"path": args.get("path")})
+    if action == "refresh":
+        return _transport.call_unity("refresh_asset_database")
+    if action == "instantiate_prefab":
+        return _transport.call_unity("instantiate_prefab", {"path": args.get("path")})
+    if action == "create_prefab":
+        return _transport.call_unity(
+            "create_prefab", {"instance_id": args.get("instance_id"), "path": args.get("path")}
+        )
+    if action == "apply_overrides":
+        return _transport.call_unity("apply_prefab_overrides", {"instance_id": args.get("instance_id")})
+    if action == "revert_overrides":
+        return _transport.call_unity("revert_prefab_overrides", {"instance_id": args.get("instance_id")})
+    return _invalid_action(
+        action,
+        [
+            "search",
+            "explore",
+            "create_material",
+            "import",
+            "refresh",
+            "instantiate_prefab",
+            "create_prefab",
+            "apply_overrides",
+            "revert_overrides",
+        ],
+    )
diff --git a/Editor/tests/test_routing.py.meta b/Editor/nexus_bridge/routes_managers.py.meta
similarity index 74%
rename from Editor/tests/test_routing.py.meta
rename to Editor/nexus_bridge/routes_managers.py.meta
index fd7c09d..bec2eca 100644
--- a/Editor/tests/test_routing.py.meta
+++ b/Editor/nexus_bridge/routes_managers.py.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 86f06c09336d401f98da3d3ec18dbcea
+guid: 8126d43a6b15945d38e4c31f8b21be91
 DefaultImporter:
   externalObjects: {}
   userData: 
diff --git a/Editor/nexus_bridge/routes_ui.py b/Editor/nexus_bridge/routes_ui.py
new file mode 100644
index 0000000..34cb3f8
--- /dev/null
+++ b/Editor/nexus_bridge/routes_ui.py
@@ -0,0 +1,107 @@
+"""UI automation routing for NexusUnity."""
+
+from __future__ import annotations
+
+from . import _transport
+from .routes_base import JsonObject, JsonRpcResponse, _compact, _first_present, _invalid_action
+
+
+def _dispatch_ui_inspect(action: str | None, args: JsonObject) -> JsonRpcResponse | None:
+    if action == "list_windows":
+        return _transport.call_unity("ui_list_windows")
+    if action == "get_hierarchy":
+        return _transport.call_unity(
+            "ui_get_hierarchy",
+            _compact(
+                {
+                    "window_title": args.get("window_title"),
+                    "deep": args.get("deep"),
+                    "max_depth": args.get("max_depth"),
+                    "max_elements": _first_present(args.get("max_elements"), args.get("max_results")),
+                }
+            ),
+        )
+    if action == "query":
+        return _transport.call_unity(
+            "ui_query_elements",
+            _compact(
+                {
+                    "window_title": args.get("window_title"),
+                    "name": args.get("name"),
+                    "text": args.get("text"),
+                    "class_name": args.get("class_name"),
+                    "max_depth": args.get("max_depth"),
+                    "max_results": _first_present(args.get("max_results"), args.get("max_elements")),
+                    "max_elements": args.get("max_elements"),
+                }
+            ),
+        )
+    return None
+
+
+def _dispatch_ui_layout_and_input(action: str | None, args: JsonObject) -> JsonRpcResponse | None:
+    if action == "get_window_rect":
+        return _transport.call_unity("ui_get_window_rect", {"window_title": args.get("window_title")})
+    if action == "set_window_rect":
+        return _transport.call_unity(
+            "ui_set_window_rect",
+            _compact(
+                {
+                    "window_title": args.get("window_title"),
+                    "x": args.get("x"),
+                    "y": args.get("y"),
+                    "width": args.get("width"),
+                    "height": args.get("height"),
+                }
+            ),
+        )
+    if action == "capture_window_snapshot":
+        return _transport.call_unity(
+            "ui_capture_window_snapshot",
+            _compact(
+                {
+                    "window_title": args.get("window_title"),
+                    "include_image": args.get("include_image"),
+                    "include_hierarchy": args.get("include_hierarchy"),
+                    "max_depth": args.get("max_depth"),
+                    "max_elements": _first_present(args.get("max_elements"), args.get("max_results")),
+                }
+            ),
+        )
+    if action == "click":
+        return _transport.call_unity(
+            "ui_click", {"window_title": args.get("window_title"), "element_name": args.get("element_name")}
+        )
+    if action == "input":
+        return _transport.call_unity(
+            "ui_input_text",
+            {
+                "window_title": args.get("window_title"),
+                "element_name": args.get("element_name"),
+                "text": args.get("text", ""),
+            },
+        )
+    return None
+
+
+def _route_ui_automation(args: JsonObject) -> JsonRpcResponse:
+    action = args.get("action")
+    inspect_result = _dispatch_ui_inspect(action, args)
+    if inspect_result is not None:
+        return inspect_result
+    action_result = _dispatch_ui_layout_and_input(action, args)
+    if action_result is not None:
+        return action_result
+    return _invalid_action(
+        action,
+        [
+            "list_windows",
+            "get_hierarchy",
+            "query",
+            "get_window_rect",
+            "set_window_rect",
+            "capture_window_snapshot",
+            "click",
+            "input",
+        ],
+    )
diff --git a/Editor/nexus_bridge/routes_ui.py.meta b/Editor/nexus_bridge/routes_ui.py.meta
new file mode 100644
index 0000000..d206c97
--- /dev/null
+++ b/Editor/nexus_bridge/routes_ui.py.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a6439f325ecf9470d81ec09042a58739
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Editor/nexus_bridge/routing.py b/Editor/nexus_bridge/routing.py
index ccc5f58..e3311f5 100644
--- a/Editor/nexus_bridge/routing.py
+++ b/Editor/nexus_bridge/routing.py
@@ -7,634 +7,45 @@
 
 from __future__ import annotations
 
-import time
-from typing import Any
-from collections.abc import Mapping, Sequence
-
-from ._transport import call_unity
-from .schemas import STATIC_TOOLS
-
-JsonObject = dict[str, Any]
-JsonRpcResponse = dict[str, Any]
-
-
-def _compact(params: JsonObject) -> JsonObject:
-    return {key: value for key, value in params.items() if value is not None}
-
-
-def _alias(action_name: str | None, aliases: Mapping[str, str]) -> str | None:
-    if action_name is None:
-        return None
-    return aliases.get(action_name, action_name)
-
-
-def _invalid_action(action_name: str | None, valid_actions: Sequence[str]) -> JsonRpcResponse:
-    valid = ", ".join(valid_actions)
-    error_payload = {
-        "code": -32602,
-        "message": f"Invalid action: {action_name}. Valid actions: {valid}",
-    }
-    return {"error": error_payload}
-
-
-def _result_object(response: JsonRpcResponse | None) -> JsonObject:
-    if not response:
-        return {}
-    result_payload = response.get("result")
-    return result_payload if isinstance(result_payload, dict) else {}
-
-
-def _error_object(response: JsonRpcResponse | None) -> JsonObject | None:
-    if not response:
-        return None
-    return response.get("error")
-
-
-def _transform_params(args: JsonObject, instance_id: int | None = None) -> JsonObject:
-    params: JsonObject = {"instance_id": instance_id if instance_id is not None else args.get("instance_id")}
-    for key in ["position", "rotation", "scale", "eulerAngles", "localScale"]:
-        params[key] = args.get(key)
-    return _compact(params)
-
-
-def _extract_created_instance_id(response: JsonRpcResponse) -> int | None:
-    if "error" in response:
-        return None
-    result_payload = _result_object(response)
-    data = result_payload.get("data", {})
-    return data.get("instance_id") if isinstance(data, dict) else None
-
-
-def _apply_created_transform(response: JsonRpcResponse, args: JsonObject) -> JsonRpcResponse:
-    instance_id = _extract_created_instance_id(response)
-    if instance_id is None:
-        return response
-    params = _transform_params(args, instance_id)
-    if len(params) <= 1:
-        return response
-    transform_response = call_unity("set_transform", params)
-    if transform_response and "error" in transform_response:
-        return transform_response
-    return response
-
-
-def _run_tests_wait(args: JsonObject) -> JsonRpcResponse:
-    timeout = args.get("timeout_seconds", 180)
-    poll_interval = args.get("poll_interval_seconds", 1.0)
-    start_time = time.time()
-
-    previous_results_response = call_unity("get_test_results")
-    previous_results_payload = _result_object(previous_results_response)
-    previous_timestamp = (
-        previous_results_payload.get("timestamp_utc") if previous_results_payload.get("status") == "Success" else None
-    )
-
-    run_params = _compact(
-        {
-            "mode": args.get("mode", "EditMode"),
-            "filter": args.get("filter"),
-        }
-    )
-    trigger_response = call_unity("run_tests", run_params)
-    if trigger_response and "error" in trigger_response:
-        return trigger_response
-
-    trigger_payload = _result_object(trigger_response)
-    if trigger_payload.get("status") not in ("Submitted", "Success"):
-        return {"result": trigger_payload}
-
-    result_path = trigger_payload.get("result_path")
-
-    while time.time() - start_time < timeout:
-        params = {"result_path": result_path} if result_path else {}
-        current_results_response = call_unity("get_test_results", params)
-        if current_results_response and "error" in current_results_response:
-            return current_results_response
-
-        current_results_payload = _result_object(current_results_response)
-        if (
-            current_results_payload.get("status") == "Success"
-            and current_results_payload.get("timestamp_utc") != previous_timestamp
-        ):
-            test_results = dict(current_results_payload)
-            test_results["time_waited_seconds"] = round(time.time() - start_time, 2)
-            return {"result": test_results}
-
-        time.sleep(poll_interval)
-
-    timeout_result = {
-        "status": "Timeout",
-        "message": "Timed out waiting for a new Unity TestResults XML file.",
-        "time_waited_seconds": round(time.time() - start_time, 2),
-        "trigger": trigger_payload,
-    }
-    if isinstance(result_path, str):
-        timeout_result["result_path"] = result_path
-    return {"result": timeout_result}
-
-
-def _wait_for_compilation(timeout: float, start_time: float | None = None) -> JsonRpcResponse:
-    start_time = time.time() if start_time is None else start_time
-    status: str = "Ready"
-
-    reload_started: bool = False
-    reload_wait_timeout = min(20.0, timeout)
-    while time.time() - start_time < reload_wait_timeout:
-        initialize_response = call_unity("initialize")
-        if initialize_response is None or "error" in initialize_response:
-            reload_started = True
-            break
-        time.sleep(0.5)
-
-    if not reload_started:
-        call_unity("refresh_asset_database")
-
-    while time.time() - start_time < timeout:
-        initialize_response = call_unity("initialize")
-        if initialize_response and "result" in initialize_response:
-            time.sleep(2.0)
-            editor_state_response = call_unity("get_editor_state")
-            editor_state = _result_object(editor_state_response)
-            if (
-                editor_state_response
-                and "result" in editor_state_response
-                and not editor_state.get("is_compiling")
-                and not editor_state.get("is_updating")
-            ):
-                break
-        time.sleep(1.0)
-    else:
-        status = "Timeout"
-
-    wait_result = {
-        "status": status,
-        "time_waited_seconds": round(time.time() - start_time, 2),
-    }
-    return {"result": wait_result}
-
-
-def _route_list_tools(_: JsonObject) -> JsonRpcResponse:
-    return {"result": {"tools": STATIC_TOOLS}}
-
-
-def _route_write_and_compile(args: JsonObject) -> JsonRpcResponse:
-    files = args.get("files", [])
-    confirm = args.get("confirm")
-    start_time: float = time.time()
-    call_unity("clear_logs")
-
-    write_errors: list[JsonObject] = []
-    for file_info in files:
-        write_file_response = call_unity(
-            "write_file",
-            _compact({"path": file_info["path"], "content": file_info["content"], "confirm": confirm}),
-        )
-        write_error = _error_object(write_file_response)
-        if write_error is not None:
-            write_errors.append({"path": file_info["path"], "error": write_error})
-
-    if write_errors:
-        failure_result = {
-            "status": "Failed",
-            "message": "Failed to write some files",
-            "errors": write_errors,
-        }
-        return {"result": failure_result}
-
-    wait_response = _wait_for_compilation(timeout=90, start_time=start_time)
-    wait_result = _result_object(wait_response)
-    wait_status: str = wait_result["status"]
-    time_waited_seconds: float = wait_result["time_waited_seconds"]
-
-    compiler_errors: list[JsonObject] = []
-    if wait_status == "Ready":
-        log_response = call_unity("read_logs", {"count": 200})
-        log_payload = _result_object(log_response)
-        if log_response and "result" in log_response:
-            for log_entry in log_payload.get("logs", []):
-                if log_entry.get("Type") in ["Error", "Exception", "Assert"]:
-                    compiler_errors.append(log_entry)
-
-    success_result = {
-        "status": "Failed" if compiler_errors else wait_status,
-        "time_waited_seconds": time_waited_seconds,
-        "compiler_errors": compiler_errors,
-    }
-    return {"result": success_result}
-
-
-def _route_scene_manager(args: JsonObject) -> JsonRpcResponse:
-    aliases = {"create_scene": "create", "open_scene": "open", "save_scene": "save", "list_scenes": "list"}
-    action = _alias(args.get("action"), aliases)
-    if action == "create":
-        return call_unity(
-            "create_scene",
-            _compact(
-                {"name": args.get("name"), "path": args.get("path"), "open_if_exists": args.get("open_if_exists")}
-            ),
-        )
-    if action == "open":
-        return call_unity("open_scene", {"path": args.get("path")})
-    if action == "save":
-        return call_unity("save_scene", {"path": args.get("path")})
-    if action == "list":
-        return call_unity("list_scenes")
-    return _invalid_action(
-        args.get("action"),
-        ["create", "create_scene", "open", "open_scene", "save", "save_scene", "list", "list_scenes"],
-    )
-
-
-def _route_hierarchy_manager(args: JsonObject) -> JsonRpcResponse:
-    aliases = {
-        "create": "create_empty",
-        "create_gameobject": "create_empty",
-        "create_game_object": "create_empty",
-        "rename": "set_name",
-        "transform": "set_transform",
-    }
-    action = _alias(args.get("action"), aliases)
-    if action == "create_empty":
-        response = call_unity(
-            "create_game_object", _compact({"name": args.get("name"), "parent_id": args.get("parent_id")})
-        )
-        return _apply_created_transform(response, args)
-    if action == "create_primitive":
-        return call_unity(
-            "create_primitive",
-            _compact(
-                {
-                    "primitive_type": args.get("primitive_type"),
-                    "name": args.get("name"),
-                    "parent_id": args.get("parent_id"),
-                    "position": args.get("position"),
-                    "rotation": args.get("rotation"),
-                    "scale": args.get("scale"),
-                    "material_path": args.get("material_path"),
-                }
-            ),
-        )
-    if action == "create_hierarchy":
-        return call_unity("create_hierarchy", _compact({"tree": args.get("tree"), "parent_id": args.get("parent_id")}))
-    if action == "set_name":
-        return call_unity(
-            "set_property",
-            {
-                "instance_id": args.get("instance_id"),
-                "property_name": "m_Name",
-                "value": args.get("name") or args.get("new_name"),
-            },
-        )
-    if action == "set_transform":
-        return call_unity("set_transform", _transform_params(args))
-    if action == "destroy":
-        return call_unity("destroy_game_object", {"instance_id": args.get("instance_id")})
-    if action == "duplicate":
-        return call_unity("duplicate_object", {"instance_id": args.get("instance_id")})
-    if action == "set_active":
-        return call_unity("set_active", {"instance_id": args.get("instance_id"), "active": args.get("active")})
-    if action == "set_parent":
-        return call_unity("set_parent", {"instance_id": args.get("instance_id"), "parent_id": args.get("parent_id")})
-    if action == "set_sibling_index":
-        return call_unity("set_sibling_index", {"instance_id": args.get("instance_id"), "index": args.get("index")})
-    return _invalid_action(
-        args.get("action"),
-        [
-            "create_empty",
-            "create",
-            "create_gameobject",
-            "create_game_object",
-            "create_primitive",
-            "create_hierarchy",
-            "destroy",
-            "duplicate",
-            "rename",
-            "set_name",
-            "set_transform",
-            "set_active",
-            "set_parent",
-            "set_sibling_index",
-        ],
-    )
-
-
-def _route_component_manager(args: JsonObject) -> JsonRpcResponse:
-    action = args.get("action")
-    if action == "add":
-        return call_unity(
-            "add_component", {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")}
-        )
-    if action == "remove":
-        return call_unity(
-            "remove_component", {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")}
-        )
-    if action == "inspect":
-        return call_unity(
-            "inspect_component", {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")}
-        )
-    if action == "get_schema":
-        return call_unity(
-            "get_component_schema",
-            {"instance_id": args.get("instance_id"), "component_name": args.get("component_name")},
-        )
-    if action == "update_properties":
-        return call_unity(
-            "update_component",
-            {
-                "instance_id": args.get("instance_id"),
-                "component_name": args.get("component_name"),
-                "properties": args.get("properties"),
-            },
-        )
-    if action == "set_property":
-        return call_unity(
-            "set_property",
-            {
-                "instance_id": args.get("instance_id"),
-                "property_name": args.get("property_name"),
-                "value": args.get("value"),
-            },
-        )
-    if action == "set_enabled":
-        return call_unity(
-            "set_enabled",
-            {
-                "instance_id": args.get("instance_id"),
-                "component_name": args.get("component_name"),
-                "enabled": args.get("enabled"),
-            },
-        )
-    return _invalid_action(
-        action, ["add", "remove", "inspect", "get_schema", "update_properties", "set_property", "set_enabled"]
-    )
-
-
-def _route_search_manager(args: JsonObject) -> JsonRpcResponse:
-    strategy = args.get("strategy")
-    if strategy == "regex":
-        return call_unity("find_objects", {"name": args.get("query"), "tag": args.get("tag"), "type": args.get("type")})
-    if strategy == "path":
-        return call_unity("find_by_path", {"path": args.get("query")})
-    if strategy == "semantic":
-        return call_unity("semantic_find", {"query": args.get("query")})
-    if strategy == "references":
-        return call_unity(
-            "find_references", {"target_id": args.get("target_id"), "target_guid": args.get("target_guid")}
-        )
-    return {
-        "error": {
-            "code": -32602,
-            "message": f"Invalid strategy: {strategy}. Valid strategies: regex, path, semantic, references",
-        }
-    }
-
-
-def _route_asset_manager(args: JsonObject) -> JsonRpcResponse:
-    action = args.get("action")
-    if action == "search":
-        return call_unity("list_assets", {"filter": args.get("filter")})
-    if action == "explore":
-        return call_unity("explore_asset", {"path": args.get("path")})
-    if action == "create_material":
-        return call_unity(
-            "create_material",
-            _compact(
-                {
-                    "name": args.get("name"),
-                    "shader": args.get("shader"),
-                    "path": args.get("path"),
-                    "base_color": args.get("base_color") or args.get("color"),
-                    "emission_color": args.get("emission_color") or args.get("emission"),
-                }
-            ),
-        )
-    if action == "import":
-        return call_unity("import_asset", {"path": args.get("path")})
-    if action == "refresh":
-        return call_unity("refresh_asset_database")
-    if action == "instantiate_prefab":
-        return call_unity("instantiate_prefab", {"path": args.get("path")})
-    if action == "create_prefab":
-        return call_unity("create_prefab", {"instance_id": args.get("instance_id"), "path": args.get("path")})
-    if action == "apply_overrides":
-        return call_unity("apply_prefab_overrides", {"instance_id": args.get("instance_id")})
-    if action == "revert_overrides":
-        return call_unity("revert_prefab_overrides", {"instance_id": args.get("instance_id")})
-    return _invalid_action(
-        action,
-        [
-            "search",
-            "explore",
-            "create_material",
-            "import",
-            "refresh",
-            "instantiate_prefab",
-            "create_prefab",
-            "apply_overrides",
-            "revert_overrides",
-        ],
-    )
-
-
-def _route_editor_controller(args: JsonObject) -> JsonRpcResponse:
-    action = args.get("action")
-    if action == "undo":
-        return call_unity("undo")
-    if action == "redo":
-        return call_unity("redo")
-    if action == "play":
-        return call_unity("toggle_play_mode", {"value": args.get("state")})
-    if action == "pause":
-        return call_unity("pause_play_mode", {"value": args.get("state")})
-    if action == "step":
-        return call_unity("step_frame")
-    if action == "menu":
-        return call_unity("execute_menu_item", {"item_path": args.get("item_path")})
-    if action == "read_logs":
-        return call_unity("read_logs", {"count": args.get("count", 100)})
-    if action == "clear_logs":
-        return call_unity("clear_logs")
-    if action == "get_state":
-        return call_unity("get_editor_state")
-    if action == "get_server_status":
-        return call_unity("get_server_status")
-    if action == "refresh_assets":
-        return call_unity("refresh_asset_database")
-    if action == "run_tests":
-        return call_unity("run_tests", _compact({"mode": args.get("mode", "EditMode"), "filter": args.get("filter")}))
-    if action == "get_test_results":
-        return call_unity("get_test_results", _compact({"result_path": args.get("result_path")}))
-    if action == "run_tests_wait":
-        return _run_tests_wait(args)
-    if action == "get_tool_usage_stats":
-        return call_unity("get_tool_usage_stats")
-    if action == "reset_tool_usage_stats":
-        return call_unity("reset_tool_usage_stats")
-    return _invalid_action(
-        action,
-        [
-            "undo",
-            "redo",
-            "play",
-            "pause",
-            "step",
-            "menu",
-            "read_logs",
-            "clear_logs",
-            "get_state",
-            "get_server_status",
-            "refresh_assets",
-            "run_tests",
-            "get_test_results",
-            "run_tests_wait",
-            "get_tool_usage_stats",
-            "reset_tool_usage_stats",
-        ],
-    )
-
-
-def _route_ui_automation(args: JsonObject) -> JsonRpcResponse:
-    action = args.get("action")
-    if action == "list_windows":
-        return call_unity("ui_list_windows")
-    if action == "get_hierarchy":
-        return call_unity(
-            "ui_get_hierarchy", _compact({"window_title": args.get("window_title"), "deep": args.get("deep")})
-        )
-    if action == "query":
-        return call_unity(
-            "ui_query_elements",
-            _compact(
-                {
-                    "window_title": args.get("window_title"),
-                    "name": args.get("name"),
-                    "text": args.get("text"),
-                    "class_name": args.get("class_name"),
-                }
-            ),
-        )
-    if action == "get_window_rect":
-        return call_unity("ui_get_window_rect", {"window_title": args.get("window_title")})
-    if action == "set_window_rect":
-        return call_unity(
-            "ui_set_window_rect",
-            _compact(
-                {
-                    "window_title": args.get("window_title"),
-                    "x": args.get("x"),
-                    "y": args.get("y"),
-                    "width": args.get("width"),
-                    "height": args.get("height"),
-                }
-            ),
-        )
-    if action == "capture_window_snapshot":
-        return call_unity(
-            "ui_capture_window_snapshot",
-            _compact(
-                {
-                    "window_title": args.get("window_title"),
-                    "include_image": args.get("include_image"),
-                    "include_hierarchy": args.get("include_hierarchy"),
-                }
-            ),
-        )
-    if action == "click":
-        return call_unity(
-            "ui_click", {"window_title": args.get("window_title"), "element_name": args.get("element_name")}
-        )
-    if action == "input":
-        return call_unity(
-            "ui_input_text",
-            {
-                "window_title": args.get("window_title"),
-                "element_name": args.get("element_name"),
-                "text": args.get("text"),
-            },
-        )
-    return _invalid_action(
-        action,
-        [
-            "list_windows",
-            "get_hierarchy",
-            "query",
-            "get_window_rect",
-            "set_window_rect",
-            "capture_window_snapshot",
-            "click",
-            "input",
-        ],
-    )
-
-
-def _route_playerprefs_manager(args: JsonObject) -> JsonRpcResponse:
-    action = args.get("action")
-    if action == "get":
-        return call_unity("get_player_pref", {"key": args.get("key"), "type": args.get("type", "string")})
-    if action == "set":
-        return call_unity(
-            "set_player_pref", {"key": args.get("key"), "value": args.get("value"), "type": args.get("type", "string")}
-        )
-    if action == "delete":
-        return call_unity("delete_player_pref", _compact({"key": args.get("key"), "confirm": args.get("confirm")}))
-    if action == "list":
-        return call_unity("list_player_prefs")
-    return _invalid_action(action, ["get", "set", "delete", "list"])
-
-
-def _route_wait(args: JsonObject) -> JsonRpcResponse:
-    condition: Any = args.get("condition")
-    timeout: float = args.get("timeout_seconds", 60)
-    start_time: float = time.time()
-    status: str = "Ready"
-
-    if condition == "compilation":
-        return _wait_for_compilation(timeout=timeout, start_time=start_time)
-    if condition == "play_mode":
-        target_state = args.get("state", True)
-        while time.time() - start_time < timeout:
-            editor_state_response = call_unity("get_editor_state")
-            editor_state = _result_object(editor_state_response)
-            if (
-                editor_state_response
-                and "result" in editor_state_response
-                and editor_state.get("is_playing") == target_state
-            ):
-                break
-            time.sleep(1.0)
-        else:
-            status = "Timeout"
-    elif condition == "import":
-        while time.time() - start_time < timeout:
-            import_idle_response = call_unity("is_asset_import_idle")
-            import_idle_state = _result_object(import_idle_response)
-            if import_idle_response and "result" in import_idle_response and import_idle_state.get("is_idle"):
-                break
-            time.sleep(1.0)
-        else:
-            status = "Timeout"
-    elif condition == "editor_idle":
-        while time.time() - start_time < timeout:
-            editor_idle_response = call_unity("is_editor_idle")
-            editor_idle_state = _result_object(editor_idle_response)
-            if editor_idle_response and "result" in editor_idle_response and editor_idle_state.get("is_idle"):
-                break
-            time.sleep(1.0)
-        else:
-            status = "Timeout"
-
-    wait_result = {
-        "status": status,
-        "time_waited_seconds": round(time.time() - start_time, 2),
-    }
-    return {"result": wait_result}
-
+from . import _transport
+from .routes_base import (  # noqa: F401
+    JsonObject,
+    JsonRpcResponse,
+    _alias,
+    _apply_created_transform,
+    _compact,
+    _error_object,
+    _extract_created_instance_id,
+    _first_present,
+    _invalid_action,
+    _result_object,
+    _transform_params,
+)
+from .routes_editor import (  # noqa: F401
+    _poll_test_results,
+    _route_editor_controller,
+    _route_list_tools,
+    _route_playerprefs_manager,
+    _route_wait,
+    _route_write_and_compile,
+    _run_tests_wait,
+    _wait_for_compilation,
+)
+from .routes_managers import (
+    _route_asset_manager,
+    _route_component_manager,
+    _route_hierarchy_manager,
+    _route_scene_manager,
+    _route_search_manager,
+)
+from .routes_ui import _route_ui_automation
 
 _HANDLERS = {
     "tools/list": _route_list_tools,
     "list_tools": _route_list_tools,
     "listTools": _route_list_tools,
     "write_and_compile": _route_write_and_compile,
+    "apply_code_change": _route_write_and_compile,
     "scene_manager": _route_scene_manager,
     "hierarchy_manager": _route_hierarchy_manager,
     "component_manager": _route_component_manager,
@@ -647,8 +58,12 @@ def _route_wait(args: JsonObject) -> JsonRpcResponse:
 }
 
 
+def call_unity(name: str, args: JsonObject | None = None) -> JsonRpcResponse:
+    return _transport.call_unity(name, args)
+
+
 def route_tool(name: str, args: JsonObject) -> JsonRpcResponse:
     handler = _HANDLERS.get(name)
     if handler is not None:
         return handler(args)
-    return call_unity(name, args)
+    return _transport.call_unity(name, args)
diff --git a/Editor/nexus_bridge/schemas.py b/Editor/nexus_bridge/schemas.py
index a1859af..0c5f859 100644
--- a/Editor/nexus_bridge/schemas.py
+++ b/Editor/nexus_bridge/schemas.py
@@ -1,7 +1,7 @@
 """Static tool and resource definitions for the NexusUnity MCP bridge.
 
 :data:`STATIC_TOOLS` is the authoritative list of MCP tools exposed to AI
-clients.  Each entry follows the JSON Schema / MCP tool-definition shape.
+clients. Each entry follows the JSON Schema / MCP tool-definition shape.
 
 :data:`STATIC_RESOURCES` lists the static read-only resources advertised via
 ``resources/list``.
@@ -11,686 +11,40 @@
 
 from typing import Any
 
-JsonObject = dict[str, Any]
+from .schemas_components import (
+    ASSET_MANAGER_TOOL,
+    COMPONENT_MANAGER_TOOL,
+    SEARCH_MANAGER_TOOL,
+)
+from .schemas_editor import (
+    DIAGNOSTIC_TOOLS,
+    EDITOR_CONTROLLER_TOOL,
+    PLAYERPREFS_MANAGER_TOOL,
+    STATIC_RESOURCES,
+    UI_AUTOMATION_TOOL,
+    WAIT_TOOL,
+    WRITE_AND_COMPILE_TOOL,
+)
+from .schemas_managers import (
+    HIERARCHY_MANAGER_TOOL,
+    SCENE_MANAGER_TOOL,
+    VECTOR3_SCHEMA,
+)
 
-# --- Shared sub-schemas ---
-VECTOR3_SCHEMA: JsonObject = {
-    "oneOf": [
-        {
-            "type": "object",
-            "properties": {
-                "x": {"type": "number"},
-                "y": {"type": "number"},
-                "z": {"type": "number"},
-            },
-        },
-        {
-            "type": "array",
-            "items": {"type": "number"},
-            "minItems": 3,
-            "maxItems": 3,
-        },
-    ],
-}
+JsonObject = dict[str, Any]
 
 STATIC_TOOLS: list[JsonObject] = [
-    # --- Consolidated Core Managers ---
-    {
-        "name": "unity_scene_manager",
-        "description": "Unified scene management (create, open, save, list)",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "properties": {
-                        "action": {"type": "string", "enum": ["create", "create_scene"]},
-                        "name": {"type": "string"},
-                        "path": {"type": "string"},
-                        "open_if_exists": {"type": "boolean"},
-                    },
-                    "required": ["action"],
-                },
-                {
-                    "properties": {
-                        "action": {"type": "string", "enum": ["open", "open_scene"]},
-                        "path": {"type": "string"},
-                    },
-                    "required": ["action", "path"],
-                },
-                {
-                    "properties": {
-                        "action": {"type": "string", "enum": ["save", "save_scene"]},
-                        "path": {"type": "string"},
-                    },
-                    "required": ["action"],
-                },
-                {"properties": {"action": {"type": "string", "enum": ["list", "list_scenes"]}}, "required": ["action"]},
-            ],
-        },
-    },
-    {
-        "name": "unity_hierarchy_manager",
-        "description": "Unified GameObject hierarchy and lifecycle management",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Create an empty GameObject, including common create-action aliases",
-                    "properties": {
-                        "action": {
-                            "type": "string",
-                            "enum": ["create_empty", "create", "create_gameobject", "create_game_object"],
-                        },
-                        "name": {"type": "string"},
-                        "parent_id": {"type": "integer"},
-                        "position": VECTOR3_SCHEMA,
-                        "rotation": VECTOR3_SCHEMA,
-                        "scale": VECTOR3_SCHEMA,
-                        "eulerAngles": VECTOR3_SCHEMA,
-                        "localScale": VECTOR3_SCHEMA,
-                    },
-                    "required": ["action", "name"],
-                },
-                {
-                    "description": "Create a primitive GameObject",
-                    "properties": {
-                        "action": {"const": "create_primitive"},
-                        "primitive_type": {
-                            "type": "string",
-                            "enum": ["Cube", "Sphere", "Capsule", "Cylinder", "Plane", "Quad"],
-                        },
-                        "name": {"type": "string"},
-                        "parent_id": {"type": "integer"},
-                        "position": VECTOR3_SCHEMA,
-                        "rotation": VECTOR3_SCHEMA,
-                        "scale": VECTOR3_SCHEMA,
-                        "material_path": {"type": "string"},
-                    },
-                    "required": ["action", "primitive_type"],
-                },
-                {
-                    "description": "Batch-create a hierarchy of GameObjects",
-                    "properties": {
-                        "action": {"const": "create_hierarchy"},
-                        "tree": {"type": "object"},
-                        "parent_id": {"type": "integer"},
-                    },
-                    "required": ["action", "tree"],
-                },
-                {
-                    "description": "Destroy a GameObject",
-                    "properties": {
-                        "action": {"const": "destroy"},
-                        "instance_id": {"type": "integer"},
-                    },
-                    "required": ["action", "instance_id"],
-                },
-                {
-                    "description": "Duplicate a GameObject",
-                    "properties": {
-                        "action": {"const": "duplicate"},
-                        "instance_id": {"type": "integer"},
-                    },
-                    "required": ["action", "instance_id"],
-                },
-                {
-                    "description": "Rename a GameObject, including the rename alias",
-                    "properties": {
-                        "action": {"type": "string", "enum": ["rename", "set_name"]},
-                        "instance_id": {"type": "integer"},
-                        "name": {"type": "string"},
-                        "new_name": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id"],
-                    "anyOf": [{"required": ["name"]}, {"required": ["new_name"]}],
-                },
-                {
-                    "description": "Move, rotate, or scale a GameObject, including the transform alias",
-                    "properties": {
-                        "action": {"type": "string", "enum": ["set_transform", "transform"]},
-                        "instance_id": {"type": "integer"},
-                        "position": VECTOR3_SCHEMA,
-                        "rotation": VECTOR3_SCHEMA,
-                        "scale": VECTOR3_SCHEMA,
-                        "eulerAngles": VECTOR3_SCHEMA,
-                        "localScale": VECTOR3_SCHEMA,
-                    },
-                    "required": ["action", "instance_id"],
-                },
-                {
-                    "description": "Enable or disable a GameObject",
-                    "properties": {
-                        "action": {"const": "set_active"},
-                        "instance_id": {"type": "integer"},
-                        "active": {"type": "boolean"},
-                    },
-                    "required": ["action", "instance_id", "active"],
-                },
-                {
-                    "description": "Reparent a GameObject",
-                    "properties": {
-                        "action": {"const": "set_parent"},
-                        "instance_id": {"type": "integer"},
-                        "parent_id": {"type": "integer"},
-                    },
-                    "required": ["action", "instance_id", "parent_id"],
-                },
-                {
-                    "description": "Reorder a GameObject within its siblings",
-                    "properties": {
-                        "action": {"const": "set_sibling_index"},
-                        "instance_id": {"type": "integer"},
-                        "index": {"oneOf": [{"type": "integer"}, {"type": "string", "enum": ["first", "last"]}]},
-                    },
-                    "required": ["action", "instance_id", "index"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_component_manager",
-        "description": "Unified component and property management",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Add a component to a GameObject",
-                    "properties": {
-                        "action": {"const": "add"},
-                        "instance_id": {"type": "integer"},
-                        "component_name": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id", "component_name"],
-                },
-                {
-                    "description": "Remove a component from a GameObject",
-                    "properties": {
-                        "action": {"const": "remove"},
-                        "instance_id": {"type": "integer"},
-                        "component_name": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id", "component_name"],
-                },
-                {
-                    "description": "Inspect all serialized fields of a component",
-                    "properties": {
-                        "action": {"const": "inspect"},
-                        "instance_id": {"type": "integer"},
-                        "component_name": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id", "component_name"],
-                },
-                {
-                    "description": "Get the serialized-field schema for a component type",
-                    "properties": {
-                        "action": {"const": "get_schema"},
-                        "instance_id": {"type": "integer"},
-                        "component_name": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id", "component_name"],
-                },
-                {
-                    "description": "Batch-update multiple properties on a component",
-                    "properties": {
-                        "action": {"const": "update_properties"},
-                        "instance_id": {"type": "integer"},
-                        "component_name": {"type": "string"},
-                        "properties": {"type": "object"},
-                    },
-                    "required": ["action", "instance_id", "component_name", "properties"],
-                },
-                {
-                    "description": "Set a single serialized property by name",
-                    "properties": {
-                        "action": {"const": "set_property"},
-                        "instance_id": {"type": "integer"},
-                        "property_name": {"type": "string"},
-                        "value": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id", "property_name", "value"],
-                },
-                {
-                    "description": "Enable or disable a component",
-                    "properties": {
-                        "action": {"const": "set_enabled"},
-                        "instance_id": {"type": "integer"},
-                        "component_name": {"type": "string"},
-                        "enabled": {"type": "boolean"},
-                    },
-                    "required": ["action", "instance_id", "component_name", "enabled"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_search_manager",
-        "description": "Unified discovery and reference search",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Find objects by name regex, tag, or type",
-                    "properties": {
-                        "strategy": {"const": "regex"},
-                        "query": {"type": "string"},
-                        "tag": {"type": "string"},
-                        "type": {"type": "string"},
-                    },
-                    "required": ["strategy"],
-                },
-                {
-                    "description": "Find a single object by its scene hierarchy path",
-                    "properties": {"strategy": {"const": "path"}, "query": {"type": "string"}},
-                    "required": ["strategy", "query"],
-                },
-                {
-                    "description": "Find objects using a natural-language semantic query",
-                    "properties": {"strategy": {"const": "semantic"}, "query": {"type": "string"}},
-                    "required": ["strategy", "query"],
-                },
-                {
-                    "description": "Find all objects that reference a specific asset or component",
-                    "properties": {
-                        "strategy": {"const": "references"},
-                        "target_id": {"type": "integer"},
-                        "target_guid": {"type": "string"},
-                    },
-                    "required": ["strategy"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_asset_manager",
-        "description": "Unified asset and prefab pipeline management",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Search for assets by filter string",
-                    "properties": {"action": {"const": "search"}, "filter": {"type": "string"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Explore metadata and sub-assets at a given asset path",
-                    "properties": {"action": {"const": "explore"}, "path": {"type": "string"}},
-                    "required": ["action", "path"],
-                },
-                {
-                    "description": "Create a new material asset",
-                    "properties": {
-                        "action": {"const": "create_material"},
-                        "name": {"type": "string"},
-                        "shader": {"type": "string"},
-                        "path": {"type": "string"},
-                        "base_color": {"type": "string"},
-                        "color": {"type": "string"},
-                        "emission_color": {"type": "string"},
-                        "emission": {"type": "string"},
-                    },
-                    "required": ["action", "name"],
-                },
-                {
-                    "description": "Import an asset from disk into the Unity project",
-                    "properties": {"action": {"const": "import"}, "path": {"type": "string"}},
-                    "required": ["action", "path"],
-                },
-                {
-                    "description": "Refresh the AssetDatabase to pick up filesystem changes",
-                    "properties": {"action": {"const": "refresh"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Instantiate a prefab from its asset path into the active scene",
-                    "properties": {"action": {"const": "instantiate_prefab"}, "path": {"type": "string"}},
-                    "required": ["action", "path"],
-                },
-                {
-                    "description": "Create a new prefab asset from an existing scene GameObject",
-                    "properties": {
-                        "action": {"const": "create_prefab"},
-                        "instance_id": {"type": "integer"},
-                        "path": {"type": "string"},
-                    },
-                    "required": ["action", "instance_id", "path"],
-                },
-                {
-                    "description": "Apply all prefab instance overrides back to the prefab asset",
-                    "properties": {"action": {"const": "apply_overrides"}, "instance_id": {"type": "integer"}},
-                    "required": ["action", "instance_id"],
-                },
-                {
-                    "description": "Revert all prefab instance overrides to match the prefab asset",
-                    "properties": {"action": {"const": "revert_overrides"}, "instance_id": {"type": "integer"}},
-                    "required": ["action", "instance_id"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_editor_controller",
-        "description": "Unified editor state and play mode control",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Undo the last editor action",
-                    "properties": {"action": {"const": "undo"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Redo the previously undone editor action",
-                    "properties": {"action": {"const": "redo"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Enter or exit Play Mode",
-                    "properties": {"action": {"const": "play"}, "state": {"type": "boolean"}},
-                    "required": ["action", "state"],
-                },
-                {
-                    "description": "Pause or unpause Play Mode",
-                    "properties": {"action": {"const": "pause"}, "state": {"type": "boolean"}},
-                    "required": ["action", "state"],
-                },
-                {
-                    "description": "Advance Play Mode by one frame while paused",
-                    "properties": {"action": {"const": "step"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Execute an editor menu item by its path (e.g. 'File/Save')",
-                    "properties": {"action": {"const": "menu"}, "item_path": {"type": "string"}},
-                    "required": ["action", "item_path"],
-                },
-                {
-                    "description": "Read recent Unity console log entries",
-                    "properties": {"action": {"const": "read_logs"}, "count": {"type": "integer"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Clear all Unity console log entries",
-                    "properties": {"action": {"const": "clear_logs"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Get the current editor state (play mode, compiling, etc.)",
-                    "properties": {"action": {"const": "get_state"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Get the Nexus Unity server status and version info",
-                    "properties": {"action": {"const": "get_server_status"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Refresh the AssetDatabase",
-                    "properties": {"action": {"const": "refresh_assets"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Trigger a Unity Test Runner run without waiting for results",
-                    "properties": {
-                        "action": {"const": "run_tests"},
-                        "mode": {"type": "string"},
-                        "filter": {"type": "string"},
-                    },
-                    "required": ["action"],
-                },
-                {
-                    "description": "Retrieve the most recent Test Runner results XML",
-                    "properties": {"action": {"const": "get_test_results"}, "result_path": {"type": "string"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Run tests and block until results are available (or timeout)",
-                    "properties": {
-                        "action": {"const": "run_tests_wait"},
-                        "mode": {"type": "string"},
-                        "filter": {"type": "string"},
-                        "timeout_seconds": {"type": "integer"},
-                        "poll_interval_seconds": {"type": "number"},
-                    },
-                    "required": ["action"],
-                },
-                {
-                    "description": "Get per-tool invocation statistics",
-                    "properties": {"action": {"const": "get_tool_usage_stats"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Reset all per-tool invocation statistics counters",
-                    "properties": {"action": {"const": "reset_tool_usage_stats"}},
-                    "required": ["action"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_ui_automation",
-        "description": "Unified UI Toolkit window automation",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "List all open editor windows",
-                    "properties": {"action": {"const": "list_windows"}},
-                    "required": ["action"],
-                },
-                {
-                    "description": "Get the UI element hierarchy for a window",
-                    "properties": {
-                        "action": {"const": "get_hierarchy"},
-                        "window_title": {"type": "string"},
-                        "deep": {"type": "boolean"},
-                    },
-                    "required": ["action", "window_title"],
-                },
-                {
-                    "description": "Query UI elements by name, text, or class within a window",
-                    "properties": {
-                        "action": {"const": "query"},
-                        "window_title": {"type": "string"},
-                        "name": {"type": "string"},
-                        "text": {"type": "string"},
-                        "class_name": {"type": "string"},
-                    },
-                    "required": ["action", "window_title"],
-                },
-                {
-                    "description": "Get the screen rect (position and size) of a window",
-                    "properties": {"action": {"const": "get_window_rect"}, "window_title": {"type": "string"}},
-                    "required": ["action", "window_title"],
-                },
-                {
-                    "description": "Reposition and resize a window",
-                    "properties": {
-                        "action": {"const": "set_window_rect"},
-                        "window_title": {"type": "string"},
-                        "x": {"type": "number"},
-                        "y": {"type": "number"},
-                        "width": {"type": "number"},
-                        "height": {"type": "number"},
-                    },
-                    "required": ["action", "window_title"],
-                },
-                {
-                    "description": "Capture a screenshot and/or UI hierarchy snapshot of a window",
-                    "properties": {
-                        "action": {"const": "capture_window_snapshot"},
-                        "window_title": {"type": "string"},
-                        "include_image": {"type": "boolean"},
-                        "include_hierarchy": {"type": "boolean"},
-                    },
-                    "required": ["action", "window_title"],
-                },
-                {
-                    "description": "Click a named UI element inside a window",
-                    "properties": {
-                        "action": {"const": "click"},
-                        "window_title": {"type": "string"},
-                        "element_name": {"type": "string"},
-                    },
-                    "required": ["action", "window_title", "element_name"],
-                },
-                {
-                    "description": "Type text into a named UI input element inside a window",
-                    "properties": {
-                        "action": {"const": "input"},
-                        "window_title": {"type": "string"},
-                        "element_name": {"type": "string"},
-                        "text": {"type": "string"},
-                    },
-                    "required": ["action", "window_title", "element_name", "text"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_wait",
-        "description": "Wait for specific Unity editor states or events",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Wait until script compilation and domain reload finishes",
-                    "properties": {"condition": {"const": "compilation"}, "timeout_seconds": {"type": "integer"}},
-                    "required": ["condition"],
-                },
-                {
-                    "description": "Wait until Play Mode reaches the specified state (true=playing, false=stopped)",
-                    "properties": {
-                        "condition": {"const": "play_mode"},
-                        "state": {"type": "boolean"},
-                        "timeout_seconds": {"type": "integer"},
-                    },
-                    "required": ["condition", "state"],
-                },
-                {
-                    "description": "Wait until all pending asset imports are complete",
-                    "properties": {"condition": {"const": "import"}, "timeout_seconds": {"type": "integer"}},
-                    "required": ["condition"],
-                },
-                {
-                    "description": "Wait until the editor is fully idle (not compiling, importing, or playing)",
-                    "properties": {"condition": {"const": "editor_idle"}, "timeout_seconds": {"type": "integer"}},
-                    "required": ["condition"],
-                },
-            ],
-        },
-    },
-    {
-        "name": "unity_playerprefs_manager",
-        "description": "Unified PlayerPrefs management",
-        "inputSchema": {
-            "type": "object",
-            "oneOf": [
-                {
-                    "description": "Read a PlayerPref value by key",
-                    "properties": {
-                        "action": {"const": "get"},
-                        "key": {"type": "string"},
-                        "type": {"type": "string", "enum": ["string", "int", "float"]},
-                    },
-                    "required": ["action", "key"],
-                },
-                {
-                    "description": "Write a PlayerPref value",
-                    "properties": {
-                        "action": {"const": "set"},
-                        "key": {"type": "string"},
-                        "value": {"type": "string"},
-                        "type": {"type": "string", "enum": ["string", "int", "float"]},
-                    },
-                    "required": ["action", "key", "value"],
-                },
-                {
-                    "description": "Delete a PlayerPref entry by key; use key 'all' with confirm true to clear all PlayerPrefs",
-                    "properties": {
-                        "action": {"const": "delete"},
-                        "key": {"type": "string"},
-                        "confirm": {"type": "boolean"},
-                    },
-                    "required": ["action", "key"],
-                },
-                {
-                    "description": "List all stored PlayerPref keys and their values",
-                    "properties": {"action": {"const": "list"}},
-                    "required": ["action"],
-                },
-            ],
-        },
-    },
-    # --- Specialized Diagnostics ---
-    {
-        "name": "unity_write_and_compile",
-        "description": "High-level macro: Writes multiple files, waits for domain reload, and returns compiler errors. Use for ALL code changes.",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "files": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
-                        "required": ["path", "content"],
-                    },
-                },
-                "confirm": {
-                    "type": "boolean",
-                    "description": "Required when writing .cs files because Unity compilation is triggered",
-                },
-            },
-            "required": ["files"],
-        },
-    },
-    {
-        "name": "unity_invoke_method",
-        "description": "Invoke a C# method on a component via reflection",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "instance_id": {"type": "integer"},
-                "component_name": {"type": "string"},
-                "method_name": {"type": "string"},
-                "arguments": {"type": "array"},
-            },
-            "required": ["instance_id", "method_name"],
-        },
-    },
-    {
-        "name": "unity_dump_scene_graph",
-        "description": "Dump recursive tree of active scene with components and key fields",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "root_id": {"type": "integer"},
-                "max_depth": {"type": "integer"},
-                "include_all_properties": {"type": "boolean"},
-            },
-        },
-    },
-    {
-        "name": "unity_get_scene_dependencies",
-        "description": "Return a scene-wide dependency map of cross-object references",
-        "inputSchema": {"type": "object", "properties": {}},
-    },
-    {
-        "name": "unity_lint_project",
-        "description": "Run Roslyn-based C# audit of the entire project",
-        "inputSchema": {"type": "object", "properties": {}},
-    },
+    SCENE_MANAGER_TOOL,
+    HIERARCHY_MANAGER_TOOL,
+    COMPONENT_MANAGER_TOOL,
+    SEARCH_MANAGER_TOOL,
+    ASSET_MANAGER_TOOL,
+    EDITOR_CONTROLLER_TOOL,
+    UI_AUTOMATION_TOOL,
+    WAIT_TOOL,
+    PLAYERPREFS_MANAGER_TOOL,
+    WRITE_AND_COMPILE_TOOL,
+    *DIAGNOSTIC_TOOLS,
 ]
 
-STATIC_RESOURCES: list[JsonObject] = [
-    {
-        "uri": "unity://docs/api-reference",
-        "name": "API Reference",
-        "mimeType": "text/markdown",
-    },
-    {
-        "uri": "unity://docs/setup",
-        "name": "Setup Guide",
-        "mimeType": "text/markdown",
-    },
-]
+__all__ = ["STATIC_RESOURCES", "STATIC_TOOLS", "VECTOR3_SCHEMA"]
diff --git a/Editor/nexus_bridge/schemas_components.py b/Editor/nexus_bridge/schemas_components.py
new file mode 100644
index 0000000..9efe5e4
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_components.py
@@ -0,0 +1,190 @@
+"""Component, search, and asset manager tool schemas for NexusUnity."""
+
+from __future__ import annotations
+
+from typing import Any
+
+JsonObject = dict[str, Any]
+
+COMPONENT_MANAGER_TOOL: JsonObject = {
+    "name": "unity_component_manager",
+    "description": "Unified component and property management",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Add a component to a GameObject",
+                "properties": {
+                    "action": {"const": "add"},
+                    "instance_id": {"type": "integer"},
+                    "component_name": {"type": "string"},
+                },
+                "required": ["action", "instance_id", "component_name"],
+            },
+            {
+                "description": "Remove a component from a GameObject",
+                "properties": {
+                    "action": {"const": "remove"},
+                    "instance_id": {"type": "integer"},
+                    "component_name": {"type": "string"},
+                },
+                "required": ["action", "instance_id", "component_name"],
+            },
+            {
+                "description": "Inspect all serialized fields of a component",
+                "properties": {
+                    "action": {"const": "inspect"},
+                    "instance_id": {"type": "integer"},
+                    "component_name": {"type": "string"},
+                },
+                "required": ["action", "instance_id", "component_name"],
+            },
+            {
+                "description": "Get the serialized-field schema for a component type",
+                "properties": {
+                    "action": {"const": "get_schema"},
+                    "instance_id": {"type": "integer"},
+                    "component_name": {"type": "string"},
+                },
+                "required": ["action", "instance_id", "component_name"],
+            },
+            {
+                "description": "Batch-update multiple properties on a component",
+                "properties": {
+                    "action": {"const": "update_properties"},
+                    "instance_id": {"type": "integer"},
+                    "component_name": {"type": "string"},
+                    "properties": {"type": "object"},
+                },
+                "required": ["action", "instance_id", "component_name", "properties"],
+            },
+            {
+                "description": "Set a single serialized property by name",
+                "properties": {
+                    "action": {"const": "set_property"},
+                    "instance_id": {"type": "integer"},
+                    "property_name": {"type": "string"},
+                    "value": {"type": "string"},
+                },
+                "required": ["action", "instance_id", "property_name", "value"],
+            },
+            {
+                "description": "Enable or disable a component",
+                "properties": {
+                    "action": {"const": "set_enabled"},
+                    "instance_id": {"type": "integer"},
+                    "component_name": {"type": "string"},
+                    "enabled": {"type": "boolean"},
+                },
+                "required": ["action", "instance_id", "component_name", "enabled"],
+            },
+        ],
+    },
+}
+
+SEARCH_MANAGER_TOOL: JsonObject = {
+    "name": "unity_search_manager",
+    "description": "Unified discovery and reference search",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Find objects by name regex, tag, or type",
+                "properties": {
+                    "strategy": {"const": "regex"},
+                    "query": {"type": "string"},
+                    "tag": {"type": "string"},
+                    "type": {"type": "string"},
+                },
+                "required": ["strategy"],
+            },
+            {
+                "description": "Find a single object by its scene hierarchy path",
+                "properties": {"strategy": {"const": "path"}, "query": {"type": "string"}},
+                "required": ["strategy", "query"],
+            },
+            {
+                "description": "Find objects using a natural-language semantic query",
+                "properties": {"strategy": {"const": "semantic"}, "query": {"type": "string"}},
+                "required": ["strategy", "query"],
+            },
+            {
+                "description": "Find all objects that reference a specific asset or component",
+                "properties": {
+                    "strategy": {"const": "references"},
+                    "target_id": {"type": "integer"},
+                    "target_guid": {"type": "string"},
+                },
+                "required": ["strategy"],
+            },
+        ],
+    },
+}
+
+ASSET_MANAGER_TOOL: JsonObject = {
+    "name": "unity_asset_manager",
+    "description": "Unified asset and prefab pipeline management",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Search for assets by filter string",
+                "properties": {"action": {"const": "search"}, "filter": {"type": "string"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Explore metadata and sub-assets at a given asset path",
+                "properties": {"action": {"const": "explore"}, "path": {"type": "string"}},
+                "required": ["action", "path"],
+            },
+            {
+                "description": "Create a new material asset",
+                "properties": {
+                    "action": {"const": "create_material"},
+                    "name": {"type": "string"},
+                    "shader": {"type": "string"},
+                    "path": {"type": "string"},
+                    "base_color": {"type": "string"},
+                    "color": {"type": "string"},
+                    "emission_color": {"type": "string"},
+                    "emission": {"type": "string"},
+                },
+                "required": ["action", "name"],
+            },
+            {
+                "description": "Import an asset from disk into the Unity project",
+                "properties": {"action": {"const": "import"}, "path": {"type": "string"}},
+                "required": ["action", "path"],
+            },
+            {
+                "description": "Refresh the AssetDatabase to pick up filesystem changes",
+                "properties": {"action": {"const": "refresh"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Instantiate a prefab from its asset path into the active scene",
+                "properties": {"action": {"const": "instantiate_prefab"}, "path": {"type": "string"}},
+                "required": ["action", "path"],
+            },
+            {
+                "description": "Create a new prefab asset from an existing scene GameObject",
+                "properties": {
+                    "action": {"const": "create_prefab"},
+                    "instance_id": {"type": "integer"},
+                    "path": {"type": "string"},
+                },
+                "required": ["action", "instance_id", "path"],
+            },
+            {
+                "description": "Apply all prefab instance overrides back to the prefab asset",
+                "properties": {"action": {"const": "apply_overrides"}, "instance_id": {"type": "integer"}},
+                "required": ["action", "instance_id"],
+            },
+            {
+                "description": "Revert all prefab instance overrides to match the prefab asset",
+                "properties": {"action": {"const": "revert_overrides"}, "instance_id": {"type": "integer"}},
+                "required": ["action", "instance_id"],
+            },
+        ],
+    },
+}
diff --git a/Editor/nexus_bridge/schemas_components.py.meta b/Editor/nexus_bridge/schemas_components.py.meta
new file mode 100644
index 0000000..cbfeb9a
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_components.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3f782f35a4b742db81161a6ab0e30c23
diff --git a/Editor/nexus_bridge/schemas_diagnostics.py b/Editor/nexus_bridge/schemas_diagnostics.py
new file mode 100644
index 0000000..39914c6
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_diagnostics.py
@@ -0,0 +1,94 @@
+"""Diagnostic, resource, and PlayerPrefs tool schemas for NexusUnity."""
+
+from __future__ import annotations
+
+from typing import Any
+
+JsonObject = dict[str, Any]
+
+PLAYERPREFS_MANAGER_TOOL: JsonObject = {
+    "name": "unity_playerprefs_manager",
+    "description": "Unified PlayerPrefs management",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Read a PlayerPref value by key",
+                "properties": {
+                    "action": {"const": "get"},
+                    "key": {"type": "string"},
+                    "type": {"type": "string", "enum": ["string", "int", "float"]},
+                },
+                "required": ["action", "key"],
+            },
+            {
+                "description": "Write a PlayerPref value",
+                "properties": {
+                    "action": {"const": "set"},
+                    "key": {"type": "string"},
+                    "value": {"type": "string"},
+                    "type": {"type": "string", "enum": ["string", "int", "float"]},
+                },
+                "required": ["action", "key", "value"],
+            },
+            {
+                "description": "Delete a PlayerPref entry by key; use key 'all' with confirm true to clear all PlayerPrefs",
+                "properties": {
+                    "action": {"const": "delete"},
+                    "key": {"type": "string"},
+                    "confirm": {"type": "boolean"},
+                },
+                "required": ["action", "key"],
+            },
+            {
+                "description": "List all stored PlayerPref keys and their values",
+                "properties": {"action": {"const": "list"}},
+                "required": ["action"],
+            },
+        ],
+    },
+}
+
+DIAGNOSTIC_TOOLS: list[JsonObject] = [
+    {
+        "name": "unity_invoke_method",
+        "description": "Invoke a C# method on a component via reflection",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "instance_id": {"type": "integer"},
+                "component_name": {"type": "string"},
+                "method_name": {"type": "string"},
+                "arguments": {"type": "array"},
+            },
+            "required": ["instance_id", "method_name"],
+        },
+    },
+    {
+        "name": "unity_dump_scene_graph",
+        "description": "Dump recursive tree of active scene with components and key fields",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "root_id": {"type": "integer"},
+                "max_depth": {"type": "integer"},
+                "include_all_properties": {"type": "boolean"},
+            },
+        },
+    },
+    {
+        "name": "unity_get_scene_dependencies",
+        "description": "Return a scene-wide dependency map of cross-object references",
+        "inputSchema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "unity_lint_project",
+        "description": "Run Roslyn-based C# audit of the entire project",
+        "inputSchema": {"type": "object", "properties": {}},
+    },
+]
+
+STATIC_RESOURCES: list[JsonObject] = [
+    {"uri": "unity://docs/api-reference", "name": "API Reference", "mimeType": "text/markdown"},
+    {"uri": "unity://docs/setup", "name": "Setup Guide", "mimeType": "text/markdown"},
+]
diff --git a/Editor/nexus_bridge/schemas_diagnostics.py.meta b/Editor/nexus_bridge/schemas_diagnostics.py.meta
new file mode 100644
index 0000000..819919a
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_diagnostics.py.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a1e8f73b9d04423ab817992c3a502a11
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Editor/nexus_bridge/schemas_editor.py b/Editor/nexus_bridge/schemas_editor.py
new file mode 100644
index 0000000..f25999c
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_editor.py
@@ -0,0 +1,181 @@
+"""Editor controller, wait, and compilation tool schemas for NexusUnity."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .schemas_diagnostics import (
+    DIAGNOSTIC_TOOLS,
+    PLAYERPREFS_MANAGER_TOOL,
+    STATIC_RESOURCES,
+)
+from .schemas_ui import UI_AUTOMATION_TOOL
+
+JsonObject = dict[str, Any]
+
+EDITOR_CONTROLLER_TOOL: JsonObject = {
+    "name": "unity_editor_controller",
+    "description": "Unified editor state and play mode control",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Undo the last editor action",
+                "properties": {"action": {"const": "undo"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Redo the previously undone editor action",
+                "properties": {"action": {"const": "redo"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Enter or exit Play Mode",
+                "properties": {"action": {"const": "play"}, "state": {"type": "boolean"}},
+                "required": ["action", "state"],
+            },
+            {
+                "description": "Pause or unpause Play Mode",
+                "properties": {"action": {"const": "pause"}, "state": {"type": "boolean"}},
+                "required": ["action", "state"],
+            },
+            {
+                "description": "Advance Play Mode by one frame while paused",
+                "properties": {"action": {"const": "step"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Execute an editor menu item by its path (e.g. 'File/Save')",
+                "properties": {"action": {"const": "menu"}, "item_path": {"type": "string"}},
+                "required": ["action", "item_path"],
+            },
+            {
+                "description": "Read recent Unity console log entries",
+                "properties": {"action": {"const": "read_logs"}, "count": {"type": "integer"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Clear all Unity console log entries",
+                "properties": {"action": {"const": "clear_logs"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Get the current editor state (play mode, compiling, etc.)",
+                "properties": {"action": {"const": "get_state"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Get the Nexus Unity server status and version info",
+                "properties": {"action": {"const": "get_server_status"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Refresh the AssetDatabase",
+                "properties": {"action": {"const": "refresh_assets"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Trigger a Unity Test Runner run without waiting for results",
+                "properties": {
+                    "action": {"const": "run_tests"},
+                    "mode": {"type": "string"},
+                    "filter": {"type": "string"},
+                },
+                "required": ["action"],
+            },
+            {
+                "description": "Retrieve the most recent Test Runner results XML",
+                "properties": {"action": {"const": "get_test_results"}, "result_path": {"type": "string"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Run tests and block until results are available (or timeout)",
+                "properties": {
+                    "action": {"const": "run_tests_wait"},
+                    "mode": {"type": "string"},
+                    "filter": {"type": "string"},
+                    "timeout_seconds": {"type": "integer"},
+                    "poll_interval_seconds": {"type": "number"},
+                },
+                "required": ["action"],
+            },
+            {
+                "description": "Get per-tool invocation statistics",
+                "properties": {"action": {"const": "get_tool_usage_stats"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Reset all per-tool invocation statistics counters",
+                "properties": {"action": {"const": "reset_tool_usage_stats"}},
+                "required": ["action"],
+            },
+        ],
+    },
+}
+
+WAIT_TOOL: JsonObject = {
+    "name": "unity_wait",
+    "description": "Wait for specific Unity editor states or events",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Wait until script compilation and domain reload finishes",
+                "properties": {"condition": {"const": "compilation"}, "timeout_seconds": {"type": "integer"}},
+                "required": ["condition"],
+            },
+            {
+                "description": "Wait until Play Mode reaches the specified state (true=playing, false=stopped)",
+                "properties": {
+                    "condition": {"const": "play_mode"},
+                    "state": {"type": "boolean"},
+                    "timeout_seconds": {"type": "integer"},
+                },
+                "required": ["condition", "state"],
+            },
+            {
+                "description": "Wait until all pending asset imports are complete",
+                "properties": {"condition": {"const": "import"}, "timeout_seconds": {"type": "integer"}},
+                "required": ["condition"],
+            },
+            {
+                "description": "Wait until the editor is fully idle (not compiling, importing, or playing)",
+                "properties": {"condition": {"const": "editor_idle"}, "timeout_seconds": {"type": "integer"}},
+                "required": ["condition"],
+            },
+        ],
+    },
+}
+
+WRITE_AND_COMPILE_TOOL: JsonObject = {
+    "name": "unity_write_and_compile",
+    "description": "High-level macro: Writes multiple files, waits for domain reload, and returns compiler errors. Use for ALL code changes.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "files": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
+                    "required": ["path", "content"],
+                },
+            },
+            "confirm": {
+                "type": "boolean",
+                "description": "Required when writing .cs files because Unity compilation is triggered",
+            },
+        },
+        "required": ["files"],
+    },
+}
+
+__all__ = [
+    "DIAGNOSTIC_TOOLS",
+    "EDITOR_CONTROLLER_TOOL",
+    "PLAYERPREFS_MANAGER_TOOL",
+    "STATIC_RESOURCES",
+    "UI_AUTOMATION_TOOL",
+    "WAIT_TOOL",
+    "WRITE_AND_COMPILE_TOOL",
+]
diff --git a/Editor/nexus_bridge/schemas_editor.py.meta b/Editor/nexus_bridge/schemas_editor.py.meta
new file mode 100644
index 0000000..3c3a94c
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_editor.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c89f80449a5d401e8d43e16387ff0e87
diff --git a/Editor/nexus_bridge/schemas_managers.py b/Editor/nexus_bridge/schemas_managers.py
new file mode 100644
index 0000000..ab186f5
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_managers.py
@@ -0,0 +1,180 @@
+"""Scene and hierarchy manager tool schemas for NexusUnity."""
+
+from __future__ import annotations
+
+from typing import Any
+
+JsonObject = dict[str, Any]
+
+VECTOR3_SCHEMA: JsonObject = {
+    "oneOf": [
+        {
+            "type": "object",
+            "properties": {
+                "x": {"type": "number"},
+                "y": {"type": "number"},
+                "z": {"type": "number"},
+            },
+        },
+        {
+            "type": "array",
+            "items": {"type": "number"},
+            "minItems": 3,
+            "maxItems": 3,
+        },
+    ],
+}
+
+SCENE_MANAGER_TOOL: JsonObject = {
+    "name": "unity_scene_manager",
+    "description": "Unified scene management (create, open, save, list)",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "properties": {
+                    "action": {"type": "string", "enum": ["create", "create_scene"]},
+                    "name": {"type": "string"},
+                    "path": {"type": "string"},
+                    "open_if_exists": {"type": "boolean"},
+                },
+                "required": ["action"],
+            },
+            {
+                "properties": {
+                    "action": {"type": "string", "enum": ["open", "open_scene"]},
+                    "path": {"type": "string"},
+                },
+                "required": ["action", "path"],
+            },
+            {
+                "properties": {
+                    "action": {"type": "string", "enum": ["save", "save_scene"]},
+                    "path": {"type": "string"},
+                },
+                "required": ["action"],
+            },
+            {"properties": {"action": {"type": "string", "enum": ["list", "list_scenes"]}}, "required": ["action"]},
+        ],
+    },
+}
+
+HIERARCHY_MANAGER_TOOL: JsonObject = {
+    "name": "unity_hierarchy_manager",
+    "description": "Unified GameObject hierarchy and lifecycle management",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "Create an empty GameObject, including common create-action aliases",
+                "properties": {
+                    "action": {
+                        "type": "string",
+                        "enum": ["create_empty", "create", "create_gameobject", "create_game_object"],
+                    },
+                    "name": {"type": "string"},
+                    "parent_id": {"type": "integer"},
+                    "position": VECTOR3_SCHEMA,
+                    "rotation": VECTOR3_SCHEMA,
+                    "scale": VECTOR3_SCHEMA,
+                    "eulerAngles": VECTOR3_SCHEMA,
+                    "localScale": VECTOR3_SCHEMA,
+                },
+                "required": ["action", "name"],
+            },
+            {
+                "description": "Create a primitive GameObject",
+                "properties": {
+                    "action": {"const": "create_primitive"},
+                    "primitive_type": {
+                        "type": "string",
+                        "enum": ["Cube", "Sphere", "Capsule", "Cylinder", "Plane", "Quad"],
+                    },
+                    "name": {"type": "string"},
+                    "parent_id": {"type": "integer"},
+                    "position": VECTOR3_SCHEMA,
+                    "rotation": VECTOR3_SCHEMA,
+                    "scale": VECTOR3_SCHEMA,
+                    "material_path": {"type": "string"},
+                },
+                "required": ["action", "primitive_type"],
+            },
+            {
+                "description": "Batch-create a hierarchy of GameObjects",
+                "properties": {
+                    "action": {"const": "create_hierarchy"},
+                    "tree": {"type": "object"},
+                    "parent_id": {"type": "integer"},
+                },
+                "required": ["action", "tree"],
+            },
+            {
+                "description": "Destroy a GameObject",
+                "properties": {
+                    "action": {"const": "destroy"},
+                    "instance_id": {"type": "integer"},
+                },
+                "required": ["action", "instance_id"],
+            },
+            {
+                "description": "Duplicate a GameObject",
+                "properties": {
+                    "action": {"const": "duplicate"},
+                    "instance_id": {"type": "integer"},
+                },
+                "required": ["action", "instance_id"],
+            },
+            {
+                "description": "Rename a GameObject, including the rename alias",
+                "properties": {
+                    "action": {"type": "string", "enum": ["rename", "set_name"]},
+                    "instance_id": {"type": "integer"},
+                    "name": {"type": "string"},
+                    "new_name": {"type": "string"},
+                },
+                "required": ["action", "instance_id"],
+                "anyOf": [{"required": ["name"]}, {"required": ["new_name"]}],
+            },
+            {
+                "description": "Move, rotate, or scale a GameObject, including the transform alias",
+                "properties": {
+                    "action": {"type": "string", "enum": ["set_transform", "transform"]},
+                    "instance_id": {"type": "integer"},
+                    "position": VECTOR3_SCHEMA,
+                    "rotation": VECTOR3_SCHEMA,
+                    "scale": VECTOR3_SCHEMA,
+                    "eulerAngles": VECTOR3_SCHEMA,
+                    "localScale": VECTOR3_SCHEMA,
+                },
+                "required": ["action", "instance_id"],
+            },
+            {
+                "description": "Enable or disable a GameObject",
+                "properties": {
+                    "action": {"const": "set_active"},
+                    "instance_id": {"type": "integer"},
+                    "active": {"type": "boolean"},
+                },
+                "required": ["action", "instance_id", "active"],
+            },
+            {
+                "description": "Reparent a GameObject",
+                "properties": {
+                    "action": {"const": "set_parent"},
+                    "instance_id": {"type": "integer"},
+                    "parent_id": {"type": "integer"},
+                },
+                "required": ["action", "instance_id", "parent_id"],
+            },
+            {
+                "description": "Reorder a GameObject within its siblings",
+                "properties": {
+                    "action": {"const": "set_sibling_index"},
+                    "instance_id": {"type": "integer"},
+                    "index": {"oneOf": [{"type": "integer"}, {"type": "string", "enum": ["first", "last"]}]},
+                },
+                "required": ["action", "instance_id", "index"],
+            },
+        ],
+    },
+}
diff --git a/Editor/nexus_bridge/schemas_managers.py.meta b/Editor/nexus_bridge/schemas_managers.py.meta
new file mode 100644
index 0000000..014e280
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_managers.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b9a1e809cfa44c75b3a111a437209170
diff --git a/Editor/nexus_bridge/schemas_ui.py b/Editor/nexus_bridge/schemas_ui.py
new file mode 100644
index 0000000..7fd9825
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_ui.py
@@ -0,0 +1,94 @@
+"""UI automation tool schemas for NexusUnity."""
+
+from __future__ import annotations
+
+from typing import Any
+
+JsonObject = dict[str, Any]
+
+UI_AUTOMATION_TOOL: JsonObject = {
+    "name": "unity_ui_automation",
+    "description": "Unified UI Toolkit window automation",
+    "inputSchema": {
+        "type": "object",
+        "oneOf": [
+            {
+                "description": "List all open editor windows",
+                "properties": {"action": {"const": "list_windows"}},
+                "required": ["action"],
+            },
+            {
+                "description": "Get the UI element hierarchy for a window",
+                "properties": {
+                    "action": {"const": "get_hierarchy"},
+                    "window_title": {"type": "string"},
+                    "deep": {"type": "boolean"},
+                    "max_depth": {"type": "integer"},
+                    "max_elements": {"type": "integer"},
+                },
+                "required": ["action", "window_title"],
+            },
+            {
+                "description": "Query UI elements by name, text, or class within a window",
+                "properties": {
+                    "action": {"const": "query"},
+                    "window_title": {"type": "string"},
+                    "name": {"type": "string"},
+                    "text": {"type": "string"},
+                    "class_name": {"type": "string"},
+                    "max_depth": {"type": "integer"},
+                    "max_results": {"type": "integer"},
+                },
+                "required": ["action", "window_title"],
+            },
+            {
+                "description": "Get the screen rect (position and size) of a window",
+                "properties": {"action": {"const": "get_window_rect"}, "window_title": {"type": "string"}},
+                "required": ["action", "window_title"],
+            },
+            {
+                "description": "Reposition and resize a window",
+                "properties": {
+                    "action": {"const": "set_window_rect"},
+                    "window_title": {"type": "string"},
+                    "x": {"type": "number"},
+                    "y": {"type": "number"},
+                    "width": {"type": "number"},
+                    "height": {"type": "number"},
+                },
+                "required": ["action", "window_title"],
+            },
+            {
+                "description": "Capture a screenshot and/or UI hierarchy snapshot of a window",
+                "properties": {
+                    "action": {"const": "capture_window_snapshot"},
+                    "window_title": {"type": "string"},
+                    "include_image": {"type": "boolean"},
+                    "include_hierarchy": {"type": "boolean"},
+                    "max_depth": {"type": "integer"},
+                    "max_elements": {"type": "integer"},
+                },
+                "required": ["action", "window_title"],
+            },
+            {
+                "description": "Click a named UI element inside a window",
+                "properties": {
+                    "action": {"const": "click"},
+                    "window_title": {"type": "string"},
+                    "element_name": {"type": "string"},
+                },
+                "required": ["action", "window_title", "element_name"],
+            },
+            {
+                "description": "Type text into a named UI input element inside a window",
+                "properties": {
+                    "action": {"const": "input"},
+                    "window_title": {"type": "string"},
+                    "element_name": {"type": "string"},
+                    "text": {"type": "string"},
+                },
+                "required": ["action", "window_title", "element_name", "text"],
+            },
+        ],
+    },
+}
diff --git a/Editor/nexus_bridge/schemas_ui.py.meta b/Editor/nexus_bridge/schemas_ui.py.meta
new file mode 100644
index 0000000..5e57829
--- /dev/null
+++ b/Editor/nexus_bridge/schemas_ui.py.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b2f9e84c0e15434bc928003d4b613b22
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Editor/tests/test_routing.py b/Editor/tests/test_routing.py
deleted file mode 100644
index 6a7ad16..0000000
--- a/Editor/tests/test_routing.py
+++ /dev/null
@@ -1,388 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-import unittest
-from typing import Any
-from unittest.mock import Mock, call, patch
-
-EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if EDITOR_DIR not in sys.path:
-    sys.path.insert(0, EDITOR_DIR)
-
-from nexus_bridge import routing
-
-
-class RouteToolDispatchTests(unittest.TestCase):
-    def test_route_tool_uses_registered_handler(self) -> None:
-        handler = Mock(return_value={"result": {"handled": True}})
-
-        with patch.dict(routing._HANDLERS, {"synthetic": handler}, clear=True):
-            with patch("nexus_bridge.routing.call_unity") as mock_call_unity:
-                response: dict[str, Any] = routing.route_tool("synthetic", {"value": 7})
-
-        self.assertEqual({"result": {"handled": True}}, response)
-        handler.assert_called_once_with({"value": 7})
-        mock_call_unity.assert_not_called()
-
-    def test_route_tool_falls_back_to_call_unity_for_unknown_route(self) -> None:
-        with patch("nexus_bridge.routing.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
-            response: dict[str, Any] = routing.route_tool("invoke_method", {"instance_id": 42})
-
-        self.assertEqual({"result": {"ok": True}}, response)
-        mock_call_unity.assert_called_once_with("invoke_method", {"instance_id": 42})
-
-    def test_route_tool_dispatches_to_expected_unity_methods(self) -> None:
-        test_cases: list[tuple[str, dict[str, Any], str, tuple[Any, ...]]] = [
-            (
-                "scene_manager",
-                {"action": "open", "path": "Assets/TestScene.unity"},
-                "open_scene",
-                ({"path": "Assets/TestScene.unity"},),
-            ),
-            (
-                "hierarchy_manager",
-                {"action": "destroy", "instance_id": 42},
-                "destroy_game_object",
-                ({"instance_id": 42},),
-            ),
-            (
-                "hierarchy_manager",
-                {"action": "set_sibling_index", "instance_id": 42, "index": 2},
-                "set_sibling_index",
-                ({"instance_id": 42, "index": 2},),
-            ),
-            (
-                "component_manager",
-                {"action": "add", "instance_id": 42, "component_name": "BoxCollider"},
-                "add_component",
-                ({"instance_id": 42, "component_name": "BoxCollider"},),
-            ),
-            (
-                "search_manager",
-                {"strategy": "path", "query": "/Canvas/Button"},
-                "find_by_path",
-                ({"path": "/Canvas/Button"},),
-            ),
-            ("asset_manager", {"action": "refresh"}, "refresh_asset_database", tuple()),
-            ("editor_controller", {"action": "get_state"}, "get_editor_state", tuple()),
-            ("ui_automation", {"action": "list_windows"}, "ui_list_windows", tuple()),
-            ("playerprefs_manager", {"action": "list"}, "list_player_prefs", tuple()),
-        ]
-
-        for route_name, route_args, unity_method, unity_params in test_cases:
-            with self.subTest(route_name=route_name):
-                with patch("nexus_bridge.routing.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
-                    response: dict[str, Any] = routing.route_tool(route_name, route_args)
-
-                self.assertEqual({"result": {"ok": True}}, response)
-                mock_call_unity.assert_called_once_with(unity_method, *unity_params)
-
-    def test_apply_created_transform_accepts_zero_instance_id(self) -> None:
-        response: dict[str, Any] = {"result": {"data": {"instance_id": 0}}}
-        args: dict[str, Any] = {"position": {"x": 1, "y": 2, "z": 3}}
-
-        with patch("nexus_bridge.routing.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
-            returned = routing._apply_created_transform(response, args)
-
-        self.assertIs(returned, response)
-        mock_call_unity.assert_called_once_with(
-            "set_transform",
-            {"instance_id": 0, "position": {"x": 1, "y": 2, "z": 3}},
-        )
-
-
-class RouteHandlerTests(unittest.TestCase):
-    def test_scene_manager_create_alias_routes_to_create_scene(self) -> None:
-        with patch("nexus_bridge.routing.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
-            response: dict[str, Any] = routing._route_scene_manager(
-                {"action": "create_scene", "name": "Arena", "open_if_exists": True}
-            )
-
-        self.assertEqual({"result": {"ok": True}}, response)
-        mock_call_unity.assert_called_once_with(
-            "create_scene",
-            {"name": "Arena", "open_if_exists": True},
-        )
-
-    def test_scene_manager_invalid_action_returns_error(self) -> None:
-        response: dict[str, Any] = routing._route_scene_manager({"action": "delete"})
-
-        self.assertEqual(-32602, response["error"]["code"])
-        self.assertIn("Invalid action: delete", response["error"]["message"])
-
-    def test_editor_controller_run_tests_wait_delegates_to_helper(self) -> None:
-        expected_response: dict[str, Any] = {"result": {"status": "Success"}}
-
-        with patch("nexus_bridge.routing._run_tests_wait", return_value=expected_response) as mock_run_tests_wait:
-            response: dict[str, Any] = routing._route_editor_controller(
-                {"action": "run_tests_wait", "timeout_seconds": 9}
-            )
-
-        self.assertEqual(expected_response, response)
-        mock_run_tests_wait.assert_called_once_with({"action": "run_tests_wait", "timeout_seconds": 9})
-
-    def test_playerprefs_delete_forwards_confirm(self) -> None:
-        with patch("nexus_bridge.routing.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
-            response: dict[str, Any] = routing._route_playerprefs_manager(
-                {"action": "delete", "key": "all", "confirm": True}
-            )
-
-        self.assertEqual({"result": {"ok": True}}, response)
-        mock_call_unity.assert_called_once_with("delete_player_pref", {"key": "all", "confirm": True})
-
-    def test_hierarchy_manager_create_applies_transform_after_create(self) -> None:
-        create_response: dict[str, Any] = {"result": {"data": {"instance_id": 12}}}
-        transform_response: dict[str, Any] = {"result": {"ok": True}}
-
-        with patch(
-            "nexus_bridge.routing.call_unity", side_effect=[create_response, transform_response]
-        ) as mock_call_unity:
-            response: dict[str, Any] = routing._route_hierarchy_manager(
-                {"action": "create", "name": "Cube", "position": {"x": 1, "y": 2, "z": 3}}
-            )
-
-        self.assertEqual(create_response, response)
-        self.assertEqual(
-            [
-                call("create_game_object", {"name": "Cube"}),
-                call("set_transform", {"instance_id": 12, "position": {"x": 1, "y": 2, "z": 3}}),
-            ],
-            mock_call_unity.call_args_list,
-        )
-
-
-class WriteAndCompileTests(unittest.TestCase):
-    def test_write_and_compile_returns_write_errors_without_waiting(self) -> None:
-        files = [
-            {"path": "Assets/One.cs", "content": "one"},
-            {"path": "Assets/Two.cs", "content": "two"},
-        ]
-        call_results: list[dict[str, Any] | None] = [
-            None,
-            {"error": {"code": -32000, "message": "disk full"}},
-            {"result": {"ok": True}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            with patch("nexus_bridge.routing._wait_for_compilation") as mock_wait_for_compilation:
-                response: dict[str, Any] = routing._route_write_and_compile({"files": files, "confirm": True})
-
-        self.assertEqual("Failed", response["result"]["status"])
-        self.assertEqual("Failed to write some files", response["result"]["message"])
-        self.assertEqual(
-            [{"path": "Assets/One.cs", "error": {"code": -32000, "message": "disk full"}}],
-            response["result"]["errors"],
-        )
-        mock_wait_for_compilation.assert_not_called()
-        self.assertEqual(
-            [
-                call("clear_logs"),
-                call("write_file", {"path": "Assets/One.cs", "content": "one", "confirm": True}),
-                call("write_file", {"path": "Assets/Two.cs", "content": "two", "confirm": True}),
-            ],
-            mock_call_unity.call_args_list,
-        )
-
-    def test_write_and_compile_waits_and_filters_compiler_errors(self) -> None:
-        files = [{"path": "Assets/Test.cs", "content": "class Test {}"}]
-        wait_response: dict[str, Any] = {"result": {"status": "Ready", "time_waited_seconds": 1.5}}
-        log_response: dict[str, Any] = {
-            "result": {
-                "logs": [
-                    {"Type": "Error", "Message": "compile failed"},
-                    {"Type": "Assert", "Message": "assertion"},
-                    {"Type": "Log", "Message": "ignore"},
-                ]
-            }
-        }
-
-        with patch("nexus_bridge.routing.time.time", return_value=10.0):
-            with patch(
-                "nexus_bridge.routing.call_unity", side_effect=[None, {"result": {"ok": True}}, log_response]
-            ) as mock_call_unity:
-                with patch(
-                    "nexus_bridge.routing._wait_for_compilation", return_value=wait_response
-                ) as mock_wait_for_compilation:
-                    response: dict[str, Any] = routing._route_write_and_compile({"files": files, "confirm": True})
-
-        self.assertEqual("Failed", response["result"]["status"])
-        self.assertEqual(1.5, response["result"]["time_waited_seconds"])
-        self.assertEqual(
-            [
-                {"Type": "Error", "Message": "compile failed"},
-                {"Type": "Assert", "Message": "assertion"},
-            ],
-            response["result"]["compiler_errors"],
-        )
-        mock_wait_for_compilation.assert_called_once_with(timeout=90, start_time=10.0)
-        self.assertEqual(
-            [
-                call("clear_logs"),
-                call("write_file", {"path": "Assets/Test.cs", "content": "class Test {}", "confirm": True}),
-                call("read_logs", {"count": 200}),
-            ],
-            mock_call_unity.call_args_list,
-        )
-
-
-class RunTestsWaitTests(unittest.TestCase):
-    def test_run_tests_wait_returns_success_when_new_results_appear(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
-            {"result": {"status": "Submitted", "result_path": "/tmp/TestResults.xml"}},
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:03Z"}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            with patch("nexus_bridge.routing.time.time", side_effect=[100.0, 100.0, 103.25]):
-                with patch("nexus_bridge.routing.time.sleep") as mock_sleep:
-                    response: dict[str, Any] = routing._run_tests_wait({})
-
-        self.assertEqual("Success", response["result"]["status"])
-        self.assertEqual(3.25, response["result"]["time_waited_seconds"])
-        self.assertEqual("2026-06-11T00:00:03Z", response["result"]["timestamp_utc"])
-        mock_sleep.assert_not_called()
-        mock_call_unity.assert_has_calls(
-            [
-                call("get_test_results"),
-                call("run_tests", {"mode": "EditMode"}),
-                call("get_test_results", {"result_path": "/tmp/TestResults.xml"}),
-            ]
-        )
-
-    def test_run_tests_wait_accepts_legacy_success_trigger(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
-            {"result": {"status": "Success", "result_path": "/tmp/TestResults.xml"}},
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:03Z"}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            with patch("nexus_bridge.routing.time.time", side_effect=[100.0, 100.0, 103.25]):
-                response: dict[str, Any] = routing._run_tests_wait({})
-
-        self.assertEqual("Success", response["result"]["status"])
-        self.assertEqual(3, mock_call_unity.call_count)
-
-    def test_run_tests_wait_returns_timeout_when_results_do_not_change(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
-            {"result": {"status": "Submitted", "result_path": "/tmp/TestResults.xml"}},
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results):
-            with patch("nexus_bridge.routing.time.time", side_effect=[0.0, 0.0, 5.1, 5.1]):
-                with patch("nexus_bridge.routing.time.sleep") as mock_sleep:
-                    response: dict[str, Any] = routing._run_tests_wait({"timeout_seconds": 5.0})
-
-        self.assertEqual("Timeout", response["result"]["status"])
-        self.assertEqual("/tmp/TestResults.xml", response["result"]["result_path"])
-        self.assertEqual(5.1, response["result"]["time_waited_seconds"])
-        self.assertEqual("Timed out waiting for a new Unity TestResults XML file.", response["result"]["message"])
-        mock_sleep.assert_called_once_with(1.0)
-
-    def test_run_tests_wait_returns_non_submitted_trigger_without_polling(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
-            {"result": {"status": "Error", "message": "A test run is already active."}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            response: dict[str, Any] = routing._run_tests_wait({})
-
-        self.assertEqual("Error", response["result"]["status"])
-        self.assertEqual("A test run is already active.", response["result"]["message"])
-        mock_call_unity.assert_has_calls(
-            [
-                call("get_test_results"),
-                call("run_tests", {"mode": "EditMode"}),
-            ]
-        )
-        self.assertEqual(2, mock_call_unity.call_count)
-
-
-class WaitForCompilationTests(unittest.TestCase):
-    def test_wait_for_compilation_returns_ready_when_editor_finishes_compiling(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"error": {"code": -32000, "message": "reload in progress"}},
-            {"result": {}},
-            {"result": {"is_compiling": False, "is_updating": False}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            with patch("nexus_bridge.routing.time.time", side_effect=[100.0, 100.0, 101.0, 103.0]):
-                with patch("nexus_bridge.routing.time.sleep") as mock_sleep:
-                    response: dict[str, Any] = routing._wait_for_compilation(timeout=30.0)
-
-        self.assertEqual({"result": {"status": "Ready", "time_waited_seconds": 3.0}}, response)
-        self.assertEqual(
-            [
-                call("initialize"),
-                call("initialize"),
-                call("get_editor_state"),
-            ],
-            mock_call_unity.call_args_list,
-        )
-        mock_sleep.assert_has_calls([call(2.0)])
-
-    def test_wait_for_compilation_returns_timeout_after_refresh(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"result": {}},
-            {"result": {}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            with patch("nexus_bridge.routing.time.time", side_effect=[0.0, 0.0, 21.0, 21.0, 22.0]):
-                with patch("nexus_bridge.routing.time.sleep") as mock_sleep:
-                    response: dict[str, Any] = routing._wait_for_compilation(timeout=10.0)
-
-        self.assertEqual({"result": {"status": "Timeout", "time_waited_seconds": 22.0}}, response)
-        self.assertEqual(
-            [
-                call("initialize"),
-                call("refresh_asset_database"),
-            ],
-            mock_call_unity.call_args_list,
-        )
-        mock_sleep.assert_called_once_with(0.5)
-
-    def test_wait_for_compilation_respects_timeout_smaller_than_reload_probe_window(self) -> None:
-        call_results: list[dict[str, Any]] = [
-            {"result": {}},
-            {"result": {}},
-        ]
-
-        with patch("nexus_bridge.routing.call_unity", side_effect=call_results) as mock_call_unity:
-            with patch("nexus_bridge.routing.time.time", side_effect=[100.0, 100.0, 105.1, 105.1, 106.1]):
-                with patch("nexus_bridge.routing.time.sleep") as mock_sleep:
-                    response: dict[str, Any] = routing._wait_for_compilation(timeout=5.0)
-
-        self.assertEqual({"result": {"status": "Timeout", "time_waited_seconds": 6.1}}, response)
-        self.assertEqual(
-            [
-                call("initialize"),
-                call("refresh_asset_database"),
-            ],
-            mock_call_unity.call_args_list,
-        )
-        mock_sleep.assert_called_once_with(0.5)
-
-    def test_wait_route_delegates_compilation_condition_to_helper(self) -> None:
-        expected_response: dict[str, Any] = {"result": {"status": "Ready", "time_waited_seconds": 4.5}}
-
-        with patch(
-            "nexus_bridge.routing._wait_for_compilation", return_value=expected_response
-        ) as mock_wait_for_compilation:
-            with patch("nexus_bridge.routing.time.time", return_value=55.0):
-                response: dict[str, Any] = routing.route_tool(
-                    "wait", {"condition": "compilation", "timeout_seconds": 12.0}
-                )
-
-        self.assertEqual(expected_response, response)
-        mock_wait_for_compilation.assert_called_once_with(timeout=12.0, start_time=55.0)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Editor/tests/test_routing_dispatch.py b/Editor/tests/test_routing_dispatch.py
new file mode 100644
index 0000000..d8c4786
--- /dev/null
+++ b/Editor/tests/test_routing_dispatch.py
@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from typing import Any
+from unittest.mock import Mock, call, patch
+
+EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if EDITOR_DIR not in sys.path:
+    sys.path.insert(0, EDITOR_DIR)
+
+from nexus_bridge import routing
+
+
+class RouteToolDispatchTests(unittest.TestCase):
+    def test_route_tool_uses_registered_handler(self) -> None:
+        handler = Mock(return_value={"result": {"handled": True}})
+
+        with patch.dict(routing._HANDLERS, {"synthetic": handler}, clear=True):
+            with patch("nexus_bridge._transport.call_unity") as mock_call_unity:
+                response: dict[str, Any] = routing.route_tool("synthetic", {"value": 7})
+
+        self.assertEqual({"result": {"handled": True}}, response)
+        handler.assert_called_once_with({"value": 7})
+        mock_call_unity.assert_not_called()
+
+    def test_route_tool_falls_back_to_call_unity_for_unknown_route(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            response: dict[str, Any] = routing.route_tool("invoke_method", {"instance_id": 42})
+
+        self.assertEqual({"result": {"ok": True}}, response)
+        mock_call_unity.assert_called_once_with("invoke_method", {"instance_id": 42})
+
+    def test_route_tool_dispatches_to_expected_unity_methods(self) -> None:
+        test_cases: list[tuple[str, dict[str, Any], str, tuple[Any, ...]]] = [
+            (
+                "scene_manager",
+                {"action": "open", "path": "Assets/TestScene.unity"},
+                "open_scene",
+                ({"path": "Assets/TestScene.unity"},),
+            ),
+            (
+                "hierarchy_manager",
+                {"action": "destroy", "instance_id": 42},
+                "destroy_game_object",
+                ({"instance_id": 42},),
+            ),
+            (
+                "hierarchy_manager",
+                {"action": "set_sibling_index", "instance_id": 42, "index": 2},
+                "set_sibling_index",
+                ({"instance_id": 42, "index": 2},),
+            ),
+            (
+                "component_manager",
+                {"action": "add", "instance_id": 42, "component_name": "BoxCollider"},
+                "add_component",
+                ({"instance_id": 42, "component_name": "BoxCollider"},),
+            ),
+            (
+                "search_manager",
+                {"strategy": "path", "query": "/Canvas/Button"},
+                "find_by_path",
+                ({"path": "/Canvas/Button"},),
+            ),
+            ("asset_manager", {"action": "refresh"}, "refresh_asset_database", tuple()),
+            ("editor_controller", {"action": "get_state"}, "get_editor_state", tuple()),
+            ("ui_automation", {"action": "list_windows"}, "ui_list_windows", tuple()),
+            ("playerprefs_manager", {"action": "list"}, "list_player_prefs", tuple()),
+        ]
+
+        for route_name, route_args, unity_method, unity_params in test_cases:
+            with self.subTest(route_name=route_name):
+                with patch(
+                    "nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}
+                ) as mock_call_unity:
+                    response: dict[str, Any] = routing.route_tool(route_name, route_args)
+
+                self.assertEqual({"result": {"ok": True}}, response)
+                mock_call_unity.assert_called_once_with(unity_method, *unity_params)
+
+    def test_apply_created_transform_accepts_zero_instance_id(self) -> None:
+        response: dict[str, Any] = {"result": {"data": {"instance_id": 0}}}
+        args: dict[str, Any] = {"position": {"x": 1, "y": 2, "z": 3}}
+
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            returned = routing._apply_created_transform(response, args)
+
+        self.assertIs(returned, response)
+        mock_call_unity.assert_called_once_with(
+            "set_transform",
+            {"instance_id": 0, "position": {"x": 1, "y": 2, "z": 3}},
+        )
+
+
+class RouteHandlerTests(unittest.TestCase):
+    def test_scene_manager_create_alias_routes_to_create_scene(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            response: dict[str, Any] = routing._route_scene_manager(
+                {"action": "create_scene", "name": "Arena", "open_if_exists": True}
+            )
+
+        self.assertEqual({"result": {"ok": True}}, response)
+        mock_call_unity.assert_called_once_with(
+            "create_scene",
+            {"name": "Arena", "open_if_exists": True},
+        )
+
+    def test_scene_manager_invalid_action_returns_error(self) -> None:
+        response: dict[str, Any] = routing._route_scene_manager({"action": "delete"})
+
+        self.assertEqual(-32602, response["error"]["code"])
+        self.assertIn("Invalid action: delete", response["error"]["message"])
+
+    def test_editor_controller_run_tests_wait_delegates_to_helper(self) -> None:
+        expected_response: dict[str, Any] = {"result": {"status": "Success"}}
+
+        with patch("nexus_bridge.routes_editor._run_tests_wait", return_value=expected_response) as mock_run_tests_wait:
+            response: dict[str, Any] = routing._route_editor_controller(
+                {"action": "run_tests_wait", "timeout_seconds": 9}
+            )
+
+        self.assertEqual(expected_response, response)
+        mock_run_tests_wait.assert_called_once_with({"action": "run_tests_wait", "timeout_seconds": 9})
+
+    def test_playerprefs_delete_forwards_confirm(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            response: dict[str, Any] = routing._route_playerprefs_manager(
+                {"action": "delete", "key": "all", "confirm": True}
+            )
+
+        self.assertEqual({"result": {"ok": True}}, response)
+        mock_call_unity.assert_called_once_with("delete_player_pref", {"key": "all", "confirm": True})
+
+    def test_hierarchy_manager_create_applies_transform_after_create(self) -> None:
+        create_response: dict[str, Any] = {"result": {"data": {"instance_id": 12}}}
+        transform_response: dict[str, Any] = {"result": {"ok": True}}
+
+        with patch(
+            "nexus_bridge._transport.call_unity", side_effect=[create_response, transform_response]
+        ) as mock_call_unity:
+            response: dict[str, Any] = routing._route_hierarchy_manager(
+                {"action": "create", "name": "Cube", "position": {"x": 1, "y": 2, "z": 3}}
+            )
+
+        self.assertEqual(create_response, response)
+        self.assertEqual(
+            [
+                call("create_game_object", {"name": "Cube"}),
+                call("set_transform", {"instance_id": 12, "position": {"x": 1, "y": 2, "z": 3}}),
+            ],
+            mock_call_unity.call_args_list,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Editor/tests/test_routing_dispatch.py.meta b/Editor/tests/test_routing_dispatch.py.meta
new file mode 100644
index 0000000..9cf5e80
--- /dev/null
+++ b/Editor/tests/test_routing_dispatch.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 582f019095d64458ba28b243b16571c7
diff --git a/Editor/tests/test_routing_editor.py b/Editor/tests/test_routing_editor.py
new file mode 100644
index 0000000..983fde4
--- /dev/null
+++ b/Editor/tests/test_routing_editor.py
@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from typing import Any
+from unittest.mock import call, patch
+
+EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if EDITOR_DIR not in sys.path:
+    sys.path.insert(0, EDITOR_DIR)
+
+from nexus_bridge import routing
+
+
+class WriteAndCompileTests(unittest.TestCase):
+    def test_write_and_compile_returns_write_errors_without_waiting(self) -> None:
+        files = [
+            {"path": "Assets/One.cs", "content": "one"},
+            {"path": "Assets/Two.cs", "content": "two"},
+        ]
+        call_results: list[dict[str, Any] | None] = [
+            None,
+            {"error": {"code": -32000, "message": "disk full"}},
+            {"result": {"ok": True}},
+        ]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            with patch("nexus_bridge.routes_editor._wait_for_compilation") as mock_wait_for_compilation:
+                response: dict[str, Any] = routing._route_write_and_compile({"files": files, "confirm": True})
+
+        self.assertEqual("Failed", response["result"]["status"])
+        self.assertEqual("Failed to write some files", response["result"]["message"])
+        self.assertEqual(
+            [{"path": "Assets/One.cs", "error": {"code": -32000, "message": "disk full"}}],
+            response["result"]["errors"],
+        )
+        mock_wait_for_compilation.assert_not_called()
+        self.assertEqual(
+            [
+                call("clear_logs"),
+                call("write_file", {"path": "Assets/One.cs", "content": "one", "confirm": True}),
+                call("write_file", {"path": "Assets/Two.cs", "content": "two", "confirm": True}),
+            ],
+            mock_call_unity.call_args_list,
+        )
+
+    def test_write_and_compile_waits_and_filters_compiler_errors(self) -> None:
+        files = [{"path": "Assets/Test.cs", "content": "class Test {}"}]
+        wait_response: dict[str, Any] = {"result": {"status": "Ready", "time_waited_seconds": 1.5}}
+        log_response: dict[str, Any] = {
+            "result": {
+                "logs": [
+                    {"Type": "Error", "Message": "compile failed"},
+                    {"Type": "Assert", "Message": "assertion"},
+                    {"Type": "Log", "Message": "ignore"},
+                ]
+            }
+        }
+
+        with patch("nexus_bridge.routes_editor.time.time", return_value=10.0):
+            with patch(
+                "nexus_bridge._transport.call_unity", side_effect=[None, {"result": {"ok": True}}, log_response]
+            ) as mock_call_unity:
+                with patch(
+                    "nexus_bridge.routes_editor._wait_for_compilation", return_value=wait_response
+                ) as mock_wait_for_compilation:
+                    response: dict[str, Any] = routing._route_write_and_compile({"files": files, "confirm": True})
+
+        self.assertEqual("Failed", response["result"]["status"])
+        self.assertEqual(1.5, response["result"]["time_waited_seconds"])
+        self.assertEqual(
+            [
+                {"Type": "Error", "Message": "compile failed"},
+                {"Type": "Assert", "Message": "assertion"},
+            ],
+            response["result"]["compiler_errors"],
+        )
+        mock_wait_for_compilation.assert_called_once_with(timeout=90, start_time=10.0)
+        self.assertEqual(
+            [
+                call("clear_logs"),
+                call("write_file", {"path": "Assets/Test.cs", "content": "class Test {}", "confirm": True}),
+                call("read_logs", {"count": 200}),
+            ],
+            mock_call_unity.call_args_list,
+        )
+
+
+class RunTestsWaitTests(unittest.TestCase):
+    def test_run_tests_wait_returns_success_when_new_results_appear(self) -> None:
+        call_results: list[dict[str, Any]] = [
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
+            {"result": {"status": "Submitted", "result_path": "/tmp/TestResults.xml"}},
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:03Z"}},
+        ]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            with patch("nexus_bridge.routes_editor.time.time", side_effect=[100.0, 100.0, 103.25]):
+                with patch("nexus_bridge.routes_editor.time.sleep") as mock_sleep:
+                    response: dict[str, Any] = routing._run_tests_wait({})
+
+        self.assertEqual("Success", response["result"]["status"])
+        self.assertEqual(3.25, response["result"]["time_waited_seconds"])
+        self.assertEqual("2026-06-11T00:00:03Z", response["result"]["timestamp_utc"])
+        mock_sleep.assert_not_called()
+        mock_call_unity.assert_has_calls(
+            [
+                call("get_test_results"),
+                call("run_tests", {"mode": "EditMode"}),
+                call("get_test_results", {"result_path": "/tmp/TestResults.xml"}),
+            ]
+        )
+
+    def test_run_tests_wait_accepts_legacy_success_trigger(self) -> None:
+        call_results: list[dict[str, Any]] = [
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
+            {"result": {"status": "Success", "result_path": "/tmp/TestResults.xml"}},
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:03Z"}},
+        ]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            with patch("nexus_bridge.routes_editor.time.time", side_effect=[100.0, 100.0, 103.25]):
+                response: dict[str, Any] = routing._run_tests_wait({})
+
+        self.assertEqual("Success", response["result"]["status"])
+        self.assertEqual(3, mock_call_unity.call_count)
+
+    def test_run_tests_wait_returns_timeout_when_results_do_not_change(self) -> None:
+        call_results: list[dict[str, Any]] = [
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
+            {"result": {"status": "Submitted", "result_path": "/tmp/TestResults.xml"}},
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
+        ]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results):
+            with patch("nexus_bridge.routes_editor.time.time", side_effect=[0.0, 0.0, 5.1, 5.1]):
+                with patch("nexus_bridge.routes_editor.time.sleep") as mock_sleep:
+                    response: dict[str, Any] = routing._run_tests_wait({"timeout_seconds": 5.0})
+
+        self.assertEqual("Timeout", response["result"]["status"])
+        self.assertEqual("/tmp/TestResults.xml", response["result"]["result_path"])
+        self.assertEqual(5.1, response["result"]["time_waited_seconds"])
+        self.assertEqual("Timed out waiting for a new Unity TestResults XML file.", response["result"]["message"])
+        mock_sleep.assert_called_once_with(1.0)
+
+    def test_run_tests_wait_returns_non_submitted_trigger_without_polling(self) -> None:
+        call_results: list[dict[str, Any]] = [
+            {"result": {"status": "Success", "timestamp_utc": "2026-06-11T00:00:00Z"}},
+            {"result": {"status": "Error", "message": "A test run is already active."}},
+        ]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            response: dict[str, Any] = routing._run_tests_wait({})
+
+        self.assertEqual("Error", response["result"]["status"])
+        self.assertEqual("A test run is already active.", response["result"]["message"])
+        mock_call_unity.assert_has_calls(
+            [
+                call("get_test_results"),
+                call("run_tests", {"mode": "EditMode"}),
+            ]
+        )
+        self.assertEqual(2, mock_call_unity.call_count)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Editor/tests/test_routing_editor.py.meta b/Editor/tests/test_routing_editor.py.meta
new file mode 100644
index 0000000..97677bd
--- /dev/null
+++ b/Editor/tests/test_routing_editor.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6048e073251c49108855b2c34c5c6ed0
diff --git a/Editor/tests/test_routing_wait.py b/Editor/tests/test_routing_wait.py
new file mode 100644
index 0000000..e315e76
--- /dev/null
+++ b/Editor/tests/test_routing_wait.py
@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from typing import Any
+from unittest.mock import call, patch
+
+EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if EDITOR_DIR not in sys.path:
+    sys.path.insert(0, EDITOR_DIR)
+
+from nexus_bridge import routing
+
+
+class WaitForCompilationTests(unittest.TestCase):
+    def test_wait_for_compilation_returns_ready_when_editor_finishes_compiling(self) -> None:
+        call_results: list[dict[str, Any]] = [
+            {"error": {"code": -32000, "message": "reload in progress"}},
+            {"result": {}},
+            {"result": {"is_compiling": False, "is_updating": False}},
+        ]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            with patch("nexus_bridge.routes_editor.time.time", side_effect=[100.0, 100.0, 101.0, 103.0]):
+                with patch("nexus_bridge.routes_editor.time.sleep") as mock_sleep:
+                    response: dict[str, Any] = routing._wait_for_compilation(timeout=30.0)
+
+        self.assertEqual({"result": {"status": "Ready", "time_waited_seconds": 3.0}}, response)
+        self.assertEqual(
+            [call("initialize"), call("initialize"), call("get_editor_state")],
+            mock_call_unity.call_args_list,
+        )
+        mock_sleep.assert_has_calls([call(2.0)])
+
+    def test_wait_for_compilation_returns_timeout_after_refresh(self) -> None:
+        call_results: list[dict[str, Any]] = [{"result": {}}, {"result": {}}]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            with patch("nexus_bridge.routes_editor.time.time", side_effect=[0.0, 0.0, 21.0, 21.0, 22.0]):
+                with patch("nexus_bridge.routes_editor.time.sleep") as mock_sleep:
+                    response: dict[str, Any] = routing._wait_for_compilation(timeout=10.0)
+
+        self.assertEqual({"result": {"status": "Timeout", "time_waited_seconds": 22.0}}, response)
+        self.assertEqual(
+            [call("initialize"), call("refresh_asset_database")],
+            mock_call_unity.call_args_list,
+        )
+        mock_sleep.assert_called_once_with(0.5)
+
+    def test_wait_for_compilation_respects_timeout_smaller_than_reload_probe_window(self) -> None:
+        call_results: list[dict[str, Any]] = [{"result": {}}, {"result": {}}]
+
+        with patch("nexus_bridge._transport.call_unity", side_effect=call_results) as mock_call_unity:
+            with patch("nexus_bridge.routes_editor.time.time", side_effect=[100.0, 100.0, 105.1, 105.1, 106.1]):
+                with patch("nexus_bridge.routes_editor.time.sleep") as mock_sleep:
+                    response: dict[str, Any] = routing._wait_for_compilation(timeout=5.0)
+
+        self.assertEqual({"result": {"status": "Timeout", "time_waited_seconds": 6.1}}, response)
+        self.assertEqual(
+            [call("initialize"), call("refresh_asset_database")],
+            mock_call_unity.call_args_list,
+        )
+        mock_sleep.assert_called_once_with(0.5)
+
+    def test_wait_route_delegates_compilation_condition_to_helper(self) -> None:
+        expected_response: dict[str, Any] = {"result": {"status": "Ready", "time_waited_seconds": 4.5}}
+
+        with patch(
+            "nexus_bridge.routes_editor._wait_for_compilation", return_value=expected_response
+        ) as mock_wait_for_compilation:
+            with patch("nexus_bridge.routes_editor.time.time", return_value=55.0):
+                response: dict[str, Any] = routing.route_tool(
+                    "wait", {"condition": "compilation", "timeout_seconds": 12.0}
+                )
+
+        self.assertEqual(expected_response, response)
+        mock_wait_for_compilation.assert_called_once_with(timeout=12.0, start_time=55.0)
+
+
+class UiAutomationRoutingTests(unittest.TestCase):
+    def test_ui_automation_routes_hierarchy_traversal_caps(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            routing.route_tool(
+                "ui_automation",
+                {
+                    "action": "get_hierarchy",
+                    "window_title": "Nexus Unity",
+                    "deep": True,
+                    "max_depth": 5,
+                    "max_elements": 50,
+                },
+            )
+            mock_call_unity.assert_called_with(
+                "ui_get_hierarchy",
+                {"window_title": "Nexus Unity", "deep": True, "max_depth": 5, "max_elements": 50},
+            )
+
+    def test_ui_automation_routes_query_traversal_caps(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            routing.route_tool(
+                "ui_automation",
+                {"action": "query", "window_title": "Nexus Unity", "name": "Button", "max_depth": 4, "max_results": 10},
+            )
+            mock_call_unity.assert_called_with(
+                "ui_query_elements",
+                {"window_title": "Nexus Unity", "name": "Button", "max_depth": 4, "max_results": 10},
+            )
+
+    def test_ui_automation_routes_snapshot_traversal_caps(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            routing.route_tool(
+                "ui_automation",
+                {
+                    "action": "capture_window_snapshot",
+                    "window_title": "Nexus Unity",
+                    "include_hierarchy": True,
+                    "max_depth": 3,
+                    "max_elements": 20,
+                },
+            )
+            mock_call_unity.assert_called_with(
+                "ui_capture_window_snapshot",
+                {"window_title": "Nexus Unity", "include_hierarchy": True, "max_depth": 3, "max_elements": 20},
+            )
+
+    def test_ui_automation_preserves_zero_caps(self) -> None:
+        with patch("nexus_bridge._transport.call_unity", return_value={"result": {"ok": True}}) as mock_call_unity:
+            routing.route_tool(
+                "ui_automation",
+                {"action": "get_hierarchy", "window_title": "Nexus Unity", "max_depth": 0, "max_elements": 0},
+            )
+            mock_call_unity.assert_called_with(
+                "ui_get_hierarchy",
+                {"window_title": "Nexus Unity", "max_depth": 0, "max_elements": 0},
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Editor/tests/test_routing_wait.py.meta b/Editor/tests/test_routing_wait.py.meta
new file mode 100644
index 0000000..41a82e1
--- /dev/null
+++ b/Editor/tests/test_routing_wait.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7dbd05e23cb94a849d39ec833001f86c
diff --git a/Editor/tests/test_schemas_editor.py b/Editor/tests/test_schemas_editor.py
new file mode 100644
index 0000000..949c20d
--- /dev/null
+++ b/Editor/tests/test_schemas_editor.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from typing import Any
+
+EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if EDITOR_DIR not in sys.path:
+    sys.path.insert(0, EDITOR_DIR)
+
+from nexus_bridge.schemas import STATIC_TOOLS
+
+
+def _get_tool(name: str) -> dict[str, Any]:
+    for tool in STATIC_TOOLS:
+        if tool["name"] == name:
+            return tool
+    raise AssertionError(f"Could not find tool {name}.")
+
+
+def _action_values(variant: dict[str, Any]) -> set[str]:
+    action_schema = variant["properties"]["action"]
+    if "const" in action_schema:
+        return {action_schema["const"]}
+    return set(action_schema["enum"])
+
+
+class PlayerPrefsManagerSchemaTests(unittest.TestCase):
+    def test_delete_variant_advertises_optional_confirm(self) -> None:
+        playerprefs_manager = _get_tool("unity_playerprefs_manager")
+        delete_variant = next(
+            variant for variant in playerprefs_manager["inputSchema"]["oneOf"] if "delete" in _action_values(variant)
+        )
+
+        self.assertCountEqual(["action", "key"], delete_variant["required"])
+        self.assertEqual({"type": "boolean"}, delete_variant["properties"]["confirm"])
+
+
+class WriteAndCompileSchemaTests(unittest.TestCase):
+    def test_write_and_compile_advertises_confirm(self) -> None:
+        tool = _get_tool("unity_write_and_compile")
+        properties = tool["inputSchema"]["properties"]
+
+        self.assertEqual("boolean", properties["confirm"]["type"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Editor/tests/test_schemas_editor.py.meta b/Editor/tests/test_schemas_editor.py.meta
new file mode 100644
index 0000000..1592f81
--- /dev/null
+++ b/Editor/tests/test_schemas_editor.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8e08950820a64c6cab6df149c1f3a598
diff --git a/Editor/tests/test_schemas.py b/Editor/tests/test_schemas_managers.py
similarity index 80%
rename from Editor/tests/test_schemas.py
rename to Editor/tests/test_schemas_managers.py
index f095a95..976b6af 100644
--- a/Editor/tests/test_schemas.py
+++ b/Editor/tests/test_schemas_managers.py
@@ -87,24 +87,5 @@ def test_set_sibling_index_accepts_integer_or_edge_keywords(self) -> None:
         )
 
 
-class PlayerPrefsManagerSchemaTests(unittest.TestCase):
-    def test_delete_variant_advertises_optional_confirm(self) -> None:
-        playerprefs_manager = _get_tool("unity_playerprefs_manager")
-        delete_variant = next(
-            variant for variant in playerprefs_manager["inputSchema"]["oneOf"] if "delete" in _action_values(variant)
-        )
-
-        self.assertCountEqual(["action", "key"], delete_variant["required"])
-        self.assertEqual({"type": "boolean"}, delete_variant["properties"]["confirm"])
-
-
-class WriteAndCompileSchemaTests(unittest.TestCase):
-    def test_write_and_compile_advertises_confirm(self) -> None:
-        tool = _get_tool("unity_write_and_compile")
-        properties = tool["inputSchema"]["properties"]
-
-        self.assertEqual("boolean", properties["confirm"]["type"])
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/Editor/tests/test_schemas_managers.py.meta b/Editor/tests/test_schemas_managers.py.meta
new file mode 100644
index 0000000..8261787
--- /dev/null
+++ b/Editor/tests/test_schemas_managers.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c22a64fddf104c91b84a344d8cec1404
diff --git a/Editor/tests/test_schemas_ui.py b/Editor/tests/test_schemas_ui.py
new file mode 100644
index 0000000..2653bce
--- /dev/null
+++ b/Editor/tests/test_schemas_ui.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+from typing import Any
+
+EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if EDITOR_DIR not in sys.path:
+    sys.path.insert(0, EDITOR_DIR)
+
+from nexus_bridge.schemas import STATIC_TOOLS
+
+
+def _get_tool(name: str) -> dict[str, Any]:
+    for tool in STATIC_TOOLS:
+        if tool["name"] == name:
+            return tool
+    raise AssertionError(f"Could not find tool {name}.")
+
+
+def _action_values(variant: dict[str, Any]) -> set[str]:
+    action_schema = variant["properties"]["action"]
+    if "const" in action_schema:
+        return {action_schema["const"]}
+    return set(action_schema["enum"])
+
+
+class UiAutomationSchemaTests(unittest.TestCase):
+    def test_ui_automation_advertises_traversal_caps(self) -> None:
+        tool = _get_tool("unity_ui_automation")
+        variants = tool["inputSchema"]["oneOf"]
+
+        get_hierarchy_variant = next(variant for variant in variants if "get_hierarchy" in _action_values(variant))
+        self.assertEqual("integer", get_hierarchy_variant["properties"]["max_depth"]["type"])
+        self.assertEqual("integer", get_hierarchy_variant["properties"]["max_elements"]["type"])
+
+        query_variant = next(variant for variant in variants if "query" in _action_values(variant))
+        self.assertEqual("integer", query_variant["properties"]["max_depth"]["type"])
+        self.assertEqual("integer", query_variant["properties"]["max_results"]["type"])
+
+        snapshot_variant = next(variant for variant in variants if "capture_window_snapshot" in _action_values(variant))
+        self.assertEqual("integer", snapshot_variant["properties"]["max_depth"]["type"])
+        self.assertEqual("integer", snapshot_variant["properties"]["max_elements"]["type"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Editor/tests/test_schemas_ui.py.meta b/Editor/tests/test_schemas_ui.py.meta
new file mode 100644
index 0000000..81c4b14
--- /dev/null
+++ b/Editor/tests/test_schemas_ui.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a303b758c4914490bd6944e51bf504ea
diff --git a/Editor/tests/test_transport.py b/Editor/tests/test_transport_call.py
similarity index 65%
rename from Editor/tests/test_transport.py
rename to Editor/tests/test_transport_call.py
index c675f22..e09e338 100644
--- a/Editor/tests/test_transport.py
+++ b/Editor/tests/test_transport_call.py
@@ -95,9 +95,6 @@ def test_call_unity_sends_auth_token_header_when_configured(self) -> None:
         self.assertEqual("secret-token", headers["x-nexus-unity-token"])
 
     def test_call_unity_retries_once_with_reloaded_token_on_401(self) -> None:
-        # Unity rotates the auth token on every domain reload; a cached token
-        # then 401s. call_unity must re-read the token file and retry once,
-        # rather than surfacing the 401 as a failure.
         transport: Any = _reload_transport_module({"NEXUS_UNITY_AUTH_TOKEN": "stale-token"}, ["nexus_unity_bridge.py"])
         import urllib.error
 
@@ -123,8 +120,6 @@ def test_call_unity_reports_401_as_auth_failure_not_unreachable(self) -> None:
 
         unauthorized = urllib.error.HTTPError(transport.UNITY_URL, 401, "Unauthorized", {}, None)
 
-        # Both attempts 401 (token file also stale): the error must name the 401,
-        # not claim the server is unreachable.
         with patch.object(transport, "_read_token_file", return_value="still-stale"):
             with patch(
                 "nexus_bridge._transport.urllib.request.urlopen",
@@ -136,50 +131,5 @@ def test_call_unity_reports_401_as_auth_failure_not_unreachable(self) -> None:
         self.assertIn("401", response["error"]["message"])
 
 
-class ReadPortTests(unittest.TestCase):
-    def test_read_port_prefers_environment_variable(self) -> None:
-        transport: Any = _reload_transport_module({"NEXUS_UNITY_PORT": "8123"}, ["nexus_unity_bridge.py", "9000"])
-        with patch.dict(os.environ, {"NEXUS_UNITY_PORT": "8123"}, clear=True):
-            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "9000"]):
-                self.assertEqual(8123, transport._read_port())
-
-    def test_read_port_uses_positional_argv_value(self) -> None:
-        transport: Any = _reload_transport_module({}, ["nexus_unity_bridge.py", "8124"])
-        with patch.dict(os.environ, {}, clear=True):
-            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "8124"]):
-                self.assertEqual(8124, transport._read_port())
-
-    def test_read_port_falls_back_to_default(self) -> None:
-        transport: Any = _reload_transport_module({}, ["nexus_unity_bridge.py", "scene_manager"])
-        with patch.dict(os.environ, {}, clear=True):
-            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "scene_manager"]):
-                self.assertEqual(transport.DEFAULT_PORT, transport._read_port())
-
-    def test_read_port_ignores_invalid_environment_variable(self) -> None:
-        transport: Any = _reload_transport_module(
-            {"NEXUS_UNITY_PORT": "scene_manager"},
-            ["nexus_unity_bridge.py", "8124"],
-        )
-        with patch.dict(os.environ, {"NEXUS_UNITY_PORT": "scene_manager"}, clear=True):
-            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "8124"]):
-                self.assertEqual(8124, transport._read_port())
-
-
-class ModuleConfigTests(unittest.TestCase):
-    def test_unity_url_uses_environment_variable_and_normalizes_trailing_slash(self) -> None:
-        transport: Any = _reload_transport_module(
-            {"NEXUS_UNITY_URL": "http://unity-host:9001"}, ["nexus_unity_bridge.py"]
-        )
-        self.assertEqual("http://unity-host:9001/", transport.UNITY_URL)
-
-    def test_timeout_is_clamped_to_minimum_of_one_second(self) -> None:
-        transport: Any = _reload_transport_module({"NEXUS_UNITY_TIMEOUT_SECONDS": "0.2"}, ["nexus_unity_bridge.py"])
-        self.assertEqual(1.0, transport.UNITY_TIMEOUT_SECONDS)
-
-    def test_timeout_ignores_invalid_environment_variable(self) -> None:
-        transport: Any = _reload_transport_module({"NEXUS_UNITY_TIMEOUT_SECONDS": "oops"}, ["nexus_unity_bridge.py"])
-        self.assertEqual(120, transport.UNITY_TIMEOUT_SECONDS)
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/Editor/tests/test_transport_call.py.meta b/Editor/tests/test_transport_call.py.meta
new file mode 100644
index 0000000..6a8805c
--- /dev/null
+++ b/Editor/tests/test_transport_call.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 867a92bc52ad4996982b2f188a084473
diff --git a/Editor/tests/test_transport_config.py b/Editor/tests/test_transport_config.py
new file mode 100644
index 0000000..9960254
--- /dev/null
+++ b/Editor/tests/test_transport_config.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import unittest
+from typing import Any
+from unittest.mock import patch
+
+EDITOR_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if EDITOR_DIR not in sys.path:
+    sys.path.insert(0, EDITOR_DIR)
+
+from nexus_bridge import _transport as transport_module
+
+
+def _reload_transport_module(environment: dict[str, str], argv: list[str]) -> Any:
+    with patch.dict(os.environ, environment, clear=True):
+        with patch.object(sys, "argv", argv):
+            return importlib.reload(transport_module)
+
+
+class ReadPortTests(unittest.TestCase):
+    def test_read_port_prefers_environment_variable(self) -> None:
+        transport: Any = _reload_transport_module({"NEXUS_UNITY_PORT": "8123"}, ["nexus_unity_bridge.py", "9000"])
+        with patch.dict(os.environ, {"NEXUS_UNITY_PORT": "8123"}, clear=True):
+            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "9000"]):
+                self.assertEqual(8123, transport._read_port())
+
+    def test_read_port_uses_positional_argv_value(self) -> None:
+        transport: Any = _reload_transport_module({}, ["nexus_unity_bridge.py", "8124"])
+        with patch.dict(os.environ, {}, clear=True):
+            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "8124"]):
+                self.assertEqual(8124, transport._read_port())
+
+    def test_read_port_falls_back_to_default(self) -> None:
+        transport: Any = _reload_transport_module({}, ["nexus_unity_bridge.py", "scene_manager"])
+        with patch.dict(os.environ, {}, clear=True):
+            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "scene_manager"]):
+                self.assertEqual(transport.DEFAULT_PORT, transport._read_port())
+
+    def test_read_port_ignores_invalid_environment_variable(self) -> None:
+        transport: Any = _reload_transport_module(
+            {"NEXUS_UNITY_PORT": "scene_manager"},
+            ["nexus_unity_bridge.py", "8124"],
+        )
+        with patch.dict(os.environ, {"NEXUS_UNITY_PORT": "scene_manager"}, clear=True):
+            with patch.object(sys, "argv", ["nexus_unity_bridge.py", "8124"]):
+                self.assertEqual(8124, transport._read_port())
+
+
+class ModuleConfigTests(unittest.TestCase):
+    def test_unity_url_uses_environment_variable_and_normalizes_trailing_slash(self) -> None:
+        transport: Any = _reload_transport_module(
+            {"NEXUS_UNITY_URL": "http://unity-host:9001"}, ["nexus_unity_bridge.py"]
+        )
+        self.assertEqual("http://unity-host:9001/", transport.UNITY_URL)
+
+    def test_timeout_is_clamped_to_minimum_of_one_second(self) -> None:
+        transport: Any = _reload_transport_module({"NEXUS_UNITY_TIMEOUT_SECONDS": "0.2"}, ["nexus_unity_bridge.py"])
+        self.assertEqual(1.0, transport.UNITY_TIMEOUT_SECONDS)
+
+    def test_timeout_ignores_invalid_environment_variable(self) -> None:
+        transport: Any = _reload_transport_module({"NEXUS_UNITY_TIMEOUT_SECONDS": "oops"}, ["nexus_unity_bridge.py"])
+        self.assertEqual(120, transport.UNITY_TIMEOUT_SECONDS)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Editor/tests/test_transport_config.py.meta b/Editor/tests/test_transport_config.py.meta
new file mode 100644
index 0000000..f9b243a
--- /dev/null
+++ b/Editor/tests/test_transport_config.py.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: af892d7f41e94c4b9901d3c6e033e827
diff --git a/Tests~/Editor/AgentToolingTests.cs b/Tests~/Editor/AgentToolingTests.cs
index 2ffdc30..5195ac6 100644
--- a/Tests~/Editor/AgentToolingTests.cs
+++ b/Tests~/Editor/AgentToolingTests.cs
@@ -265,6 +265,82 @@ public void UiCaptureWindowSnapshotReturnsRectHierarchyAndBestEffortImage()
 #endif
         }
 
+        [Test]
+        public void UiGetHierarchyRespectsDepthAndElementCaps()
+        {
+            MCPTestWindow window = MCPTestWindow.ShowWindow();
+            window.ResetState();
+
+            JObject shallow = RpcResult("ui_get_hierarchy", new JObject
+            {
+                ["window_title"] = MCPTestWindow.WindowTitle,
+                ["max_depth"] = 0
+            });
+            Assert.AreEqual(true, shallow["truncated"]?.Value<bool>());
+            Assert.AreEqual(true, shallow["children_truncated"]?.Value<bool>());
+            Assert.IsNull(shallow["children"]);
+
+            JObject cappedElements = RpcResult("ui_get_hierarchy", new JObject
+            {
+                ["window_title"] = MCPTestWindow.WindowTitle,
+                ["max_elements"] = 1
+            });
+            Assert.AreEqual(true, cappedElements["truncated"]?.Value<bool>());
+            Assert.AreEqual(true, cappedElements["children_truncated"]?.Value<bool>());
+
+            JObject full = RpcResult("ui_get_hierarchy", new JObject
+            {
+                ["window_title"] = MCPTestWindow.WindowTitle,
+                ["max_depth"] = 30,
+                ["max_elements"] = 1000
+            });
+            Assert.IsNull(full["truncated"]);
+            Assert.IsNotNull(full["children"]);
+        }
+
+        [Test]
+        public void UiQueryElementsRespectsMaxResultsAndMaxDepth()
+        {
+            MCPTestWindow window = MCPTestWindow.ShowWindow();
+            window.ResetState();
+
+            // Query by broad match (empty text or common name)
+            var response = Rpc("ui_query_elements", new JObject
+            {
+                ["window_title"] = MCPTestWindow.WindowTitle,
+                ["name"] = "TestButton",
+                ["max_results"] = 1
+            });
+            Assert.IsNull(response["error"]);
+            JArray results = (JArray)response["result"];
+            Assert.AreEqual(1, results.Count);
+            Assert.AreEqual("TestButton", results[0]?["name"]?.ToString());
+            Assert.IsNull(results[0]?["children"]);
+            Assert.IsNull(results[0]?["truncated"]);
+
+            // Depth cap preventing reaching nested elements
+            var depthZeroResponse = Rpc("ui_query_elements", new JObject
+            {
+                ["window_title"] = MCPTestWindow.WindowTitle,
+                ["name"] = "TestButton",
+                ["max_depth"] = 0
+            });
+            Assert.IsNull(depthZeroResponse["error"]);
+            JArray depthZeroResults = (JArray)depthZeroResponse["result"];
+            Assert.AreEqual(0, depthZeroResults.Count);
+
+            // Traversal cap preventing reaching nested elements even with large max_results
+            var cappedTraversalResponse = Rpc("ui_query_elements", new JObject
+            {
+                ["window_title"] = MCPTestWindow.WindowTitle,
+                ["name"] = "TestButton",
+                ["max_elements"] = 1
+            });
+            Assert.IsNull(cappedTraversalResponse["error"]);
+            JArray cappedTraversalResults = (JArray)cappedTraversalResponse["result"];
+            Assert.AreEqual(0, cappedTraversalResults.Count);
+        }
+
         [Test]
         public void CreateScriptableObjectAssetRejectsAbstractTypes()
         {
diff --git a/Tests~/Editor/ConsolidatedManagersTests.cs b/Tests~/Editor/ConsolidatedManagersTests.cs
index 9bc7b4a..d434045 100644
--- a/Tests~/Editor/ConsolidatedManagersTests.cs
+++ b/Tests~/Editor/ConsolidatedManagersTests.cs
@@ -128,11 +128,11 @@ private JToken SimulateBridgeRouting(string managerName, JObject args) {
             else if (managerName == "unity_ui_automation") {
                 string action = args["action"]?.ToString();
                 if (action == "list_windows") { mappedMethod = "ui_list_windows"; mappedParams = new JObject(); }
-                else if (action == "get_hierarchy") { mappedMethod = "ui_get_hierarchy"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["deep"] = args["deep"] }; }
-                else if (action == "query") { mappedMethod = "ui_query_elements"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["name"] = args["name"], ["text"] = args["text"], ["class_name"] = args["class_name"] }; }
+                else if (action == "get_hierarchy") { mappedMethod = "ui_get_hierarchy"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["deep"] = args["deep"], ["max_depth"] = args["max_depth"], ["max_elements"] = args["max_elements"] ?? args["max_results"] }; }
+                else if (action == "query") { mappedMethod = "ui_query_elements"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["name"] = args["name"], ["text"] = args["text"], ["class_name"] = args["class_name"], ["max_depth"] = args["max_depth"], ["max_results"] = args["max_results"] ?? args["max_elements"], ["max_elements"] = args["max_elements"] }; }
                 else if (action == "get_window_rect") { mappedMethod = "ui_get_window_rect"; mappedParams = new JObject { ["window_title"] = args["window_title"] }; }
                 else if (action == "set_window_rect") { mappedMethod = "ui_set_window_rect"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["x"] = args["x"], ["y"] = args["y"], ["width"] = args["width"], ["height"] = args["height"] }; }
-                else if (action == "capture_window_snapshot") { mappedMethod = "ui_capture_window_snapshot"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["include_image"] = args["include_image"], ["include_hierarchy"] = args["include_hierarchy"] }; }
+                else if (action == "capture_window_snapshot") { mappedMethod = "ui_capture_window_snapshot"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["include_image"] = args["include_image"], ["include_hierarchy"] = args["include_hierarchy"], ["max_depth"] = args["max_depth"], ["max_elements"] = args["max_elements"] ?? args["max_results"] }; }
                 else if (action == "click") { mappedMethod = "ui_click"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["element_name"] = args["element_name"] }; }
                 else if (action == "input") { mappedMethod = "ui_input_text"; mappedParams = new JObject { ["window_title"] = args["window_title"], ["element_name"] = args["element_name"], ["text"] = args["text"] }; }
             }
diff --git a/scripts/agent-tooling-smoke.py b/scripts/agent-tooling-smoke.py
index 37c90b0..4403479 100644
--- a/scripts/agent-tooling-smoke.py
+++ b/scripts/agent-tooling-smoke.py
@@ -3,7 +3,6 @@
 import os
 import sys
 import time
-import urllib.request
 
 sys.dont_write_bytecode = True
 
@@ -12,50 +11,25 @@
 if EDITOR_DIR not in sys.path:
     sys.path.insert(0, EDITOR_DIR)
 
+from nexus_bridge._transport import UNITY_URL, call_unity  # noqa: E402
 from nexus_bridge.routing import route_tool  # noqa: E402
 
 
-def nexus_url():
-    if os.environ.get("NEXUS_UNITY_URL"):
-        url = os.environ["NEXUS_UNITY_URL"]
-        return url if url.endswith("/") else url + "/"
-
-    port = os.environ.get("NEXUS_UNITY_PORT", "8081")
-    return f"http://127.0.0.1:{port}/"
-
-
-def timeout_seconds():
-    return max(1.0, float(os.environ.get("NEXUS_UNITY_TIMEOUT_SECONDS", "120")))
-
-
-def rpc(method, params=None):
-    payload = {
-        "jsonrpc": "2.0",
-        "method": method,
-        "params": params or {},
-        "id": 1,
-    }
-    data = json.dumps(payload).encode("utf-8")
-    request = urllib.request.Request(
-        nexus_url(),
-        data=data,
-        headers={"Content-Type": "application/json"},
-    )
-    with urllib.request.urlopen(request, timeout=timeout_seconds()) as response:
-        result = json.loads(response.read().decode("utf-8"))
+def rpc(method: str, params: dict | None = None) -> dict:
+    result = call_unity(method, params)
     if "error" in result:
         raise RuntimeError(f"{method} failed: {result['error']}")
-    return result["result"]
+    return result.get("result", result)
 
 
-def bridge_result(name, args):
+def bridge_result(name: str, args: dict) -> dict:
     result = route_tool(name, args)
     if "error" in result:
         raise RuntimeError(f"{name} failed: {result['error']}")
     return result.get("result", result)
 
 
-def summarize_snapshot(snapshot):
+def summarize_snapshot(snapshot: dict) -> dict:
     return {
         "status": snapshot.get("status"),
         "has_image": bool(snapshot.get("image_base64")),
@@ -66,14 +40,7 @@ def summarize_snapshot(snapshot):
     }
 
 
-def main():
-    started = time.time()
-    summary = {"success": False, "url": nexus_url()}
-
-    server = rpc("get_server_status")
-    tools = rpc("list_tools")
-    rpc("reset_tool_usage_stats")
-
+def _run_ui_smoke() -> tuple[dict, dict, dict]:
     rpc("execute_menu_item", {"item_path": "Window/Nexus Unity"})
     time.sleep(0.5)
 
@@ -96,13 +63,7 @@ def main():
             "height": 720,
         },
     )
-    rect = bridge_result(
-        "ui_automation",
-        {
-            "action": "get_window_rect",
-            "window_title": "Nexus Unity",
-        },
-    )
+    rect = bridge_result("ui_automation", {"action": "get_window_rect", "window_title": "Nexus Unity"})
     snapshot = bridge_result(
         "ui_automation",
         {
@@ -112,24 +73,35 @@ def main():
             "include_hierarchy": True,
         },
     )
+    return query, rect, snapshot
+
+
+def main() -> int:
+    started = time.time()
+    server = rpc("get_server_status")
+    tools = rpc("list_tools")
+    rpc("reset_tool_usage_stats")
+
+    query, rect, snapshot = _run_ui_smoke()
     editor_state = bridge_result("editor_controller", {"action": "get_state"})
     stats = rpc("get_tool_usage_stats")
-    success = bool(tools) and server.get("state") and snapshot.get("status") in {None, "Success", "success"}
-
-    summary.update(
-        {
-            "success": bool(success),
-            "elapsed_seconds": round(time.time() - started, 2),
-            "server_state": server.get("state"),
-            "editor_state": editor_state,
-            "tool_count": len(tools),
-            "window_query_count": len(query) if isinstance(query, list) else 0,
-            "rect": rect.get("rect"),
-            "snapshot": summarize_snapshot(snapshot),
-            "usage_method_count": len(stats.get("tools", [])),
-        }
+    success = (
+        bool(tools) and server.get("state") and snapshot.get("status") in {None, "Success", "success", "PartialSuccess"}
     )
 
+    summary = {
+        "success": bool(success),
+        "url": UNITY_URL,
+        "elapsed_seconds": round(time.time() - started, 2),
+        "server_state": server.get("state"),
+        "editor_state": editor_state,
+        "tool_count": len(tools),
+        "window_query_count": len(query) if isinstance(query, list) else 0,
+        "rect": rect.get("rect"),
+        "snapshot": summarize_snapshot(snapshot),
+        "usage_method_count": len(stats.get("tools", [])),
+    }
+
     print(json.dumps(summary, indent=2, sort_keys=True))
     return 0 if summary["success"] else 1