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/.githooks/post-commit b/.githooks/post-commit
new file mode 100755
index 0000000..419f1cc
--- /dev/null
+++ b/.githooks/post-commit
@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+set -eu
+
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+if [ -d "$REPO_ROOT/.projectmem" ] && command -v pjm >/dev/null 2>&1; then
+  (cd "$REPO_ROOT" && pjm _auto-capture commit >/dev/null 2>&1 &)
+fi
diff --git a/.githooks/post-merge b/.githooks/post-merge
new file mode 100755
index 0000000..768f500
--- /dev/null
+++ b/.githooks/post-merge
@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+set -eu
+
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+if [ -d "$REPO_ROOT/.projectmem" ] && command -v pjm >/dev/null 2>&1; then
+  (cd "$REPO_ROOT" && pjm _auto-capture merge >/dev/null 2>&1 &)
+fi
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
new file mode 100755
index 0000000..e0f454f
--- /dev/null
+++ b/.githooks/pre-commit
@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+set -eu
+
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+if [ -d "$REPO_ROOT/.projectmem" ] && command -v pjm >/dev/null 2>&1; then
+  (cd "$REPO_ROOT" && pjm precheck --level warn) || true
+fi
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/.github/workflows/approve-external-pr.yml b/.github/workflows/approve-external-pr.yml
index 3525ea6..c04f771 100644
--- a/.github/workflows/approve-external-pr.yml
+++ b/.github/workflows/approve-external-pr.yml
@@ -29,6 +29,11 @@ on:
         description: "External PR number to replay (e.g. 30)"
         required: true
         type: string
+      acknowledge_critical_files:
+        description: "Set true only after reviewing the diff, to proceed even though the PR touches .github/workflows, .githooks, or scripts"
+        required: false
+        type: boolean
+        default: false
 
 permissions:
   contents: write        # push the trusted/pr-N branch
@@ -79,6 +84,70 @@ jobs:
             exit 1
           fi
 
+      # ── 0.1. Authorize maintainer actor ─────────────────────────────────────
+      - name: Verify maintainer authorization
+        env:
+          ACTOR: ${{ github.actor }}
+          REPOSITORY: ${{ github.repository }}
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+
+          echo "Verifying authorization for actor @$ACTOR..."
+
+          # Explicit maintainer bypass
+          if [ "$ACTOR" = "Daliys" ]; then
+            echo "Actor @$ACTOR is authorized maintainer."
+            exit 0
+          fi
+
+          # Check collaborator permission via GitHub API
+          PERM=$(gh api "repos/$REPOSITORY/collaborators/$ACTOR/permission" --jq '.permission' 2>/dev/null || echo "none")
+          case "$PERM" in
+            admin|write)
+              echo "Actor @$ACTOR authorized with permission: $PERM"
+              ;;
+            *)
+              echo "::error::Actor @$ACTOR does not have maintainer authorization (permission: $PERM)."
+              exit 1
+              ;;
+          esac
+
+      # ── 0.2. Content & Security Pre-scan ────────────────────────────────────
+      - name: Run security pre-scan on PR files
+        env:
+          REPOSITORY: ${{ github.repository }}
+          PR_NUMBER: ${{ inputs.pr_number }}
+          ACKNOWLEDGE: ${{ inputs.acknowledge_critical_files }}
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+
+          echo "Scanning changed files in PR #$PR_NUMBER..."
+          FILES=$(gh api "repos/$REPOSITORY/pulls/$PR_NUMBER/files" --paginate --jq '.[].filename')
+
+          SUSPICIOUS_COUNT=0
+          while IFS= read -r file; do
+            [ -z "$file" ] && continue
+            case "$file" in
+              .github/workflows/*|.githooks/*|scripts/*)
+                echo "::warning::PR #$PR_NUMBER modifies critical CI/script file: $file"
+                SUSPICIOUS_COUNT=$((SUSPICIOUS_COUNT + 1))
+                ;;
+            esac
+          done <<< "$FILES"
+
+          if [ "$SUSPICIOUS_COUNT" -gt 0 ]; then
+            echo "::notice::PR #$PR_NUMBER modifies $SUSPICIOUS_COUNT critical file(s)."
+            if [ "$ACKNOWLEDGE" != "true" ]; then
+              echo "::error::Refusing to replay PR #$PR_NUMBER: it modifies critical CI/script file(s) (see warnings above). Review the diff, then re-run this workflow with 'acknowledge_critical_files' set to true if it's safe to proceed."
+              exit 1
+            fi
+            echo "Critical file changes acknowledged by @${{ github.actor }} — proceeding."
+          else
+            echo "Content pre-scan passed cleanly: no critical CI/workflow files modified."
+          fi
+
       # ── 1. Create trusted branch with the fork's commits ───────────────────
       - name: Create trusted/pr-${{ inputs.pr_number }} branch
         env:
diff --git a/.github/workflows/validate.yml b/.github/workflows/validate.yml
index ff7228b..deafd67 100644
--- a/.github/workflows/validate.yml
+++ b/.github/workflows/validate.yml
@@ -128,17 +128,21 @@ jobs:
           path: candidate
 
       - name: Run required Ollama documentation and checklist review
+        env:
+          IS_FORK_PR: ${{ github.event.pull_request && github.event.pull_request.head.repo.fork || false }}
         run: |
           set -euo pipefail
           dotnet --version
 
           QUALITY_GATE_PROJECT="trusted/tools~/NexusQualityGate/NexusQualityGate.csproj"
-          if [ ! -f "$QUALITY_GATE_PROJECT" ]; then
-            echo "::notice::Trusted branch does not have NexusQualityGate yet; using candidate tool for bootstrap validation."
-            QUALITY_GATE_PROJECT="candidate/tools~/NexusQualityGate/NexusQualityGate.csproj"
-          elif ! grep -q -- "--checklist-ai" trusted/tools~/NexusQualityGate/QualityGateOptions.cs; then
-            echo "::notice::Trusted NexusQualityGate does not support checklist AI yet; using candidate tool for this bootstrap validation."
-            QUALITY_GATE_PROJECT="candidate/tools~/NexusQualityGate/NexusQualityGate.csproj"
+          if [ ! -f "$QUALITY_GATE_PROJECT" ] || ! grep -q -- "--checklist-ai" trusted/tools~/NexusQualityGate/QualityGateOptions.cs; then
+            if [ "${IS_FORK_PR:-false}" = "true" ]; then
+              echo "::warning::Trusted branch does not support the required NexusQualityGate version, and candidate tool cannot be executed for fork PRs due to security restrictions. Skipping AI documentation check."
+              exit 0
+            else
+              echo "::notice::Trusted branch does not have the required NexusQualityGate version; using candidate tool for bootstrap validation."
+              QUALITY_GATE_PROJECT="candidate/tools~/NexusQualityGate/NexusQualityGate.csproj"
+            fi
           fi
 
           dotnet run --project "$QUALITY_GATE_PROJECT" -- \
@@ -239,6 +243,9 @@ jobs:
           dependencies = manifest.setdefault("dependencies", {})
           dependencies["com.forkhorizon.nexus.unity"] = f"file:{os.environ['GITHUB_WORKSPACE']}"
           dependencies["com.unity.test-framework"] = "1.5.1"
+          testables = manifest.setdefault("testables", [])
+          if "com.forkhorizon.nexus.unity" not in testables:
+              testables.append("com.forkhorizon.nexus.unity")
           manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
           PY
 
@@ -361,7 +368,7 @@ jobs:
             -projectPath "$SMOKE_ROOT" \
             -runTests \
             -testPlatform editmode \
-            -assemblyNames NexusUnity.PackageSmoke.EditorTests \
+            -assemblyNames "NexusUnity.PackageSmoke.EditorTests;UnityMCP.Editor.Tests" \
             -testResults "$SMOKE_TEST_RESULTS" \
             -logFile "$SMOKE_TEST_LOG"; then
             echo "::error::Unity package Editor tests failed."
diff --git a/AGENTS.md b/AGENTS.md
index fa5b301..f84b7bb 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -43,3 +43,14 @@ PYTHONDONTWRITEBYTECODE=1 scripts/prepush-validate.sh --static-only
 For Unity-facing behavior, also use the running test harness through MCP tools such as `unity_wait`, `unity_lint_project`, and `unity_editor_controller`.
 
 Clean generated Python caches before validation if needed; `__pycache__` or `*.pyc` files are not part of package changes.
+
+<!-- SOMA_MEMORY_TOOLS_START -->
+## Memory Tools
+
+Default mode: light. Do not spend tokens on memory tools for small, obvious, single-file tasks.
+
+- projectmem: use for bugs, regressions, multi-step changes, repeated attempts, or architecture decisions. For small self-contained edits, skip full memory startup and use targeted history checks only when useful.
+- `.projectmem/config.toml`, `PROJECT_MAP.md`, and `plan.md` are shared project configuration. The append-only event log, issue files, generated summary/structure, watcher state, and generated `CLAUDE.md` bridge are local and ignored.
+- This package uses the tracked `.githooks` directory. When `pjm` is installed, its `pre-commit`, `post-commit`, and `post-merge` wrappers provide warnings and local auto-capture; do not run `pjm hooks install`, which assumes `.git/hooks` exists.
+- Verify that the projectmem MCP server is bound to this package before using write tools. If it is bound elsewhere, use the local `pjm` CLI from this package root instead.
+<!-- SOMA_MEMORY_TOOLS_END -->
diff --git a/API_REFERENCE.MD b/API_REFERENCE.MD
index 33f3971..5e015dc 100644
--- a/API_REFERENCE.MD
+++ b/API_REFERENCE.MD
@@ -1,6 +1,6 @@
 # Nexus Unity API Reference
 
-Version: `1.5.0`
+Version: `1.6.0`
 
 Nexus Unity exposes two supported public API surfaces:
 
@@ -187,12 +187,12 @@ Actions: `search`, `explore`, `create_material`, `import`, `refresh`, `instantia
 ### `unity_editor_controller`
 Actions: `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`.
 
-`run_tests_wait` triggers `run_tests` and polls raw `get_test_results` from the Python bridge so Unity's main thread is not blocked while the agent waits.
+`get_tool_usage_stats` returns in-memory call counts, average/total durations, `last_error_type`, and sanitized `last_error` with sensitive paths redacted; `reset_tool_usage_stats` resets the counters. Raw `run_tests` returns `status: "Submitted"` after Unity accepts the asynchronous request; it does not claim that execution has begun or completed. `run_tests_wait` triggers `run_tests` and polls raw `get_test_results` from the Python bridge so Unity's main thread is not blocked while the agent waits. If submission is rejected, `run_tests_wait` returns that result without polling.
 
 ### `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`.
@@ -209,6 +209,9 @@ This is the public MCP bridge macro for code edits. Pass `confirm: true` when wr
 
 Raw `attach_script`, `write_file`, and `write_files_batch` calls also require `confirm: true` before writing `.cs` files.
 
+### `delete_asset`
+Deletes a file or folder in the project. Requires `path` and `confirm: true`. Deletions use `AssetDatabase.MoveAssetToTrash` to send items to the OS Trash. Deletion of `ProjectSettings/` or `Packages/` paths is forbidden.
+
 ### `unity_invoke_method`
 Invokes a C# method on a component through reflection.
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f80c51..0888d9a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,32 @@ All notable public changes to Nexus Unity are documented here.
 
 ## [Unreleased]
 
+## [1.6.0] - 2026-08-23
+
+### Security
+- Sanitize and redact sensitive exception messages in tool usage stats (`get_tool_usage_stats` and `RecordToolUsage`), replacing absolute filesystem paths, user directories, and multiline frames with generic placeholders and safe truncated summaries, and exposing `last_error_type` (#142).
+- Require explicit confirmation (`confirm: true`) for `delete_asset`, enforce `AssetDatabase.MoveAssetToTrash` for OS trash recovery, and block creation, modification, moving, or deletion of `ProjectSettings/` and `Packages/` paths across all asset tools (#140).
+- Hardened external PR replay workflow (`approve-external-pr.yml`) with an in-workflow actor authorization gate and a PR content security pre-scan to prevent unauthorized execution and flag critical CI modifications on self-hosted runners (#144).
+- The content pre-scan now blocks the replay when a PR touches `.github/workflows/*`, `.githooks/*`, or `scripts/*`, requiring the maintainer to re-run with `acknowledge_critical_files: true` after reviewing the diff, instead of only logging a warning (#144).
+
+### Changed
+- 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).
+- Persist authentication tokens across Unity Editor process restarts in Library token file, preventing persistent HTTP 401 Unauthorized errors for external MCP CLI integrations after restarting Unity (#166).
+- `get_scene_dependencies` now uses `enterChildren = false` after the initial property iteration step, preventing deep recursive traversal into child properties and eliminating duplicated dependency references (#71).
+- `find_objects` now safely constructs name search regexes with a 100ms match timeout and falls back gracefully to literal substring search on invalid regex patterns or match timeouts (#119).
+- Restrict type resolution (`FindType`) to user project assemblies and standard public `UnityEngine` assemblies, disallow internal system/editor assemblies and namespaces, and enforce strict type allowlist constraints for component and ScriptableObject creation/inspection tools (#139).
+- Resolve symlinks and directory junctions to their real filesystem targets in `ValidatePath` before checking project boundaries to prevent path traversal.
+- Reject abstract ScriptableObject types before calling `CreateInstance` in `create_scriptable_object_asset` and `list_fields_for_type`.
+- `TriggerSafeAssetRefresh` callback is now tracked to prevent callback leaks, duplicate refresh hooks, and memory leaks across assembly reload/shutdown boundaries, with a fail-safe 15-second timeout guard.
+- `run_tests` now reports `Submitted` rather than `Success` after Unity accepts its asynchronous request, and `run_tests_wait` now returns rejected submissions immediately instead of polling until timeout.
+- Auto Setup now reports a clear refresh-and-retry message if a client is unavailable after the integration list is regenerated, instead of throwing an exception.
+
 ## [1.5.0] - 2026-07-12
 
 ### Changed
diff --git a/DOCUMENTATION.MD b/DOCUMENTATION.MD
index f7ad418..2f1340a 100644
--- a/DOCUMENTATION.MD
+++ b/DOCUMENTATION.MD
@@ -1,6 +1,6 @@
 # Nexus Unity Technical Documentation
 
-Version: `1.5.0`
+Version: `1.6.0`
 
 Nexus Unity is a Unity Editor automation package with two public interfaces:
 
@@ -62,6 +62,7 @@ Nexus Unity is a local developer tool and should be used only with trusted local
 
 - HTTP and WebSocket requests must target loopback hosts.
 - HTTP and WebSocket requests require the per-session `X-Nexus-Unity-Token` header; generated MCP configs pass it to the Python bridge as `NEXUS_UNITY_AUTH_TOKEN`.
+- WebSocket and HTTP requests are processed asynchronously on background worker threads, ensuring the server accept loop remains non-blocking for concurrent clients.
 - Browser origins are validated to reduce CSRF and DNS rebinding exposure; non-loopback origins are rejected.
 - File operations resolve paths and enforce the Unity project root boundary.
 - C# script writes require `confirm: true` before creating or overwriting `.cs` files and triggering Unity compilation.
@@ -114,9 +115,9 @@ MCP bridge:
 - Manager tools accept common raw-action aliases where agents naturally try them, for example `unity_scene_manager action=list_scenes` and `unity_hierarchy_manager action=create_gameobject`.
 - Invalid manager actions include the valid action names in the error message.
 - `unity_hierarchy_manager` can create primitives with name, parent, transform, and material path; it can also rename, set transforms, and pass through `create_hierarchy`.
-- `unity_editor_controller` includes `run_tests_wait`, which waits in the Python bridge by polling raw `get_test_results` instead of blocking the Unity main thread.
+- 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
 
@@ -206,7 +207,7 @@ PlayerPrefs cleanup should use specific disposable keys. Bulk cleanup requires `
 
 - Public repo: `https://github.com/ForkHorizon/NexusUnity.git`.
 - Package id: `com.forkhorizon.nexus.unity`.
-- Public release version: `1.5.0`.
+- Public release version: `1.6.0`.
 - License: `MIT`.
 - Required release docs: `SECURITY.md`, `CONTRIBUTING.md`, and `RELEASE.md`.
 - Repository funding metadata lives in `.github/FUNDING.yml` and configures the GitHub Sponsor button for `Daliys`.
@@ -218,12 +219,12 @@ PlayerPrefs cleanup should use specific disposable keys. Bulk cleanup requires `
 
 Nexus Unity follows semantic versioning for public releases, but the development branch should not bump the package version for every merged fix. Keep `package.json` and visible docs at the latest shipped public version until a release is being prepared.
 
-Unity Package Manager requires `MAJOR.MINOR.PATCH` values in `package.json`, and GitHub release tags and titles use the same semantic version. Use forms like `1.5.0` for the package version, `v1.5.0` for tags, and `1.5.0` for release titles.
+Unity Package Manager requires `MAJOR.MINOR.PATCH` values in `package.json`, and GitHub release tags and titles use the same semantic version. Use forms like `1.6.0` for the package version, `v1.6.0` for tags, and `1.6.0` for release titles.
 
 During normal development:
 
 - Add all user-visible API, behavior, docs, and validation changes to `[Unreleased]` in `CHANGELOG.md`.
-- Do not change `package.json` from `1.5.0` unless the change is part of a release-preparation commit.
+- Do not change `package.json` from `1.6.0` unless the change is part of a release-preparation commit.
 - Prefer compatibility fixes over breaking changes; if a breaking change is unavoidable, document the migration path before release.
 
 During release preparation:
@@ -231,4 +232,4 @@ During release preparation:
 - Choose the next semantic version based on accumulated changes.
 - Move `[Unreleased]` entries into the new dated release section.
 - Update `package.json`, README badges/install examples, `DOCUMENTATION.MD`, and `API_REFERENCE.MD`.
-- Tag the release with the matching semantic GitHub version, for example `v1.5.0` for package version `1.5.0`.
+- Tag the release with the matching semantic GitHub version, for example `v1.6.0` for package version `1.6.0`.
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.Discovery.cs b/Editor/MCPServer.Discovery.cs
new file mode 100644
index 0000000..09f5a71
--- /dev/null
+++ b/Editor/MCPServer.Discovery.cs
@@ -0,0 +1,159 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    // Probing existing MCP server instances, legacy server detection, and port discovery.
+    // Split out of MCPServer.Networking.cs to keep files modular and well under readability limits.
+    public static partial class MCPServer
+    {
+        // Kept on its own line (no surrounding code braces): the "//" inside the
+        // URL confuses simple readability linters that strip comments before
+        // strings, so we never place a brace on the same line as this literal.
+        private static string LoopbackUrl => $"http://127.0.0.1:{_port}/";
+
+        private static System.Net.Http.StringContent JsonRpcContent(string method)
+        {
+            string payload = "{\"jsonrpc\":\"2.0\",\"method\":\"" + method + "\",\"params\":{},\"id\":1}";
+            return new System.Net.Http.StringContent(payload, Encoding.UTF8, "application/json");
+        }
+
+        private static async Task<bool> IsAnotherMcpInstanceRunning()
+        {
+            using var client = new System.Net.Http.HttpClient();
+            client.Timeout = TimeSpan.FromMilliseconds(500);
+            client.DefaultRequestHeaders.Add(AuthTokenHeaderName, AuthToken);
+            try
+            {
+                var response = await client.PostAsync(LoopbackUrl, JsonRpcContent("get_server_status"));
+                if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden)
+                {
+                    return await HandleUnauthorizedProbe();
+                }
+
+                string body = await response.Content.ReadAsStringAsync();
+                if (body.Contains("serverAlive"))
+                {
+                    bool? verdict = await EvaluateAliveServer(client, body);
+                    if (verdict.HasValue) return verdict.Value;
+                }
+
+                return await ProbeLegacyServer(client);
+            }
+            catch { return false; }
+        }
+
+        // A 401/403 means either a genuine other instance, or our own stale
+        // listener from a previous domain reload. Returns true only for the
+        // former; cleans up and returns false for the latter.
+        private static async Task<bool> HandleUnauthorizedProbe()
+        {
+            string owner = GetPortOwner(_port);
+            int localPid = System.Diagnostics.Process.GetCurrentProcess().Id;
+            if (!string.IsNullOrEmpty(owner) && owner.Contains(localPid.ToString()))
+            {
+                NexusEditorLog.Warning(NexusLogCategory.Server, $"[MCP] Detected unauthorized listener from previous domain (PID: {localPid}). Cleaning up stale listener...");
+                Cleanup();
+                await Task.Delay(200);
+                return false;
+            }
+            return true;
+        }
+
+        // Returns a conclusive verdict from a live server's identity, or null to
+        // fall through to the legacy-server probe.
+        private static async Task<bool?> EvaluateAliveServer(System.Net.Http.HttpClient client, string body)
+        {
+            var json = JObject.Parse(body);
+            string remoteProjectPath = json["result"]?["projectPath"]?.ToString();
+            if (string.IsNullOrEmpty(remoteProjectPath)) return null;
+
+            string localProjectPath = Directory.GetCurrentDirectory().Replace("\\", "/");
+            int remotePid = json["result"]?["processId"]?.Value<int>() ?? -1;
+            int localPid = System.Diagnostics.Process.GetCurrentProcess().Id;
+
+            if (remoteProjectPath != localProjectPath)
+            {
+                NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Existing MCP server found on port {_port}. Project does NOT match current workspace. Action required: choose another port or stop the other session. Remote project: {remoteProjectPath} (PID: {remotePid})");
+                return true;
+            }
+
+            if (remotePid == localPid)
+            {
+                NexusEditorLog.Warning(NexusLogCategory.Server, $"[MCP] Detected zombie listener from previous domain (PID: {localPid}). Disconnecting stale entity...");
+                try { await client.PostAsync(LoopbackUrl, JsonRpcContent("shutdown_server")); } catch { }
+                await Task.Delay(200); // Give it time to close
+                return false; // Allow Start() to try binding its own listener
+            }
+
+            NexusEditorLog.Log(NexusLogCategory.Server, $"[MCP] Existing MCP server found on port {_port}. Project matches current workspace. Action taken: attached to existing session.", true);
+            return true;
+        }
+
+        // Fallback for older servers that predate get_server_status.
+        private static async Task<bool> ProbeLegacyServer(System.Net.Http.HttpClient client)
+        {
+            var initResponse = await client.PostAsync(LoopbackUrl, JsonRpcContent("initialize"));
+            if (initResponse.StatusCode == HttpStatusCode.Unauthorized || initResponse.StatusCode == HttpStatusCode.Forbidden) return true;
+
+            string initBody = await initResponse.Content.ReadAsStringAsync();
+            if (initBody.Contains("Unity MCP Server"))
+            {
+                NexusEditorLog.Log(NexusLogCategory.Server, $"[MCP] Connected to an older existing session on port {_port}", true);
+                return true;
+            }
+            return false;
+        }
+
+        // Resolves the configured port, allocating a free ephemeral port when it is left at 0.
+        private static void ResolvePort()
+        {
+            if (_port <= 0)
+            {
+                ParseCommandLineArgs();
+                _port = _cliPortOverride ?? MCPSettings.Port;
+            }
+
+            if (_port != 0) return;
+
+            try
+            {
+                var l = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
+                l.Start();
+                _port = ((System.Net.IPEndPoint)l.LocalEndpoint).Port;
+                l.Stop();
+                System.Threading.Thread.Sleep(100);
+            }
+            catch { }
+        }
+
+        // Returns true if we may proceed to bind the busy port ourselves; false
+        // if another instance/app owns it (state is set accordingly).
+        private static async Task<bool> TryClaimBusyPort()
+        {
+            if (await IsAnotherMcpInstanceRunning())
+            {
+                _state = ServerState.Attached;
+                return false;
+            }
+
+            string owner = GetPortOwner(_port);
+            if (owner != "Unknown Process")
+            {
+                _state = ServerState.Error;
+                LastError = $"Port {_port} is being used by another application: {owner}.";
+                NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] {LastError}");
+                return false;
+            }
+
+            NexusEditorLog.Warning(NexusLogCategory.Server, $"[MCP] Port {_port} reported busy by Unknown Process. Proceeding with force-bind attempt...");
+            return true;
+        }
+    }
+}
diff --git a/Editor/MCPServer.Discovery.cs.meta b/Editor/MCPServer.Discovery.cs.meta
new file mode 100644
index 0000000..a357f00
--- /dev/null
+++ b/Editor/MCPServer.Discovery.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d9426f81a70441c49b8123ef51b9e401
diff --git a/Editor/MCPServer.Http.cs b/Editor/MCPServer.Http.cs
new file mode 100644
index 0000000..d28b6a4
--- /dev/null
+++ b/Editor/MCPServer.Http.cs
@@ -0,0 +1,239 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace UnityMCP.Editor
+{
+    // HTTP/WebSocket request handling and authorization for the loopback server.
+    // Split out of MCPServer.Networking.cs to keep each file under the readability
+    // line budget; both are the same partial MCPServer class.
+    public static partial class MCPServer
+    {
+        private const long MaxPayloadSize = 10 * 1024 * 1024; // 10MB, prevents memory exhaustion
+
+        private static bool IsValidOrigin(HttpListenerContext context)
+        {
+            if (!context.Request.Url.IsLoopback) return false;
+
+            string origin = context.Request.Headers["Origin"];
+            if (string.IsNullOrEmpty(origin)) return true;
+
+            try
+            {
+                Uri originUri = new Uri(origin);
+                return originUri.IsLoopback && (originUri.Scheme == Uri.UriSchemeHttp || originUri.Scheme == Uri.UriSchemeHttps);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private static async Task ProcessWebSocket(HttpListenerContext context)
+        {
+            WebSocket socket = null;
+            try
+            {
+                if (!IsValidOrigin(context))
+                {
+                    context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+                    context.Response.Close();
+                    return;
+                }
+
+                if (!IsAuthorized(context))
+                {
+                    RejectUnauthorized(context);
+                    return;
+                }
+
+                var wsContext = await context.AcceptWebSocketAsync(null);
+                socket = wsContext.WebSocket;
+                lock (_webSocketLock)
+                {
+                    _activeWebSockets.Add(socket);
+                }
+
+                var token = _cts?.Token ?? CancellationToken.None;
+                await ReceiveWebsocketLoop(socket, token);
+            }
+            catch (ObjectDisposedException) { }
+            catch (HttpListenerException) { }
+            catch (WebSocketException) { }
+            catch (OperationCanceledException) { }
+            catch (Exception e)
+            {
+                NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Error handling WebSocket connection: {e.Message}");
+            }
+            finally
+            {
+                if (socket != null)
+                {
+                    lock (_webSocketLock)
+                    {
+                        _activeWebSockets.Remove(socket);
+                    }
+                    try { socket.Dispose(); } catch { }
+                }
+            }
+        }
+
+        private static void HandleHttpRequest(HttpListenerContext context)
+        {
+            try
+            {
+                if (!IsValidOrigin(context))
+                {
+                    context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
+                    context.Response.Close();
+                    return;
+                }
+
+                if (context.Request.HttpMethod != "POST")
+                {
+                    context.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
+                    context.Response.Close();
+                    return;
+                }
+
+                if (!TryReadRequestBody(context, out string requestJson)) return;
+
+                bool isProbeMethod = !string.IsNullOrEmpty(requestJson) && (requestJson.Contains("\"get_server_status\"") || requestJson.Contains("\"shutdown_server\""));
+                if (!IsAuthorized(context) && !isProbeMethod)
+                {
+                    RejectUnauthorized(context);
+                    return;
+                }
+
+                WriteJsonResponse(context, MCPServerMethods.ProcessJsonRpc(requestJson));
+            }
+            catch (ObjectDisposedException) { }
+            catch (System.Net.HttpListenerException) { }
+            catch (ThreadAbortException) { }
+            catch (Exception e)
+            {
+                NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Error handling HTTP request: {e.Message}");
+            }
+        }
+
+        // Reads the request body with a hard size cap. Returns false (and closes
+        // the response with 413) when the payload is too large.
+        private static bool TryReadRequestBody(HttpListenerContext context, out string requestJson)
+        {
+            requestJson = null;
+
+            if (context.Request.ContentLength64 > MaxPayloadSize)
+            {
+                context.Response.StatusCode = (int)HttpStatusCode.RequestEntityTooLarge;
+                context.Response.Close();
+                return false;
+            }
+
+            using var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding ?? Encoding.UTF8);
+            var sb = new StringBuilder();
+            char[] buffer = new char[4096];
+            int charsRead;
+            long totalChars = 0;
+            while ((charsRead = reader.Read(buffer, 0, buffer.Length)) > 0)
+            {
+                totalChars += charsRead;
+                if (totalChars > MaxPayloadSize)
+                {
+                    context.Response.StatusCode = (int)HttpStatusCode.RequestEntityTooLarge;
+                    context.Response.Close();
+                    return false;
+                }
+                sb.Append(buffer, 0, charsRead);
+            }
+
+            requestJson = sb.ToString();
+            return true;
+        }
+
+        private static void WriteJsonResponse(HttpListenerContext context, string response)
+        {
+            byte[] responseBuffer = Encoding.UTF8.GetBytes(response);
+            context.Response.ContentType = "application/json";
+            context.Response.ContentLength64 = responseBuffer.Length;
+            context.Response.OutputStream.Write(responseBuffer, 0, responseBuffer.Length);
+            context.Response.Close();
+        }
+
+        private static bool IsAuthorized(HttpListenerContext context)
+        {
+            string requestToken = context.Request.Headers[AuthTokenHeaderName];
+            if (string.IsNullOrEmpty(requestToken))
+            {
+                requestToken = context.Request.Headers["X-Nexus-Auth-Token"];
+            }
+            return IsAuthorizedToken(requestToken);
+        }
+
+        internal static bool IsAuthorizedToken(string token)
+        {
+            if (string.IsNullOrEmpty(token)) return false;
+            string activeToken = AuthToken?.Trim();
+            if (string.Equals(token.Trim(), activeToken, StringComparison.Ordinal)) return true;
+
+            string fileToken = ReadTokenFile();
+            if (!string.IsNullOrEmpty(fileToken) && string.Equals(token.Trim(), fileToken.Trim(), StringComparison.Ordinal))
+            {
+                _authToken = fileToken.Trim();
+                return true;
+            }
+            return false;
+        }
+
+        private static void RejectUnauthorized(HttpListenerContext context)
+        {
+            context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
+            context.Response.Close();
+        }
+
+        private static async Task ReceiveWebsocketLoop(WebSocket ws, CancellationToken token)
+        {
+            var buffer = new byte[4096];
+            using var ms = new MemoryStream();
+
+            while (ws.State == WebSocketState.Open && !token.IsCancellationRequested)
+            {
+                ms.SetLength(0);
+                WebSocketReceiveResult result = null;
+                do
+                {
+                    result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer), token);
+                    if (result.MessageType == WebSocketMessageType.Close)
+                    {
+                        await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
+                        return;
+                    }
+
+                    if (ms.Length + result.Count > MaxPayloadSize)
+                    {
+                        NexusEditorLog.Error(NexusLogCategory.Server, "[MCP] WebSocket payload exceeded maximum size. Disconnecting.");
+                        await ws.CloseAsync(WebSocketCloseStatus.MessageTooBig, "Payload too large", CancellationToken.None);
+                        return;
+                    }
+
+                    ms.Write(buffer, 0, result.Count);
+                } while (!result.EndOfMessage && !token.IsCancellationRequested);
+
+                if (result != null && result.EndOfMessage && ms.Length > 0 && result.MessageType == WebSocketMessageType.Text)
+                {
+                    ms.Position = 0;
+                    using var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, leaveOpen: true);
+                    string response = MCPServerMethods.ProcessJsonRpc(reader);
+                    if (ws.State == WebSocketState.Open)
+                    {
+                        var respBuffer = Encoding.UTF8.GetBytes(response);
+                        await ws.SendAsync(new ArraySegment<byte>(respBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Editor/MCPServer.Http.cs.meta b/Editor/MCPServer.Http.cs.meta
new file mode 100644
index 0000000..176d5cc
--- /dev/null
+++ b/Editor/MCPServer.Http.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8330794c5d0144803a7aab494c148263
\ No newline at end of file
diff --git a/Editor/MCPServer.Identity.cs b/Editor/MCPServer.Identity.cs
new file mode 100644
index 0000000..f2a09c2
--- /dev/null
+++ b/Editor/MCPServer.Identity.cs
@@ -0,0 +1,142 @@
+using System;
+using System.IO;
+using System.Threading;
+using UnityEditor;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    // Package version resolution and auth-token lifecycle. Split out of
+    // MCPServer.cs to keep each file under the readability line budget; this is
+    // the same partial MCPServer class.
+    public static partial class MCPServer
+    {
+        private static string ReadPackageVersion()
+        {
+            try
+            {
+                var pkgInfo = UnityEditor.PackageManager.PackageInfo.FindForAssembly(typeof(MCPServer).Assembly);
+                if (pkgInfo != null && !string.IsNullOrEmpty(pkgInfo.version))
+                {
+                    return pkgInfo.version;
+                }
+            }
+            catch { }
+
+            try
+            {
+                string packageJsonPath = Path.GetFullPath(Path.Combine(UnityEngine.Application.dataPath, "NexusUnity", "package.json"));
+                if (!File.Exists(packageJsonPath))
+                {
+                    packageJsonPath = Path.GetFullPath(Path.Combine(UnityEngine.Application.dataPath, "..", "package.json"));
+                }
+                if (File.Exists(packageJsonPath))
+                {
+                    var json = JObject.Parse(File.ReadAllText(packageJsonPath));
+                    string ver = json["version"]?.ToString();
+                    if (!string.IsNullOrEmpty(ver)) return ver;
+                }
+            }
+            catch { }
+
+            return "1.5.0";
+        }
+
+        internal static string AuthToken => EnsureAuthToken();
+
+        private static readonly object AuthTokenLock = new object();
+
+        private static string EnsureAuthToken()
+        {
+            if (!string.IsNullOrEmpty(_authToken)) return _authToken;
+
+            lock (AuthTokenLock)
+            {
+                if (!string.IsNullOrEmpty(_authToken)) return _authToken;
+
+                bool isMainThread = _mainThreadId != -1 && Thread.CurrentThread.ManagedThreadId == _mainThreadId;
+
+                if (isMainThread)
+                {
+                    try
+                    {
+                        _authToken = SessionState.GetString(AuthSessionStateKey, string.Empty);
+                    }
+                    catch { }
+                }
+
+                if (string.IsNullOrEmpty(_authToken))
+                {
+                    _authToken = ReadTokenFile();
+                }
+
+                if (string.IsNullOrEmpty(_authToken))
+                {
+                    _authToken = Guid.NewGuid().ToString("N") + Guid.NewGuid().ToString("N");
+                }
+
+                if (isMainThread)
+                {
+                    try
+                    {
+                        SessionState.SetString(AuthSessionStateKey, _authToken);
+                    }
+                    catch { }
+                }
+
+                WriteTokenFile(_authToken);
+                return _authToken;
+            }
+        }
+
+        internal static string RotateAuthToken()
+        {
+            lock (AuthTokenLock)
+            {
+                _authToken = Guid.NewGuid().ToString("N") + Guid.NewGuid().ToString("N");
+                bool isMainThread = _mainThreadId != -1 && Thread.CurrentThread.ManagedThreadId == _mainThreadId;
+                if (isMainThread)
+                {
+                    try
+                    {
+                        SessionState.SetString(AuthSessionStateKey, _authToken);
+                    }
+                    catch { }
+                }
+                WriteTokenFile(_authToken);
+                return _authToken;
+            }
+        }
+
+        private static void WriteTokenFile(string token)
+        {
+            try
+            {
+                string projectRoot = Path.GetFullPath(Path.Combine(UnityEngine.Application.dataPath, ".."));
+                string libraryDir = Path.Combine(projectRoot, "Library");
+                if (!Directory.Exists(libraryDir))
+                {
+                    Directory.CreateDirectory(libraryDir);
+                }
+                File.WriteAllText(Path.Combine(libraryDir, "NexusUnityAuthToken.txt"), token);
+            }
+            catch { }
+        }
+
+        internal static string ReadTokenFile()
+        {
+            try
+            {
+                string projectRoot = Path.GetFullPath(Path.Combine(UnityEngine.Application.dataPath, ".."));
+                string tokenPath = Path.Combine(projectRoot, "Library", "NexusUnityAuthToken.txt");
+                if (File.Exists(tokenPath))
+                {
+                    return File.ReadAllText(tokenPath).Trim();
+                }
+            }
+            catch { }
+            return null;
+        }
+    }
+}
diff --git a/Editor/MCPServer.Identity.cs.meta b/Editor/MCPServer.Identity.cs.meta
new file mode 100644
index 0000000..a906697
--- /dev/null
+++ b/Editor/MCPServer.Identity.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9f13ba6d1a3634e36b859ac8821b1841
\ No newline at end of file
diff --git a/Editor/MCPServer.Logs.cs b/Editor/MCPServer.Logs.cs
index f2d263c..ac15c59 100644
--- a/Editor/MCPServer.Logs.cs
+++ b/Editor/MCPServer.Logs.cs
@@ -42,17 +42,17 @@ public static List<LogEntry> GetLogsSince(long cursor, string[] severities, stri
         {
             SyncWithUnityConsole();
             var query = _logs.AsEnumerable().Where(l => l.Id > cursor);
-            
+
             if (severities != null && severities.Length > 0)
             {
                 query = query.Where(l => severities.Any(s => l.Type.Equals(s, StringComparison.OrdinalIgnoreCase)));
             }
-            
+
             if (!string.IsNullOrEmpty(searchText))
             {
                 query = query.Where(l => l.Message.Contains(searchText) || l.StackTrace.Contains(searchText));
             }
-            
+
             return query.ToList();
         }
 
@@ -65,7 +65,7 @@ private static void SyncWithUnityConsole()
 
                 var getCountMethod = type.GetMethod("GetCount");
                 var getEntryMethod = type.GetMethod("GetEntryInternal");
-                
+
                 if (getCountMethod == null || getEntryMethod == null) return;
 
                 int count = (int)getCountMethod.Invoke(null, null);
@@ -83,7 +83,7 @@ private static void SyncWithUnityConsole()
                     string msg = (string)messageField.GetValue(entry);
                     string stack = (string)stackField.GetValue(entry);
                     int mode = (int)typeField.GetValue(entry);
-                    
+
                     LogType logType = LogType.Log;
                     if ((mode & 1) != 0) logType = LogType.Error;
                     else if ((mode & 2) != 0) logType = LogType.Warning;
@@ -124,9 +124,6 @@ private static void RuntimeInitLogs()
         {
             Application.logMessageReceivedThreaded -= OnLogMessageReceived;
             Application.logMessageReceivedThreaded += OnLogMessageReceived;
-
-            UnityMCP.Runtime.MCPRuntimeLogger.OnLogReceived -= OnLogMessageReceived;
-            UnityMCP.Runtime.MCPRuntimeLogger.OnLogReceived += OnLogMessageReceived;
         }
 
         private static void OnLogMessageReceived(string condition, string stackTrace, LogType type)
diff --git a/Editor/MCPServer.Networking.cs b/Editor/MCPServer.Networking.cs
index fd3acc0..0800d5e 100644
--- a/Editor/MCPServer.Networking.cs
+++ b/Editor/MCPServer.Networking.cs
@@ -1,77 +1,16 @@
 using System;
-using System.IO;
 using System.Net;
-using System.Net.WebSockets;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using UnityEditor;
 using UnityEngine;
-using Newtonsoft.Json.Linq;
 
 namespace UnityMCP.Editor
 {
+    // Server lifecycle, HttpListener setup, accept loop, and shutdown cleanup.
+    // Probing existing instances and port discovery live in MCPServer.Discovery.cs.
     public static partial class MCPServer
     {
-        private static async Task<bool> IsAnotherMcpInstanceRunning()
-        {
-            using var client = new System.Net.Http.HttpClient();
-            client.Timeout = TimeSpan.FromMilliseconds(500); 
-            client.DefaultRequestHeaders.Add(AuthTokenHeaderName, AuthToken);
-            try
-            {
-                var content = new System.Net.Http.StringContent("{\"jsonrpc\":\"2.0\",\"method\":\"get_server_status\",\"params\":{},\"id\":1}", Encoding.UTF8, "application/json");
-                var response = await client.PostAsync($"http://127.0.0.1:{_port}/", content);
-                if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden) return true;
-                string body = await response.Content.ReadAsStringAsync();
-                
-                if (body.Contains("serverAlive"))
-                {
-                    var json = JObject.Parse(body);
-                    string remoteProjectPath = json["result"]?["projectPath"]?.ToString();
-                    string localProjectPath = Directory.GetCurrentDirectory().Replace("\\", "/");
-                    int remotePid = json["result"]?["processId"]?.Value<int>() ?? -1;
-                    int localPid = System.Diagnostics.Process.GetCurrentProcess().Id;
-
-                    if (!string.IsNullOrEmpty(remoteProjectPath))
-                    {
-                        if (remoteProjectPath == localProjectPath)
-                        {
-                            if (remotePid == localPid)
-                            {
-                                NexusEditorLog.Warning(NexusLogCategory.Server, $"[MCP] Detected zombie listener from previous domain (PID: {localPid}). Disconnecting stale entity...");
-                                var shutdownContent = new System.Net.Http.StringContent("{\"jsonrpc\":\"2.0\",\"method\":\"shutdown_server\",\"params\":{},\"id\":1}", Encoding.UTF8, "application/json");
-                                try { await client.PostAsync($"http://127.0.0.1:{_port}/", shutdownContent); } catch { }
-                                await Task.Delay(200); // Give it time to close
-                                return false; // Allow Start() to try binding its own listener
-                            }
-
-                            NexusEditorLog.Log(NexusLogCategory.Server, $"[MCP] Existing MCP server found on port {_port}. Project matches current workspace. Action taken: attached to existing session.", true);
-                            return true;
-                        }
-                        else
-                        {
-                            NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Existing MCP server found on port {_port}. Project does NOT match current workspace. Action required: choose another port or stop the other session. Remote project: {remoteProjectPath} (PID: {remotePid})");
-                            return true; // We consider it "running" to prevent attempting to start our own and throwing a cryptic error
-                        }
-                    }
-                }
-                
-                // Fallback to old initialize method just in case it's an older server
-                var initContent = new System.Net.Http.StringContent("{\"jsonrpc\":\"2.0\",\"method\":\"initialize\",\"params\":{},\"id\":1}", Encoding.UTF8, "application/json");
-                var initResponse = await client.PostAsync($"http://127.0.0.1:{_port}/", initContent);
-                if (initResponse.StatusCode == HttpStatusCode.Unauthorized || initResponse.StatusCode == HttpStatusCode.Forbidden) return true;
-                string initBody = await initResponse.Content.ReadAsStringAsync();
-                if (initBody.Contains("Unity MCP Server")) {
-                    NexusEditorLog.Log(NexusLogCategory.Server, $"[MCP] Connected to an older existing session on port {_port}", true);
-                    return true;
-                }
-
-                return false;
-            }
-            catch { return false; }
-        }
-
         private static void BindAndStartListener()
         {
             try
@@ -103,7 +42,7 @@ private static async Task ServerLoop(CancellationToken token)
                 while (!token.IsCancellationRequested && _listener != null && _listener.IsListening)
                 {
                     var context = await _listener.GetContextAsync();
-                    if (context.Request.IsWebSocketRequest) await ProcessWebSocket(context);
+                    if (context.Request.IsWebSocketRequest) _ = Task.Run(() => ProcessWebSocket(context));
                     else _ = Task.Run(() => HandleHttpRequest(context));
                 }
             }
@@ -112,172 +51,112 @@ private static async Task ServerLoop(CancellationToken token)
                 if (!token.IsCancellationRequested)
                     NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Fatal server loop error: {e.Message}");
             }
-            finally { if (_state == ServerState.Running) _state = ServerState.Stopped; }
-        }
-
-        private static bool IsValidOrigin(HttpListenerContext context)
-        {
-            if (!context.Request.Url.IsLoopback) return false;
-
-            string origin = context.Request.Headers["Origin"];
-            if (string.IsNullOrEmpty(origin)) return true;
-
-            try
-            {
-                Uri originUri = new Uri(origin);
-                return originUri.IsLoopback && (originUri.Scheme == Uri.UriSchemeHttp || originUri.Scheme == Uri.UriSchemeHttps);
-            }
-            catch
+            finally
             {
-                return false;
+                if (_state == ServerState.Running) _state = ServerState.Stopped;
             }
         }
 
-        private static async Task ProcessWebSocket(HttpListenerContext context)
+        /// <summary>
+        /// Starts the loopback-only Nexus Unity HTTP/WebSocket server and persists restart intent in Unity <see cref="EditorPrefs"/>.
+        /// </summary>
+        /// <remarks>
+        /// Startup must run from the Unity Editor main thread; background calls are marshaled through <see cref="EditorApplication.delayCall"/>.
+        /// The method initializes tool dispatch, resolves or allocates the configured port, records restart intent, may attach to an
+        /// existing Nexus Unity instance on the same port, and enables the macOS App Nap bypass before binding the listener.
+        /// </remarks>
+        public static void Start()
         {
-            if (!IsValidOrigin(context))
+            if (_mainThreadId != -1 && Thread.CurrentThread.ManagedThreadId != _mainThreadId)
             {
-                context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
-                context.Response.Close();
+                EditorApplication.delayCall += Start;
                 return;
             }
 
-            if (!IsAuthorized(context))
+            lock (_startLock)
             {
-                RejectUnauthorized(context);
-                return;
+                if (_state == ServerState.Running || _state == ServerState.Starting) return;
+                _state = ServerState.Starting;
+                LastError = null;
+                _cts = new CancellationTokenSource();
             }
 
-            var wsContext = await context.AcceptWebSocketAsync(null);
-            _webSocket = wsContext.WebSocket;
-            await ReceiveWebsocketLoop(_cts.Token);
-        }
+            MCPServerMethods.Init();
+            EnsureAuthToken();
+            if (EditorApplication.isPlaying) Application.runInBackground = true;
 
-        private static void HandleHttpRequest(HttpListenerContext context)
-        {
-            try {
-                if (!IsValidOrigin(context))
-                {
-                    context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
-                    context.Response.Close();
-                    return;
-                }
-
-                if (!IsAuthorized(context))
-                {
-                    RejectUnauthorized(context);
-                    return;
-                }
+            ResolvePort();
 
-                if (context.Request.HttpMethod != "POST") {
-                    context.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
-                    context.Response.Close();
-                    return;
-                }
+            EditorPrefs.SetBool(StablePrefsKey, true);
+            NexusEditorLog.Log(NexusLogCategory.Server, $"[MCP] Attempting to start server on port {_port}...", true);
 
-                const long maxPayloadSize = 10 * 1024 * 1024; // 10MB limit to prevent memory exhaustion
-                if (context.Request.ContentLength64 > maxPayloadSize)
-                {
-                    context.Response.StatusCode = (int)HttpStatusCode.RequestEntityTooLarge;
-                    context.Response.Close();
-                    return;
-                }
+            var token = _cts.Token;
+            Task.Run(() => StartListenerAsync(token));
+        }
 
-                string requestJson;
-                using (var reader = new System.IO.StreamReader(context.Request.InputStream, context.Request.ContentEncoding ?? Encoding.UTF8))
-                {
-                    var sb = new System.Text.StringBuilder();
-                    char[] buffer = new char[4096];
-                    int charsRead;
-                    int totalChars = 0;
-                    while ((charsRead = reader.Read(buffer, 0, buffer.Length)) > 0)
-                    {
-                        totalChars += charsRead;
-                        if (totalChars > maxPayloadSize)
-                        {
-                            context.Response.StatusCode = (int)HttpStatusCode.RequestEntityTooLarge;
-                            context.Response.Close();
-                            return;
-                        }
-                        sb.Append(buffer, 0, charsRead);
-                    }
-                    requestJson = sb.ToString();
-                }
+        // Runs off the main thread: attaches to an existing instance if one owns
+        // the port, otherwise binds our own listener.
+        private static async Task StartListenerAsync(CancellationToken token)
+        {
+            try
+            {
+                if (IsPortBusy(_port) && !await TryClaimBusyPort()) return;
 
-                string response = MCPServerMethods.ProcessJsonRpc(requestJson);
-                byte[] responseBuffer = Encoding.UTF8.GetBytes(response);
-                context.Response.ContentType = "application/json";
-                context.Response.ContentLength64 = responseBuffer.Length;
-                context.Response.OutputStream.Write(responseBuffer, 0, responseBuffer.Length);
-                context.Response.Close();
+                if (token.IsCancellationRequested) return;
+                #if UNITY_EDITOR_OSX
+                AppNapBypass.Enable();
+                #endif
+                BindAndStartListener();
             }
-            catch (ObjectDisposedException) { }
-            catch (System.Net.HttpListenerException) { }
-            catch (ThreadAbortException) { }
             catch (Exception e)
             {
-                NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Error handling HTTP request: {e.Message}");
+                _state = ServerState.Error;
+                LastError = e.Message;
+                NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Server start error: {e.Message}");
             }
         }
 
-        private static bool IsAuthorized(HttpListenerContext context)
-        {
-            return IsAuthorizedToken(context.Request.Headers[AuthTokenHeaderName]);
-        }
-
-        internal static bool IsAuthorizedToken(string token)
+        /// <summary>
+        /// Stops the Nexus Unity server on the editor main thread, clears restart intent, disables macOS App Nap bypass, and closes listeners.
+        /// </summary>
+        /// <remarks>
+        /// Calls from background threads are marshaled through <see cref="Enqueue"/> before mutating Unity editor state.
+        /// Cleanup cancels pending server work and closes the HTTP listener/WebSocket state used by the local automation server.
+        /// </remarks>
+        public static void Stop()
         {
-            return !string.IsNullOrEmpty(token) && string.Equals(token, _authToken, StringComparison.Ordinal);
-        }
-
-        private static void RejectUnauthorized(HttpListenerContext context)
-        {
-            context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
-            context.Response.Close();
+            if (Thread.CurrentThread.ManagedThreadId != _mainThreadId)
+            {
+                MCPServer.Enqueue(Stop);
+                return;
+            }
+            EditorPrefs.SetBool(StablePrefsKey, false);
+            #if UNITY_EDITOR_OSX
+            AppNapBypass.Disable();
+            #endif
+            Cleanup();
         }
 
-        private static async Task ReceiveWebsocketLoop(CancellationToken token)
+        internal static void Cleanup()
         {
-            var buffer = new byte[4096];
-            using var ms = new MemoryStream();
-            const long maxPayloadSize = 10 * 1024 * 1024; // 10MB limit
-
-            while (_webSocket.State == WebSocketState.Open && !token.IsCancellationRequested)
+            lock (_startLock)
             {
-                ms.SetLength(0);
-                WebSocketReceiveResult result;
-                do
+                _cts?.Cancel();
+                lock (_webSocketLock)
                 {
-                    result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), token);
-                    if (result.MessageType == WebSocketMessageType.Close)
+                    foreach (var ws in _activeWebSockets)
                     {
-                        await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
-                        return;
+                        try { ws?.Dispose(); } catch { }
                     }
-
-                    if (ms.Length + result.Count > maxPayloadSize)
-                    {
-                        NexusEditorLog.Error(NexusLogCategory.Server, "[MCP] WebSocket payload exceeded maximum size. Disconnecting.");
-                        await _webSocket.CloseAsync(WebSocketCloseStatus.MessageTooBig, "Payload too large", CancellationToken.None);
-                        return;
-                    }
-
-                    ms.Write(buffer, 0, result.Count);
-                } while (!result.EndOfMessage && !token.IsCancellationRequested);
-
-                if (ms.Length > 0 && result.MessageType == WebSocketMessageType.Text)
+                    _activeWebSockets.Clear();
+                }
+                if (_listener != null)
                 {
-                    ms.Position = 0;
-                    using (var reader = new System.IO.StreamReader(ms, Encoding.UTF8, false, 1024, leaveOpen: true))
-                    {
-                        string response = MCPServerMethods.ProcessJsonRpc(reader);
-                        if (_webSocket.State == WebSocketState.Open)
-                        {
-                            var respBuffer = Encoding.UTF8.GetBytes(response);
-                            await _webSocket.SendAsync(new ArraySegment<byte>(respBuffer), WebSocketMessageType.Text, true, CancellationToken.None);
-                        }
-                    }
+                    try { if (_listener.IsListening) _listener.Stop(); } catch { }
+                    try { _listener.Close(); } catch { }
+                    _listener = null;
                 }
+                _state = ServerState.Stopped;
             }
         }
     }
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 86e9b47..075ddd3 100644
--- a/Editor/MCPServer.cs
+++ b/Editor/MCPServer.cs
@@ -10,6 +10,7 @@
 using System.Linq;
 using UnityEditor;
 using UnityEngine;
+using Newtonsoft.Json.Linq;
 
 namespace UnityMCP.Editor
 {
@@ -25,9 +26,9 @@ public enum ServerState { Stopped, Starting, Running, Attached, Error }
 
     public static partial class MCPServer
     {
-        private static string _version = "1.4.0";
+        private static string _version;
         private static long _logCounter = 0;
-        public static string Version => _version;
+        public static string Version => _version ?? (_version = ReadPackageVersion());
 
         public static string SessionId { get; private set; }
         public static int SessionGeneration { get; private set; }
@@ -50,11 +51,12 @@ public static partial class MCPServer
         public static string LastError { get; private set; }
 
         private static HttpListener _listener;
-        private static WebSocket _webSocket;
+        private static readonly System.Collections.Generic.HashSet<WebSocket> _activeWebSockets = new System.Collections.Generic.HashSet<WebSocket>();
+        private static readonly object _webSocketLock = new object();
         private static CancellationTokenSource _cts;
         private static int? _cliPortOverride;
         private const int _MAX_LOGS = 5000;
-        
+
         private static string GetDeterministicProjectKey()
         {
             int hash = 17;
@@ -65,7 +67,7 @@ private static string GetDeterministicProjectKey()
         private static string _prefsKeyCached;
         private static string StablePrefsKey => _prefsKeyCached ?? (_prefsKeyCached = GetDeterministicProjectKey());
         private static string AuthSessionStateKey => StablePrefsKey + "_AuthToken";
-        
+
         private static int _mainThreadId = -1;
         public static int MainThreadId => _mainThreadId;
 
@@ -78,7 +80,11 @@ internal static void RefreshMainThreadCachedState()
             IsUpdatingCached = EditorApplication.isUpdating;
             IsPlayingCached = EditorApplication.isPlaying;
             IsPausedCached = EditorApplication.isPaused;
-            IsPlayModeTransitionCached = EditorApplication.isPlayingOrWillChangePlaymode;
+            // 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;
         }
 
@@ -88,22 +94,6 @@ static MCPServer()
             _logs = new ConcurrentQueue<LogEntry>();
         }
 
-        internal static string AuthToken => EnsureAuthToken();
-
-        private static string EnsureAuthToken()
-        {
-            if (!string.IsNullOrEmpty(_authToken)) return _authToken;
-
-            _authToken = SessionState.GetString(AuthSessionStateKey, string.Empty);
-            if (string.IsNullOrEmpty(_authToken))
-            {
-                _authToken = Guid.NewGuid().ToString("N") + Guid.NewGuid().ToString("N");
-                SessionState.SetString(AuthSessionStateKey, _authToken);
-            }
-
-            return _authToken;
-        }
-
         [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
         private static void RuntimeInit() => Init();
 
@@ -122,14 +112,34 @@ internal static void Init()
                 SessionState.SetInt("MCP_SessionGen", SessionGeneration);
                 EnsureAuthToken();
             }
-            
+
             RefreshMainThreadCachedState();
+            Application.runInBackground = true;
             #if UNITY_EDITOR_OSX
             AppNapBypass.CacheApplicationPath();
+            AppNapBypass.Enable();
             #endif
             MCPServerMethods.Init();
             InitTimeline();
-            
+
+            SubscribeEditorEvents();
+
+            ParseCommandLineArgs();
+            _port = _cliPortOverride ?? MCPSettings.Port;
+
+            if (EditorPrefs.GetBool(StablePrefsKey, false)) ScheduleAutoStart();
+
+            #if UNITY_EDITOR_OSX
+            _postCompileFramesToWait = 15;
+            EditorApplication.update -= HandlePostCompileFocusReturn;
+            EditorApplication.update += HandlePostCompileFocusReturn;
+            #endif
+        }
+
+        // Idempotent (unsubscribe-then-subscribe) so it is safe to call on every
+        // domain reload without stacking duplicate handlers.
+        private static void SubscribeEditorEvents()
+        {
             EditorApplication.update -= HandleMainThreadQueue;
             EditorApplication.update += HandleMainThreadQueue;
             Application.logMessageReceivedThreaded -= OnLogMessageReceived;
@@ -140,31 +150,23 @@ internal static void Init()
             Application.logMessageReceived += OnLogMessageReceived;
             #endif
 
-            UnityMCP.Runtime.MCPRuntimeLogger.OnLogReceived -= OnLogMessageReceived;
-            UnityMCP.Runtime.MCPRuntimeLogger.OnLogReceived += OnLogMessageReceived;            
             AssemblyReloadEvents.beforeAssemblyReload -= Cleanup;
             AssemblyReloadEvents.beforeAssemblyReload += Cleanup;
+        }
 
-            ParseCommandLineArgs();
-            _port = _cliPortOverride ?? MCPSettings.Port;
-            
-            if (EditorPrefs.GetBool(StablePrefsKey, false))
-            {
-                int framesToWait = 60;
-                EditorApplication.CallbackFunction autoStart = null;
-                autoStart = () => {
-                    if (framesToWait-- <= 0) {
-                        EditorApplication.update -= autoStart;
-                        if (_state != ServerState.Running) Start();
-                    }
-                };
-                EditorApplication.update += autoStart;
-            }
-
-            #if UNITY_EDITOR_OSX
-            _postCompileFramesToWait = 15;
-            EditorApplication.update += HandlePostCompileFocusReturn;
-            #endif
+        // Restart intent was persisted in EditorPrefs, so start the server a few
+        // frames after the reload settles rather than during Init itself.
+        private static void ScheduleAutoStart()
+        {
+            int framesToWait = 60;
+            EditorApplication.CallbackFunction autoStart = null;
+            autoStart = () => {
+                if (framesToWait-- <= 0) {
+                    EditorApplication.update -= autoStart;
+                    if (_state != ServerState.Running) Start();
+                }
+            };
+            EditorApplication.update += autoStart;
         }
 
         #if UNITY_EDITOR_OSX
@@ -183,125 +185,5 @@ private static void HandlePostCompileFocusReturn()
 
         public static int Port => _port;
         public static bool IsRunning => _state == ServerState.Running;
-
-        /// <summary>
-        /// Starts the loopback-only Nexus Unity HTTP/WebSocket server and persists restart intent in Unity <see cref="EditorPrefs"/>.
-        /// </summary>
-        /// <remarks>
-        /// Startup must run from the Unity Editor main thread; background calls are marshaled through <see cref="EditorApplication.delayCall"/>.
-        /// The method initializes tool dispatch, resolves or allocates the configured port, records restart intent, may attach to an
-        /// existing Nexus Unity instance on the same port, and enables the macOS App Nap bypass before binding the listener.
-        /// </remarks>
-        public static void Start()
-        {
-            if (_mainThreadId != -1 && Thread.CurrentThread.ManagedThreadId != _mainThreadId)
-            {
-                EditorApplication.delayCall += Start;
-                return;
-            }
-
-            lock (_startLock)
-            {
-                if (_state == ServerState.Running || _state == ServerState.Starting) return;
-                _state = ServerState.Starting;
-                LastError = null;
-                _cts = new CancellationTokenSource();
-            }
-            
-            MCPServerMethods.Init();
-            EnsureAuthToken();
-            if (EditorApplication.isPlaying) Application.runInBackground = true;
-
-            if (_port <= 0) {
-                ParseCommandLineArgs();
-                _port = _cliPortOverride ?? MCPSettings.Port;
-            }
-
-            if (_port == 0)
-            {
-                try {
-                    var l = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
-                    l.Start();
-                    _port = ((System.Net.IPEndPoint)l.LocalEndpoint).Port;
-                    l.Stop();
-                    System.Threading.Thread.Sleep(100);
-                } catch { }
-            }
-            
-            EditorPrefs.SetBool(StablePrefsKey, true);
-            NexusEditorLog.Log(NexusLogCategory.Server, $"[MCP] Attempting to start server on port {_port}...", true);
-
-            var token = _cts.Token;
-            Task.Run(async () => {
-                try {
-                    if (IsPortBusy(_port))
-                    {
-                        if (await IsAnotherMcpInstanceRunning()) {
-                            _state = ServerState.Attached;
-                            return;
-                        }
-                        
-                        string owner = GetPortOwner(_port);
-                        if (owner != "Unknown Process")
-                        {
-                            _state = ServerState.Error;
-                            LastError = $"Port {_port} is being used by another application: {owner}.";
-                            NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] {LastError}");
-                            return;
-                        }
-                        NexusEditorLog.Warning(NexusLogCategory.Server, $"[MCP] Port {_port} reported busy by Unknown Process. Proceeding with force-bind attempt...");
-                    }
-
-                    if (token.IsCancellationRequested) return;
-                    #if UNITY_EDITOR_OSX
-                    AppNapBypass.Enable();
-                    #endif
-                    BindAndStartListener();
-                } catch (Exception e) {
-                    _state = ServerState.Error;
-                    LastError = e.Message;
-                    NexusEditorLog.Error(NexusLogCategory.Server, $"[MCP] Server start error: {e.Message}");
-                }
-            });
-        }
-
-        /// <summary>
-        /// Stops the Nexus Unity server on the editor main thread, clears restart intent, disables macOS App Nap bypass, and closes listeners.
-        /// </summary>
-        /// <remarks>
-        /// Calls from background threads are marshaled through <see cref="Enqueue"/> before mutating Unity editor state.
-        /// Cleanup cancels pending server work and closes the HTTP listener/WebSocket state used by the local automation server.
-        /// </remarks>
-        public static void Stop()
-        {
-            if (Thread.CurrentThread.ManagedThreadId != _mainThreadId)
-            {
-                MCPServer.Enqueue(Stop);
-                return;
-            }
-            EditorPrefs.SetBool(StablePrefsKey, false);
-            #if UNITY_EDITOR_OSX
-            AppNapBypass.Disable();
-            #endif
-            Cleanup();
-        }
-
-        internal static void Cleanup()
-        {
-            lock (_startLock)
-            {
-                _cts?.Cancel();
-                if (_listener != null)
-                {
-                    try { if (_listener.IsListening) _listener.Stop(); } catch { }
-                    try { _listener.Close(); } catch { }
-                    _listener = null;
-                }
-                _state = ServerState.Stopped;
-            }
-        }
-
-
-
     }
 }
diff --git a/Editor/MCPServerMethods.Asset.cs b/Editor/MCPServerMethods.Asset.cs
index a5cf9e1..517b642 100644
--- a/Editor/MCPServerMethods.Asset.cs
+++ b/Editor/MCPServerMethods.Asset.cs
@@ -39,7 +39,7 @@ private static JToken ExploreAsset(JToken p)
         {
             if (p?["path"] == null) throw new Exception("path required");
             string path = ValidateAssetPath(p["path"].ToString());
-            
+
             string mainGuid = AssetDatabase.AssetPathToGUID(path);
             if (string.IsNullOrEmpty(mainGuid)) throw new Exception($"Asset not found at path: {path}");
 
@@ -47,35 +47,21 @@ private static JToken ExploreAsset(JToken p)
             if (allAssets == null || allAssets.Length == 0) throw new Exception($"No assets loaded at path: {path}");
 
             var mainAsset = AssetDatabase.LoadMainAssetAtPath(path);
-            
+
             JObject result = new JObject { ["guid"] = mainGuid };
             JArray subAssetsArr = new JArray();
 
             foreach (var asset in allAssets)
             {
                 if (asset == null) continue;
-                
                 if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out string guid, out long fileId))
                 {
-                    var assetData = new JObject
-                    {
-                        ["name"] = asset.name,
-                        ["type"] = asset.GetType().Name,
-                        ["file_id"] = fileId,
-                        ["instance_id"] = asset.GetRawId()
-                    };
-                    
-                    if (asset == mainAsset)
-                    {
-                        result["main_asset"] = assetData;
-                    }
-                    else
-                    {
-                        subAssetsArr.Add(assetData);
-                    }
+                    var assetData = new JObject { ["name"] = asset.name, ["type"] = asset.GetType().Name, ["file_id"] = fileId, ["instance_id"] = asset.GetRawId() };
+                    if (asset == mainAsset) result["main_asset"] = assetData;
+                    else subAssetsArr.Add(assetData);
                 }
             }
-            
+
             result["sub_assets"] = subAssetsArr;
             return result;
         }
@@ -101,15 +87,10 @@ private static JToken CreateMaterial(JToken p)
             ApplyOptionalMaterialColor(mat, p["emission_color"] ?? (p["emission"]?.Type == JTokenType.Boolean ? null : p["emission"]), true);
 
             string path = p["path"]?.ToString();
-            if (string.IsNullOrEmpty(path))
-            {
-                path = Path.Combine("Assets", $"{name}.mat");
-            }
-            else if (!path.EndsWith(".mat", StringComparison.OrdinalIgnoreCase))
-            {
-                path += ".mat";
-            }
-            path = ValidateAssetPath(path);
+            if (string.IsNullOrEmpty(path)) path = Path.Combine("Assets", $"{name}.mat");
+            else if (!path.EndsWith(".mat", StringComparison.OrdinalIgnoreCase)) path += ".mat";
+
+            path = ValidateWritableAssetPath(path);
             string fullPath = ValidatePath(path);
             string directory = Path.GetDirectoryName(fullPath);
             if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
@@ -187,9 +168,9 @@ private static JToken RefreshAssetDatabase(JToken p)
             var logs = MCPServer.GetLogs(20, "Error", "");
             var compilerErrors = logs.Where(l => l.Message.Contains("error CS")).Select(l => l.Message).ToList();
 
-            return new JObject 
-            { 
-                ["status"] = compilerErrors.Count > 0 ? "Error" : (EditorApplication.isCompiling ? "Compiling" : "Success"), 
+            return new JObject
+            {
+                ["status"] = compilerErrors.Count > 0 ? "Error" : (EditorApplication.isCompiling ? "Compiling" : "Success"),
                 ["is_compiling"] = EditorApplication.isCompiling,
                 ["is_updating"] = EditorApplication.isUpdating,
                 ["compiler_errors"] = new JArray(compilerErrors)
@@ -199,24 +180,16 @@ private static JToken RefreshAssetDatabase(JToken p)
         private static JToken ImportAsset(JToken p)
         {
             if (p == null || p["path"] == null) throw new Exception("path is required");
-            string path = ValidateAssetPath(p["path"].ToString());
+            string path = ValidateWritableAssetPath(p["path"].ToString());
             AssetDatabase.ImportAsset(path);
             return new JObject { ["status"] = "Success", ["message"] = "Imported" };
         }
 
-
-
-
-
-
-        // Helper for isolated prefab asset edits
-
         private static JToken MoveAsset(JToken p)
         {
             if (p?["old_path"] == null || p["new_path"] == null) throw new Exception("old_path and new_path required");
-            
-            string oldPath = ValidateAssetPath(p["old_path"].ToString());
-            string newPath = ValidateAssetPath(p["new_path"].ToString());
+            string oldPath = ValidateWritableAssetPath(p["old_path"].ToString());
+            string newPath = ValidateWritableAssetPath(p["new_path"].ToString(), allowAssetsRoot: true);
 
             if (AssetDatabase.IsValidFolder(oldPath) && AssetDatabase.IsValidFolder(newPath))
             {
@@ -224,6 +197,12 @@ private static JToken MoveAsset(JToken p)
                 return new JObject { ["status"] = "Success", ["message"] = "OK (Merged)" };
             }
 
+            if (newPath.Equals("Assets", StringComparison.OrdinalIgnoreCase))
+            {
+                string fileName = Path.GetFileName(oldPath);
+                newPath = Path.Combine("Assets", fileName).Replace("\\", "/");
+            }
+
             string result = AssetDatabase.MoveAsset(oldPath, newPath);
             if (!string.IsNullOrEmpty(result)) throw new Exception(result);
             return new JObject { ["status"] = "Success", ["message"] = "OK" };
@@ -235,10 +214,8 @@ private static void MergeDirectories(string sourceDir, string targetDir)
             foreach (var file in files)
             {
                 if (file.EndsWith(".meta")) continue;
-                
                 string fileName = Path.GetFileName(file);
                 string destFile = Path.Combine(targetDir, fileName).Replace("\\", "/");
-                
                 string result = AssetDatabase.MoveAsset(file.Replace("\\", "/"), destFile);
                 if (!string.IsNullOrEmpty(result)) throw new Exception($"Failed to move {fileName}: {result}");
             }
@@ -248,12 +225,7 @@ private static void MergeDirectories(string sourceDir, string targetDir)
             {
                 string dirName = Path.GetFileName(dir);
                 string destDir = Path.Combine(targetDir, dirName).Replace("\\", "/");
-                
-                if (!AssetDatabase.IsValidFolder(destDir))
-                {
-                    AssetDatabase.CreateFolder(targetDir, dirName);
-                }
-                
+                if (!AssetDatabase.IsValidFolder(destDir)) AssetDatabase.CreateFolder(targetDir, dirName);
                 MergeDirectories(dir.Replace("\\", "/"), destDir);
             }
 
@@ -263,8 +235,22 @@ private static void MergeDirectories(string sourceDir, string targetDir)
         private static JToken DeleteAsset(JToken p)
         {
             if (p?["path"] == null) throw new Exception("path required");
-            string path = ValidateAssetPath(p["path"].ToString());
-            if (!AssetDatabase.DeleteAsset(path)) throw new Exception("Delete failed");
+            if (p?["confirm"]?.Value<bool>() != true) throw new ArgumentException("Deleting an asset requires confirm: true because it is destructive.");
+
+            string rawPath = p["path"]?.ToString()?.Trim();
+            if (string.IsNullOrWhiteSpace(rawPath)) throw new Exception("Asset path cannot be empty");
+            if (rawPath.Contains("\0")) throw new Exception("Invalid character in asset path");
+
+            string path = ValidateWritableAssetPath(rawPath, allowAssetsRoot: false).TrimEnd('/', '\\');
+            if (path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)) throw new Exception("Cannot delete .meta files directly. Delete the main asset file or folder instead.");
+
+            string fullPath = ValidatePath(path);
+            if (!File.Exists(fullPath) && !Directory.Exists(fullPath)) throw new Exception($"Asset not found: {path}");
+
+            bool movedToTrash = AssetDatabase.MoveAssetToTrash(path);
+            if (!movedToTrash) throw new Exception($"Failed to move asset to OS trash at path: '{path}'. Permanent deletion was blocked for security.");
+
+            AssetDatabase.Refresh();
             return new JObject { ["status"] = "Success", ["message"] = "OK" };
         }
 
@@ -272,7 +258,14 @@ private static JToken CopyAsset(JToken p)
         {
             if (p?["source_path"] == null || p["dest_path"] == null) throw new Exception("source_path and dest_path required");
             string sourcePath = ValidateAssetPath(p["source_path"].ToString());
-            string destPath = ValidateAssetPath(p["dest_path"].ToString());
+            string destPath = ValidateWritableAssetPath(p["dest_path"].ToString(), allowAssetsRoot: true);
+
+            if (destPath.Equals("Assets", StringComparison.OrdinalIgnoreCase))
+            {
+                string fileName = Path.GetFileName(sourcePath);
+                destPath = Path.Combine("Assets", fileName).Replace("\\", "/");
+            }
+
             if (!AssetDatabase.CopyAsset(sourcePath, destPath)) throw new Exception("Copy failed");
             return new JObject { ["status"] = "Success", ["message"] = "OK" };
         }
@@ -289,7 +282,7 @@ private static JToken GetDependencies(JToken p)
         private static JToken CreateFolder(JToken p)
         {
             if (p?["path"] == null) throw new Exception("path required (e.g., 'Assets/NewFolder')");
-            string path = ValidateAssetPath(p["path"].ToString());
+            string path = ValidateWritableAssetPath(p["path"].ToString());
             string parent = Path.GetDirectoryName(path).Replace("\\", "/");
             string name = Path.GetFileName(path);
             string guid = AssetDatabase.CreateFolder(parent, name);
@@ -297,4 +290,4 @@ private static JToken CreateFolder(JToken p)
             return new JObject { ["status"] = "Success" };
         }
     }
-}// Force Wed Apr  1 21:53:54 CEST 2026
+}
diff --git a/Editor/MCPServerMethods.Component.cs b/Editor/MCPServerMethods.Component.cs
index a91fad8..0ac317a 100644
--- a/Editor/MCPServerMethods.Component.cs
+++ b/Editor/MCPServerMethods.Component.cs
@@ -34,9 +34,10 @@ private static JToken AddComponent(JToken p)
             if (p == null || p["instance_id"] == null || p["component_name"] == null) throw new Exception("instance_id and component_name required");
             var go = MCPServerMethods.IdToObject(MCPServerMethods.ExtractId(p)) as GameObject;
             if (go == null) throw new Exception("GameObject not found");
-            Type type = FindType(p["component_name"].ToString());
-            if (type == null) throw new Exception($"Type '{p["component_name"]}' not found");
-            return new JObject { ["status"] = "Success", ["message"] = $"Added {p["component_name"]} to {Undo.AddComponent(go, type).name}" };
+            string compName = p["component_name"].ToString();
+            Type type = FindComponentType(compName);
+            if (type == null) throw new Exception($"Type '{compName}' not found or is not a valid attachable Component");
+            return new JObject { ["status"] = "Success", ["message"] = $"Added {compName} to {Undo.AddComponent(go, type).name}" };
         }
 
         private static JToken InspectComponent(JToken p)
@@ -47,7 +48,7 @@ private static JToken InspectComponent(JToken p)
 
             bool detailed = p["detailed"]?.Value<bool>() ?? false;
             JArray fieldsFilter = p["fields"] as JArray;
-            
+
             SerializedObject so = new SerializedObject(comp);
             JObject result = new JObject();
 
@@ -59,7 +60,7 @@ private static JToken InspectComponent(JToken p)
                     var prop = FindPropertyFuzzy(so, fieldName);
                     if (prop != null)
                     {
-                        try { result[fieldName] = SerializeProperty(prop, detailed); } 
+                        try { result[fieldName] = SerializeProperty(prop, detailed); }
                         catch (Exception e) { NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Serialization error for {fieldName}: {e.Message}"); }
                     }
                 }
@@ -71,7 +72,7 @@ private static JToken InspectComponent(JToken p)
                 while (prop.Next(enterChildren))
                 {
                     enterChildren = false; // Only enter children for the root
-                    try { result[prop.name] = SerializeProperty(prop, detailed); } 
+                    try { result[prop.name] = SerializeProperty(prop, detailed); }
                     catch (Exception e) { NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Serialization error for {prop.name}: {e.Message}"); }
                 }
             }
@@ -96,7 +97,7 @@ private static JToken ComponentValues(JToken p)
                 var prop = FindPropertyFuzzy(so, fieldName);
                 if (prop != null)
                 {
-                    try { result[fieldName] = SerializeProperty(prop, false); } 
+                    try { result[fieldName] = SerializeProperty(prop, false); }
                     catch (Exception e) { NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Serialization error for {fieldName}: {e.Message}"); }
                 }
                 else
@@ -152,9 +153,9 @@ private static JToken UpdateComponent(JToken p)
             int updatedCount = UpdateComponentProperties(so, data, errors);
 
             so.ApplyModifiedProperties();
-            
-            return new JObject 
-            { 
+
+            return new JObject
+            {
                 ["status"] = errors.Count == 0 ? "Success" : (updatedCount > 0 ? "Partial" : "Failed"),
                 ["updated_count"] = updatedCount,
                 ["errors"] = errors
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..ec2a0d2 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);
@@ -163,7 +199,7 @@ private static JToken ReadLogsSinceCursor(JToken p)
             bool structured = p?["structured"]?.Value<bool>() ?? false;
 
             var logs = MCPServer.GetLogsSince(cursor, severities, searchText);
-            
+
             if (structured)
             {
                 logs = CollapseLogs(logs);
@@ -179,10 +215,10 @@ private static JToken ReadLogsSinceCursor(JToken p)
         }
 
         private static JToken ClearLogs(JToken p) { MCPServer.ClearLogs(); return new JObject { ["status"] = "Success", ["message"] = "Logs cleared" }; }
-        private static JToken TestCoroutine(JToken p) { 
+        private static JToken TestCoroutine(JToken p) {
             NexusEditorLog.Log(NexusLogCategory.Diagnostics, "[MCP_EXECUTE] test_coroutine");
             EditorApplication.delayCall += () => NexusEditorLog.Log(NexusLogCategory.Diagnostics, "[MCP] Delay call complete");
-            return new JObject { ["status"] = "Success", ["message"] = "Started" }; 
+            return new JObject { ["status"] = "Success", ["message"] = "Started" };
         }
 
         // Cache the tool definitions since they are static and do not change during the session.
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..b91cdcf 100644
--- a/Editor/MCPServerMethods.Delta.cs
+++ b/Editor/MCPServerMethods.Delta.cs
@@ -36,7 +36,7 @@ private class SceneChangeEvent
         private static void RegisterDeltaMethods()
         {
             _methods["scene_delta"] = SceneDelta;
-            
+
             // Register for changes
             ObjectChangeEvents.changesPublished -= OnChangesPublished;
             ObjectChangeEvents.changesPublished += OnChangesPublished;
@@ -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 c729b67..e16a106 100644
--- a/Editor/MCPServerMethods.Editor.cs
+++ b/Editor/MCPServerMethods.Editor.cs
@@ -45,50 +45,16 @@ 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
                 {
-                    ["status"] = "Success",
-                    ["message"] = $"Test run triggered for {modeStr} (filter: {filter ?? "none"})",
+                    ["status"] = "Submitted",
+                    ["message"] = $"Test run submitted for {modeStr} (filter: {filter ?? "none"})",
                     ["mode"] = modeStr,
                     ["filter"] = filter,
                     ["result_path"] = GetDefaultTestResultsPath(),
-                    ["started_at_utc"] = DateTime.UtcNow.ToString("o")
+                    ["submitted_at_utc"] = DateTime.UtcNow.ToString("o")
                 };
             }
             catch (Exception e)
@@ -97,21 +63,46 @@ 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");
             string path = ValidateAssetPath(p["path"].ToString());
-            
+
             var prefabAsset = AssetDatabase.LoadAssetAtPath<GameObject>(path);
             if (prefabAsset == null) throw new System.Exception($"Prefab not found at {path}");
 
             AssetDatabase.OpenAsset(prefabAsset);
             var stage = PrefabStageUtility.GetCurrentPrefabStage();
-            
+
             if (stage != null)
             {
-                return new JObject { 
-                    ["status"] = "Success", 
+                return new JObject {
+                    ["status"] = "Success",
                     ["message"] = $"Opened Prefab Stage for {prefabAsset.name}",
                     ["stage_path"] = stage.assetPath
                 };
@@ -123,7 +114,7 @@ private static JToken ClosePrefabStage(JToken p)
         {
             var stage = PrefabStageUtility.GetCurrentPrefabStage();
             if (stage == null) return new JObject { ["status"] = "Failed", ["message"] = "No Prefab Stage is currently open" };
-            
+
             StageUtility.GoToMainStage();
             return new JObject { ["status"] = "Success", ["message"] = "Returned to Main Stage" };
         }
@@ -156,11 +147,11 @@ private static JToken SetSelection(JToken p)
             if (p == null || p["instance_ids"] == null) throw new System.Exception("instance_ids (array) is required");
             var ids = p["instance_ids"] as JArray;
             if (ids == null) throw new System.Exception("instance_ids must be an array");
-            
+
             var objects = ids.Select(token => MCPServerMethods.IdToObject(MCPServerMethods.ExtractIdFromToken(token)))
                              .Where(o => o != null)
                              .ToArray();
-            
+
             Selection.objects = objects;
             return new JObject { ["status"] = "Success", ["message"] = $"Selected {objects.Length} objects" };
         }
@@ -215,29 +206,16 @@ private static JToken SetProperty(JToken p)
 
             SerializedObject so = new SerializedObject(obj);
             SerializedProperty prop = so.FindProperty(p["property_name"].ToString());
-            
+
             if (prop == null) throw new System.Exception($"Property '{p["property_name"]}' not found on {obj.name}");
 
             Undo.RecordObject(obj, $"Set {p["property_name"]}");
-            ApplyValueToSerializedProperty(prop, p["value"]);
+            ApplySimpleJTokenValue(prop, p["value"], "Value type not supported for surgical edit yet");
 
             so.ApplyModifiedProperties();
             return new JObject { ["status"] = "Success", ["message"] = "Property updated" };
         }
 
-        private static void ApplyValueToSerializedProperty(SerializedProperty prop, JToken val)
-        {
-            if (val.Type == JTokenType.Boolean) prop.boolValue = val.Value<bool>();
-            else if (val.Type == JTokenType.Float) prop.floatValue = val.Value<float>();
-            else if (val.Type == JTokenType.Integer) prop.intValue = val.Value<int>();
-            else if (val.Type == JTokenType.String) prop.stringValue = val.Value<string>();
-            else if (val.Type == JTokenType.Object && val["x"] != null)
-            {
-                prop.vector3Value = new Vector3(val["x"].Value<float>(), val["y"].Value<float>(), val["z"].Value<float>());
-            }
-            else throw new System.Exception("Value type not supported for surgical edit yet");
-        }
-
         /// <summary>Returns current editor state flags.</summary>
         private static JToken GetEditorState(JToken p)
         {
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 5819930..0ebe5e4 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 = FindType(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
@@ -276,7 +185,7 @@ private static JToken WriteFilesBatch(JToken p)
                 System.IO.File.WriteAllText(fullPath, f["content"].ToString());
 
                 string relativePath = fullPath.Substring(root.Length).TrimStart(System.IO.Path.DirectorySeparatorChar, System.IO.Path.AltDirectorySeparatorChar).Replace("\\", "/");
-                
+
                 if (IsCSharpScriptPath(fullPath))
                 {
                     hasScripts = true;
@@ -301,29 +210,52 @@ private static void EnsureParentDirectory(string fullPath)
             if (!string.IsNullOrEmpty(directory)) System.IO.Directory.CreateDirectory(directory);
         }
 
+        private static EditorApplication.CallbackFunction _pendingRefreshCallback;
+
+        static MCPServerMethods()
+        {
+            AssemblyReloadEvents.beforeAssemblyReload += CleanupPendingRefresh;
+            EditorApplication.quitting += CleanupPendingRefresh;
+        }
+
+        private static void CleanupPendingRefresh()
+        {
+            if (_pendingRefreshCallback != null)
+            {
+                EditorApplication.update -= _pendingRefreshCallback;
+                _pendingRefreshCallback = null;
+            }
+        }
+
         private static void TriggerSafeAssetRefresh()
         {
+            CleanupPendingRefresh();
+
             _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
 
-            EditorApplication.CallbackFunction waitForFocus = null;
-            waitForFocus = () => {
-                EditorApplication.update -= waitForFocus;
-                
-                // Trigger refresh immediately. With App Nap bypassed, this is reliable 
-                // even if the focus-switch (open -a) is still in flight.
+            double startTime = EditorApplication.timeSinceStartup;
+            double timeoutSeconds = 15.0;
+
+            _pendingRefreshCallback = () => {
+                var cb = _pendingRefreshCallback;
+                if (cb == null) return;
+                EditorApplication.update -= cb;
+                _pendingRefreshCallback = null;
+
+                if (EditorApplication.timeSinceStartup - startTime > timeoutSeconds)
+                {
+                    NexusEditorLog.Warning(NexusLogCategory.Api, "[MCP] TriggerSafeAssetRefresh timed out waiting for OS focus. Refresh aborted.");
+                    return;
+                }
+
                 AssetDatabase.Refresh();
             };
-            
-            EditorApplication.update += waitForFocus;
+
+            EditorApplication.update += _pendingRefreshCallback;
         }
     }
 }
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..a599691 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();
@@ -164,10 +36,10 @@ private static JToken GenerateMermaidDiagram(JToken p)
                 }
             }
 
-            return new JObject 
-            { 
-                ["status"] = "Success", 
-                ["mermaid"] = sb.ToString() 
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["mermaid"] = sb.ToString()
             };
         }
 
@@ -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.Input.cs b/Editor/MCPServerMethods.Input.cs
index 82b233c..d7e4d15 100644
--- a/Editor/MCPServerMethods.Input.cs
+++ b/Editor/MCPServerMethods.Input.cs
@@ -43,19 +43,38 @@ private static void FocusGameView()
             if (gameView != null) gameView.Focus();
         }
 
+        // A click's release is deferred ~100ms so the button is observably held for
+        // at least one frame. Without tracking that pending release, a second click
+        // issued inside the window queued a press while the button was still down,
+        // so it produced no press edge and was silently lost. Flush any pending
+        // release before starting a new click.
+        private static Action _pendingMouseRelease;
+
+        private static void FlushPendingMouseRelease()
+        {
+            var pending = _pendingMouseRelease;
+            if (pending == null) return;
+            _pendingMouseRelease = null;
+            pending();
+        }
+
         private static void QueueCrossFrameMouseClick(Mouse mouse, MouseState state, MouseButton button)
         {
+            FlushPendingMouseRelease();
+
             // Immediate press
             InputSystem.QueueStateEvent(mouse, state.WithButton(button, true));
             NexusEditorLog.Log(NexusLogCategory.UiAutomation, $"[MCP] Queued mouse {button} PRESS at {state.position}");
 
             // Use a simple timer to release after 100ms
             double releaseTime = EditorApplication.timeSinceStartup + 0.1;
-            
+
             EditorApplication.CallbackFunction releaseAction = null;
-            releaseAction = () => {
-                if (EditorApplication.timeSinceStartup < releaseTime) return;
-                
+            bool released = false;
+
+            Action doRelease = () => {
+                if (released) return;
+                released = true;
                 EditorApplication.update -= releaseAction;
                 if (!EditorApplication.isPlaying) return;
 
@@ -63,6 +82,13 @@ private static void QueueCrossFrameMouseClick(Mouse mouse, MouseState state, Mou
                 NexusEditorLog.Log(NexusLogCategory.UiAutomation, $"[MCP] Queued mouse {button} RELEASE at {state.position}");
             };
 
+            releaseAction = () => {
+                if (EditorApplication.timeSinceStartup < releaseTime) return;
+                _pendingMouseRelease = null;
+                doRelease();
+            };
+
+            _pendingMouseRelease = doRelease;
             EditorApplication.update += releaseAction;
         }
 
@@ -70,8 +96,8 @@ private static JToken SimulateMouse(JToken p)
         {
             var mouse = Mouse.current;
             if (mouse == null) throw new Exception("No active mouse device found.");
-            
-            string action = p["action"]?.ToString() ?? "click"; 
+
+            string action = p["action"]?.ToString() ?? "click";
             Vector2 pos = GetScreenPosition(p);
             int buttonIdx = p["button"]?.Value<int>() ?? 0;
 
@@ -106,7 +132,7 @@ private static JToken SimulateMouse(JToken p)
         private static JToken SimulateTouch(JToken p)
         {
             var touch = Touchscreen.current;
-            if (touch == null) 
+            if (touch == null)
             {
                 touch = InputSystem.AddDevice<Touchscreen>();
             }
@@ -163,9 +189,9 @@ private static JToken ClickObjectInGame(JToken p)
 
             QueueCrossFrameMouseClick(mouse, state, MouseButton.Left);
 
-            return new JObject 
-            { 
-                ["status"] = "Success", 
+            return new JObject
+            {
+                ["status"] = "Success",
                 ["screen_position"] = new JObject { ["x"] = finalPos.x, ["y"] = finalPos.y },
                 ["object_name"] = target.name
             };
diff --git a/Editor/MCPServerMethods.PlayerPrefs.cs b/Editor/MCPServerMethods.PlayerPrefs.cs
index 18929ba..551e1c6 100644
--- a/Editor/MCPServerMethods.PlayerPrefs.cs
+++ b/Editor/MCPServerMethods.PlayerPrefs.cs
@@ -2,6 +2,7 @@
 using System.IO;
 using System.Linq;
 using System.Collections.Generic;
+using System.Text.RegularExpressions;
 using UnityEditor;
 using UnityEngine;
 using Newtonsoft.Json.Linq;
@@ -23,7 +24,7 @@ private static JToken GetPlayerPref(JToken p)
         {
             string key = p["key"].ToString();
             string type = p["type"]?.ToString() ?? "string";
-            
+
             if (type == "int") return PlayerPrefs.GetInt(key, p["default"]?.Value<int>() ?? 0);
             if (type == "float") return PlayerPrefs.GetFloat(key, p["default"]?.Value<float>() ?? 0f);
             return PlayerPrefs.GetString(key, p["default"]?.ToString() ?? "");
@@ -34,11 +35,11 @@ private static JToken SetPlayerPref(JToken p)
             string key = p["key"].ToString();
             string type = p["type"]?.ToString() ?? "string";
             JToken value = p["value"];
-            
+
             if (type == "int") PlayerPrefs.SetInt(key, value.Value<int>());
             else if (type == "float") PlayerPrefs.SetFloat(key, value.Value<float>());
             else PlayerPrefs.SetString(key, value.ToString());
-            
+
             PlayerPrefs.Save();
             return "Success";
         }
@@ -68,116 +69,215 @@ private static JToken DeletePlayerPref(JToken p)
             return "Success";
         }
 
-        private static JToken ListPlayerPrefs(JToken p)
+        private static List<string> CollectPlayerPrefKeys()
+        {
+            try
+            {
+#if UNITY_EDITOR_OSX
+                return CollectMacOsPlayerPrefKeys();
+#elif UNITY_EDITOR_WIN
+                return CollectWindowsPlayerPrefKeys();
+#elif UNITY_EDITOR_LINUX
+                return CollectLinuxPlayerPrefKeys();
+#else
+                return new List<string>();
+#endif
+            }
+            catch (Exception ex)
+            {
+                NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Failed to list PlayerPrefs: {ex.Message}");
+                return new List<string>();
+            }
+        }
+
+        private static string GetSafeCompanyName()
+        {
+            string company = PlayerSettings.companyName;
+            return string.IsNullOrEmpty(company) ? "DefaultCompany" : company;
+        }
+
+        private static string GetSafeProductName()
+        {
+            string product = PlayerSettings.productName;
+            return string.IsNullOrEmpty(product) ? "DefaultProduct" : product;
+        }
+
+#if UNITY_EDITOR_OSX
+        private static List<string> CollectMacOsPlayerPrefKeys()
+        {
+            var keys = new List<string>();
+            string company = GetSafeCompanyName();
+            string product = GetSafeProductName();
+            string bundleId = PlayerSettings.applicationIdentifier;
+            if (string.IsNullOrEmpty(bundleId)) bundleId = $"com.{company}.{product}";
+            string editorPlist = $"unity.{company}.{product}";
+
+            var domainsToCheck = new List<string> { editorPlist, bundleId };
+            foreach (var domain in domainsToCheck)
+            {
+                keys.AddRange(ReadMacOsPlistKeys(domain));
+            }
+            return keys;
+        }
+
+        private static List<string> ReadMacOsPlistKeys(string domain)
         {
-            var result = new JObject();
             var keys = new List<string>();
+            ProcessStartInfo psi = new ProcessStartInfo("defaults");
+            psi.ArgumentList.Add("read");
+            psi.ArgumentList.Add(domain);
+            psi.RedirectStandardOutput = true;
+            psi.RedirectStandardError = false;
+            psi.UseShellExecute = false;
+            psi.CreateNoWindow = true;
 
-            // Note: Unity doesn't provide a native way to list all PlayerPrefs keys.
-            // We use platform-specific logic to find where they are stored.
-            
             try
             {
-#if UNITY_EDITOR_OSX
-                string bundleId = PlayerSettings.applicationIdentifier;
-                if (string.IsNullOrEmpty(bundleId)) bundleId = $"com.{PlayerSettings.companyName}.{PlayerSettings.productName}";
-                
-                // On macOS, Unity Editor stores PlayerPrefs in unity.<Company>.<Product>.plist
-                string editorPlist = $"unity.{PlayerSettings.companyName}.{PlayerSettings.productName}";
-                
-                var domainsToCheck = new List<string> { editorPlist, bundleId };
-                
-                foreach (var domain in domainsToCheck)
+                using (Process process = Process.Start(psi))
                 {
-                    ProcessStartInfo psi = new ProcessStartInfo("defaults", $"read \"{domain}\"");
-                    psi.RedirectStandardOutput = true;
-                    psi.RedirectStandardError = true;
-                    psi.UseShellExecute = false;
-                    psi.CreateNoWindow = true;
-                    
-                    using (Process process = Process.Start(psi))
+                    if (process == null) return keys;
+                    string output = process.StandardOutput.ReadToEnd();
+                    if (!process.WaitForExit(5000))
                     {
-                        string output = process.StandardOutput.ReadToEnd();
-                        process.WaitForExit();
-                        
-                        if (process.ExitCode == 0)
-                        {
-                            var lines = output.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
-                            foreach (var line in lines)
-                            {
-                                var trimmed = line.Trim();
-                                if (trimmed.StartsWith("{") || trimmed.EndsWith("}") || string.IsNullOrEmpty(trimmed) || trimmed.EndsWith("(")) continue;
-                                
-                                int equalIndex = trimmed.IndexOf('=');
-                                if (equalIndex > 0)
-                                {
-                                    string key = trimmed.Substring(0, equalIndex).Trim().Trim('"');
-                                    keys.Add(key);
-                                }
-                            }
-                        }
+                        try { process.Kill(); } catch { }
+                        NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] 'defaults read {domain}' timed out after 5000ms.");
+                        return keys;
+                    }
+
+                    if (process.ExitCode == 0)
+                    {
+                        keys.AddRange(ParseMacOsDefaultsOutput(output));
                     }
                 }
+            }
+            catch (Exception ex)
+            {
+                NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Failed reading macOS plist for domain '{domain}': {ex.Message}");
+            }
+            return keys;
+        }
 #elif UNITY_EDITOR_WIN
-                string registryPath = $@"Software\Unity\UnityEditor\{PlayerSettings.companyName}\{PlayerSettings.productName}";
-                using (var key = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(registryPath))
+        private static List<string> CollectWindowsPlayerPrefKeys()
+        {
+            var keys = new List<string>();
+            string company = GetSafeCompanyName();
+            string product = GetSafeProductName();
+            string registryPath = $@"Software\Unity\UnityEditor\{company}\{product}";
+            using (var key = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(registryPath))
+            {
+                if (key != null)
+                {
+                    foreach (var valueName in key.GetValueNames())
+                    {
+                        keys.Add(UnescapeWindowsRegistryKeyName(valueName));
+                    }
+                }
+            }
+            return keys;
+        }
+#elif UNITY_EDITOR_LINUX
+        private static List<string> CollectLinuxPlayerPrefKeys()
+        {
+            var keys = new List<string>();
+            string company = GetSafeCompanyName();
+            string product = GetSafeProductName();
+            string configDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            string prefsPath = Path.Combine(configDir, ".config", "unity3d", company, product, "prefs");
+
+            if (File.Exists(prefsPath))
+            {
+                try
                 {
-                    if (key != null)
+                    var doc = System.Xml.Linq.XDocument.Load(prefsPath);
+                    foreach (var elem in doc.Descendants("pref"))
                     {
-                        foreach (var valueName in key.GetValueNames())
+                        var nameAttr = elem.Attribute("name");
+                        if (nameAttr != null && !string.IsNullOrEmpty(nameAttr.Value))
                         {
-                            // Unity appends a hash to the end of the key name in the registry
-                            // e.g. "MyKey_h123456789"
-                            int lastUnderscore = valueName.LastIndexOf('_');
-                            if (lastUnderscore > 0)
-                            {
-                                keys.Add(valueName.Substring(0, lastUnderscore));
-                            }
-                            else
-                            {
-                                keys.Add(valueName);
-                            }
+                            keys.Add(nameAttr.Value);
                         }
                     }
                 }
+                catch (Exception ex)
+                {
+                    NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Failed to parse Linux PlayerPrefs XML: {ex.Message}");
+                }
+            }
+            return keys;
+        }
 #endif
+
+        internal static List<string> ParseMacOsDefaultsOutput(string output)
+        {
+            var keys = new List<string>();
+            if (string.IsNullOrEmpty(output)) return keys;
+
+            var lineRegex = new Regex(@"^\s*(?:""((?:[^""\\]|\\.)+)""|([^\s=]+))\s*=", RegexOptions.Multiline);
+            var matches = lineRegex.Matches(output);
+            foreach (Match match in matches)
+            {
+                string rawKey = match.Groups[1].Success ? match.Groups[1].Value : match.Groups[2].Value;
+                if (!string.IsNullOrEmpty(rawKey))
+                {
+                    string unescaped = rawKey.Replace("\\\"", "\"").Replace("\\\\", "\\");
+                    keys.Add(unescaped);
+                }
             }
-            catch (Exception ex)
+            return keys;
+        }
+
+        internal static string UnescapeWindowsRegistryKeyName(string valueName)
+        {
+            if (string.IsNullOrEmpty(valueName)) return valueName;
+            int lastUnderscore = valueName.LastIndexOf('_');
+            if (lastUnderscore > 0 && lastUnderscore < valueName.Length - 1 && valueName[lastUnderscore + 1] == 'h')
             {
-                NexusEditorLog.Warning(NexusLogCategory.Api, $"[MCP] Failed to list PlayerPrefs: {ex.Message}");
+                string hashPart = valueName.Substring(lastUnderscore + 2);
+                if (hashPart.Length > 0 && hashPart.All(char.IsDigit))
+                {
+                    return valueName.Substring(0, lastUnderscore);
+                }
+            }
+            return valueName;
+        }
+
+        internal static JToken ReadPlayerPrefValue(string key)
+        {
+            const string def1 = "__NEXUS_PLPREF_DEF_1__";
+            const string def2 = "__NEXUS_PLPREF_DEF_2__";
+
+            string sVal1 = PlayerPrefs.GetString(key, def1);
+            string sVal2 = PlayerPrefs.GetString(key, def2);
+            if (sVal1 == sVal2 && sVal1 != def1)
+            {
+                return sVal1;
             }
 
-            // Now populate the result with values using the standard Unity API
+            int iVal1 = PlayerPrefs.GetInt(key, 0);
+            int iVal2 = PlayerPrefs.GetInt(key, 1);
+            if (iVal1 == iVal2) return iVal1;
+
+            float fVal1 = PlayerPrefs.GetFloat(key, 0f);
+            float fVal2 = PlayerPrefs.GetFloat(key, 1f);
+            if (Mathf.Approximately(fVal1, fVal2)) return fVal1;
+
+            return "[Unknown Type]";
+        }
+
+        private static JToken ListPlayerPrefs(JToken p)
+        {
+            var result = new JObject();
+            var keys = CollectPlayerPrefKeys();
+
             foreach (var key in keys.Distinct())
             {
                 if (PlayerPrefs.HasKey(key))
                 {
-                    // Best effort to get the value.
-                    // If it's a string, GetString works.
-                    // If it's an int, GetString might return empty, but GetInt will work.
-                    // Since we can't be sure, we'll try to get it as string.
-                    // If it's empty, we try int and float.
-                    string sVal = PlayerPrefs.GetString(key, null);
-                    if (sVal != null) 
-                    {
-                        result[key] = sVal;
-                    }
-                    else
-                    {
-                        // Try int
-                        int iVal = PlayerPrefs.GetInt(key, int.MinValue);
-                        if (iVal != int.MinValue) result[key] = iVal;
-                        else
-                        {
-                            float fVal = PlayerPrefs.GetFloat(key, float.NaN);
-                            if (!float.IsNaN(fVal)) result[key] = fVal;
-                            else result[key] = "[Unknown Type]";
-                        }
-                    }
+                    result[key] = ReadPlayerPrefValue(key);
                 }
             }
 
-            return new JObject { 
+            return new JObject {
                 ["prefs"] = result,
                 ["bundleIdentifier"] = PlayerSettings.applicationIdentifier
             };
diff --git a/Editor/MCPServerMethods.Prefab.cs b/Editor/MCPServerMethods.Prefab.cs
index be4b835..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 { ApplyValueToSerializedPropertyAsset(prop, propPair.Value); 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,20 +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 void ApplyValueToSerializedPropertyAsset(SerializedProperty prop, JToken val)
+        private static int ApplyPrefabPropertyEdits(SerializedObject serializedObject, JObject data, JArray errors)
         {
-            if (val.Type == JTokenType.Boolean) prop.boolValue = val.Value<bool>();
-            else if (val.Type == JTokenType.Float) prop.floatValue = val.Value<float>();
-            else if (val.Type == JTokenType.Integer) prop.intValue = val.Value<int>();
-            else if (val.Type == JTokenType.String) prop.stringValue = val.Value<string>();
-            else if (val.Type == JTokenType.Object && val["x"] != null)
+            int updatedCount = 0;
+            foreach (var propPair in data)
             {
-                prop.vector3Value = new Vector3(val["x"].Value<float>(), val["y"].Value<float>(), val["z"].Value<float>());
+                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 });
+                }
             }
-            else throw new Exception("Value type not supported for surgical asset edit yet");
+            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
new file mode 100644
index 0000000..3cffd3c
--- /dev/null
+++ b/Editor/MCPServerMethods.References.cs
@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static JToken FindReferences(JToken p)
+        {
+            string targetGuid = p?["target_guid"]?.ToString();
+            EntityId targetId = MCPServerMethods.ExtractId(p, "target_id");
+
+            if (string.IsNullOrEmpty(targetGuid) && targetId == default)
+                throw new System.Exception("Either target_guid or target_id is required.");
+
+            Object targetObject = ResolveTargetObject(targetGuid, targetId);
+            if (targetObject == null)
+                throw new System.Exception("Could not find the target object.");
+
+            string searchGuid = GetSearchGuid(targetGuid, targetObject);
+            JArray assetRefs = FindAssetReferences(searchGuid);
+
+            HashSet<EntityId> targetInstanceIds = BuildTargetInstanceIds(targetObject, searchGuid);
+            JArray sceneRefs = FindSceneReferences(targetInstanceIds);
+
+            var result = new JObject();
+            result["status"] = "Success";
+            result["asset_references"] = assetRefs;
+            result["scene_references"] = sceneRefs;
+            return result;
+        }
+
+        private static Object ResolveTargetObject(string targetGuid, EntityId targetId)
+        {
+            if (!string.IsNullOrEmpty(targetGuid))
+            {
+                string path = AssetDatabase.GUIDToAssetPath(targetGuid);
+                if (!string.IsNullOrEmpty(path))
+                    return AssetDatabase.LoadAssetAtPath<Object>(path);
+            }
+            else if (targetId != default)
+            {
+                return MCPServerMethods.IdToObject(targetId);
+            }
+            return null;
+        }
+
+        private static string GetSearchGuid(string targetGuid, Object targetObject)
+        {
+            if (!string.IsNullOrEmpty(targetGuid)) return targetGuid;
+            string path = AssetDatabase.GetAssetPath(targetObject);
+            return !string.IsNullOrEmpty(path) ? AssetDatabase.AssetPathToGUID(path) : null;
+        }
+
+        private static JArray FindAssetReferences(string searchGuid)
+        {
+            var assetRefs = new JArray();
+            if (!string.IsNullOrEmpty(searchGuid))
+            {
+                string[] dependencies = AssetDatabase.FindAssets("ref:" + searchGuid);
+                foreach (var guid in dependencies)
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(guid);
+                    if (!string.IsNullOrEmpty(path))
+                        assetRefs.Add(path);
+                }
+            }
+            return assetRefs;
+        }
+
+        private static HashSet<EntityId> BuildTargetInstanceIds(Object targetObject, string searchGuid)
+        {
+            var targetInstanceIds = new HashSet<EntityId>();
+            if (targetObject != null)
+                targetInstanceIds.Add(targetObject.GetId());
+
+            if (!string.IsNullOrEmpty(searchGuid))
+            {
+                string path = AssetDatabase.GUIDToAssetPath(searchGuid);
+                if (!string.IsNullOrEmpty(path))
+                {
+                    var allAssets = AssetDatabase.LoadAllAssetsAtPath(path);
+                    foreach (var a in allAssets)
+                    {
+                        if (a != null)
+                            targetInstanceIds.Add(a.GetId());
+                    }
+                }
+            }
+            return targetInstanceIds;
+        }
+
+        private static JArray FindSceneReferences(HashSet<EntityId> targetInstanceIds)
+        {
+            var sceneRefs = new JArray();
+            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)
+                {
+                    if (go.scene == null || !go.scene.isLoaded) continue;
+
+                    go.GetComponents(components);
+                    var goMatches = InspectGameObjectReferences(components, targetInstanceIds);
+                    if (goMatches.Count > 0)
+                    {
+                        var goData = new JObject
+                        {
+                            ["name"] = go.name,
+                            ["instance_id"] = go.GetRawId(),
+                            ["references"] = goMatches
+                        };
+                        sceneRefs.Add(goData);
+                    }
+                }
+            }
+            return sceneRefs;
+        }
+
+        private static JArray InspectGameObjectReferences(List<Component> components, HashSet<EntityId> targetInstanceIds)
+        {
+            var goMatches = new JArray();
+            foreach (var comp in components)
+            {
+                if (comp == null) continue;
+
+                using (var so = new SerializedObject(comp))
+                {
+                    var prop = so.GetIterator();
+                    bool enterChildren = true;
+                    while (prop.Next(enterChildren))
+                    {
+                        enterChildren = false;
+                        if (prop.propertyType == SerializedPropertyType.ObjectReference)
+                        {
+                            var propId = MCPServerMethods.GetObjectReferenceId(prop);
+                            var objRef = prop.objectReferenceValue;
+
+                            bool directMatch = targetInstanceIds.Contains(propId);
+                            bool indirectMatch = objRef != null && targetInstanceIds.Contains(objRef.GetId());
+
+                            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.References.cs.meta b/Editor/MCPServerMethods.References.cs.meta
new file mode 100644
index 0000000..f1a9a50
--- /dev/null
+++ b/Editor/MCPServerMethods.References.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a7d83f219b4e4c91a2578b930d8c11e2
diff --git a/Editor/MCPServerMethods.Reflection.Symbols.cs b/Editor/MCPServerMethods.Reflection.Symbols.cs
new file mode 100644
index 0000000..dfb31df
--- /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 c297a0d..158253a 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,37 +16,11 @@ 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;
             _methods["invoke_method"] = InvokeMethod;
-            
+
             // Trigger initial scan
             StartIndexing();
         }
@@ -58,13 +30,13 @@ private static void AddReflectionTools(JArray tools)
             tools.Add(CreateTool("symbol_index", "Index and search all compiled symbols (Classes, Methods, Fields)", new JObject
             {
                 ["query"] = new JObject { ["type"] = "string", ["description"] = "Fuzzy or Regex search query" },
-                ["type_filter"] = new JObject { 
-                    ["type"] = "string", 
+                ["type_filter"] = new JObject {
+                    ["type"] = "string",
                     ["enum"] = new JArray("Class", "Method", "Field"),
                     ["description"] = "Optional: Filter by symbol type"
                 }
             }));
-            
+
             tools.Add(CreateTool("invoke_method", "Invoke a C# method on a component", new JObject
             {
                 ["instance_id"] = new JObject { ["type"] = "integer" },
@@ -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";
@@ -238,48 +56,15 @@ internal static string GetTypeName(Type type)
             return name;
         }
 
-        internal static Type FindType(string name)
-        {
-            if (string.IsNullOrEmpty(name)) return null;
-            if (_typeCache.TryGetValue(name, out var cachedType)) return cachedType;
-
-            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
-            Type resultType = null;
-            
-            // Priority 1: Check Assembly-CSharp
-            var mainAsm = assemblies.FirstOrDefault(a => a.GetName().Name == "Assembly-CSharp");
-            if (mainAsm != null)
-            {
-                resultType = mainAsm.GetType(name) ?? mainAsm.GetTypes().FirstOrDefault(x => x.Name == name);
-            }
-
-            // Priority 2: Check all other assemblies
-            if (resultType == null)
-            {
-                foreach (var a in assemblies)
-                {
-                    try 
-                    {
-                        resultType = a.GetType(name) ?? a.GetTypes().FirstOrDefault(x => x.Name == name);
-                        if (resultType != null) break;
-                    }
-                    catch { }
-                }
-            }
-
-            _typeCache[name] = resultType;
-            return resultType;
-        }
-
         private static JToken InvokeMethod(JToken p)
         {
-            if (p == null || p["instance_id"] == null || p["method_name"] == null) 
+            if (p == null || p["instance_id"] == null || p["method_name"] == null)
                 throw new Exception("instance_id and method_name required");
 
             object target = ResolveTarget(p);
             string methodName = p["method_name"].ToString();
             var argsArray = p["arguments"] as JArray ?? new JArray();
-            
+
             var method = ResolveMethod(target, methodName, argsArray);
             var invokeArgs = PrepareArguments(method, argsArray);
 
@@ -321,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;
@@ -345,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();
@@ -377,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)
                 {
@@ -399,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.ScriptableObject.cs b/Editor/MCPServerMethods.ScriptableObject.cs
index 7b83685..31d0006 100644
--- a/Editor/MCPServerMethods.ScriptableObject.cs
+++ b/Editor/MCPServerMethods.ScriptableObject.cs
@@ -28,7 +28,7 @@ private static JToken DiffScriptableObjectAgainstDefaults(JToken p)
         {
             var so = GetScriptableObject(p);
             var defaults = ScriptableObject.CreateInstance(so.GetType());
-            
+
             var sObj = new SerializedObject(so);
             var sDefaults = new SerializedObject(defaults);
 
@@ -72,7 +72,7 @@ private static ScriptableObject GetScriptableObject(JToken p, string pathKey = "
                 if (so == null) throw new Exception($"ScriptableObject not found at path: {path}");
                 return so;
             }
-            
+
             EntityId id = ExtractId(p, idKey);
             if (!id.Equals(default(EntityId)))
             {
@@ -139,13 +139,13 @@ private static JToken ReadScriptableObject(JToken p)
             JObject result = new JObject();
             SerializedProperty prop = serializedObj.GetIterator();
             bool enterChildren = true;
-            
+
             while (prop.Next(enterChildren))
             {
                 enterChildren = false;
                 try { result[prop.name] = SerializeProperty(prop, detailed); } catch { }
             }
-            
+
             result["status"] = "Success";
             result["type"] = so.GetType().Name;
             result["name"] = so.name;
@@ -167,8 +167,8 @@ private static JToken UpdateScriptableObject(JToken p)
             serializedObj.ApplyModifiedProperties();
             AssetDatabase.SaveAssets();
 
-            return new JObject 
-            { 
+            return new JObject
+            {
                 ["status"] = errors.Count > 0 ? "Partial Success" : "Success",
                 ["updated_count"] = updatedCount,
                 ["errors"] = errors
@@ -181,19 +181,18 @@ private static JToken CreateScriptableObjectAsset(JToken p)
             string typeName = p["type"].ToString();
             string path = ValidateAssetPath(p["path"].ToString());
 
-            Type type = FindType(typeName);
-            if (type == null) throw new Exception($"Type '{typeName}' not found");
-            if (!typeof(ScriptableObject).IsAssignableFrom(type)) throw new Exception($"Type '{typeName}' is not a ScriptableObject");
+            Type type = FindScriptableObjectType(typeName);
+            if (type == null) throw new Exception($"Type '{typeName}' not found or is not a valid instantiable ScriptableObject");
 
             var instance = ScriptableObject.CreateInstance(type);
             AssetDatabase.CreateAsset(instance, path);
             AssetDatabase.SaveAssets();
 
-            return new JObject 
-            { 
-                ["status"] = "Success", 
-                ["path"] = path, 
-                ["instance_id"] = instance.GetRawId() 
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["path"] = path,
+                ["instance_id"] = instance.GetRawId()
             };
         }
 
@@ -207,11 +206,11 @@ private static JToken DuplicateScriptableObjectAsset(JToken p)
             AssetDatabase.SaveAssets();
 
             var newAsset = AssetDatabase.LoadAssetAtPath<ScriptableObject>(dest);
-            return new JObject 
-            { 
-                ["status"] = "Success", 
-                ["path"] = dest, 
-                ["instance_id"] = newAsset != null ? newAsset.GetRawId() : 0 
+            return new JObject
+            {
+                ["status"] = "Success",
+                ["path"] = dest,
+                ["instance_id"] = newAsset != null ? newAsset.GetRawId() : 0
             };
         }
 
@@ -220,14 +219,15 @@ private static JToken ListFieldsForType(JToken p)
             if (p["type"] == null) throw new Exception("'type' required");
             string typeName = p["type"].ToString();
 
-            Type type = FindType(typeName);
-            if (type == null) throw new Exception($"Type '{typeName}' not found");
+            Type type = FindScriptableObjectType(typeName) ?? FindComponentType(typeName);
+            if (type == null) throw new Exception($"Type '{typeName}' not found or is not an inspectable Component/ScriptableObject");
 
             JArray result = new JArray();
-            
+
             // For ScriptableObjects and Components, we use SerializedObject to get serializable fields
             if (typeof(ScriptableObject).IsAssignableFrom(type))
             {
+                if (type.IsAbstract) throw new Exception($"Type '{typeName}' is abstract and cannot be instantiated");
                 var temp = ScriptableObject.CreateInstance(type);
                 var so = new SerializedObject(temp);
                 var prop = so.GetIterator();
@@ -235,10 +235,10 @@ private static JToken ListFieldsForType(JToken p)
                 while (prop.Next(enterChildren))
                 {
                     enterChildren = false;
-                    result.Add(new JObject 
-                    { 
-                        ["name"] = prop.name, 
-                        ["type"] = prop.propertyType.ToString(), 
+                    result.Add(new JObject
+                    {
+                        ["name"] = prop.name,
+                        ["type"] = prop.propertyType.ToString(),
                         ["displayName"] = prop.displayName,
                         ["tooltip"] = prop.tooltip
                     });
@@ -247,7 +247,7 @@ private static JToken ListFieldsForType(JToken p)
             }
             else
             {
-                // Generic reflection for non-Unity objects if needed, 
+                // Generic reflection for non-Unity objects if needed,
                 // but usually users want this for Unity serializable types.
                 var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                 foreach (var f in fields)
diff --git a/Editor/MCPServerMethods.Search.cs b/Editor/MCPServerMethods.Search.cs
index 21a8b16..a82bcc1 100644
--- a/Editor/MCPServerMethods.Search.cs
+++ b/Editor/MCPServerMethods.Search.cs
@@ -62,7 +62,7 @@ private static JToken FindObjects(JToken p)
             string name = p?["name"]?.ToString();
             string tag = p?["tag"]?.ToString();
             string typeName = p?["type"]?.ToString();
-            
+
             IEnumerable<GameObject> results;
 
             if (!string.IsNullOrEmpty(typeName))
@@ -82,11 +82,7 @@ private static JToken FindObjects(JToken p)
                     .Where(go => go.hideFlags == HideFlags.None);
             }
 
-            if (!string.IsNullOrEmpty(name))
-            {
-                var regex = new System.Text.RegularExpressions.Regex(name, System.Text.RegularExpressions.RegexOptions.IgnoreCase);
-                results = results.Where(go => regex.IsMatch(go.name));
-            }
+            results = FilterByName(results, name);
 
             if (!string.IsNullOrEmpty(tag))
                 results = results.Where(go => go.CompareTag(tag));
@@ -94,6 +90,38 @@ private static JToken FindObjects(JToken p)
             return new JObject { ["objects"] = new JArray(results.Take(50).Select(SerializeGameObject)) };
         }
 
+        private static IEnumerable<GameObject> FilterByName(IEnumerable<GameObject> results, string name)
+        {
+            if (string.IsNullOrEmpty(name)) return results;
+
+            System.Text.RegularExpressions.Regex regex = null;
+            try
+            {
+                regex = new System.Text.RegularExpressions.Regex(name, System.Text.RegularExpressions.RegexOptions.IgnoreCase, System.TimeSpan.FromMilliseconds(100));
+            }
+            catch (System.ArgumentException)
+            {
+                // Invalid regex pattern (e.g. "Player (1)"), fallback to literal substring search
+            }
+
+            if (regex != null)
+            {
+                return results.Where(go =>
+                {
+                    try
+                    {
+                        return regex.IsMatch(go.name);
+                    }
+                    catch (System.Text.RegularExpressions.RegexMatchTimeoutException)
+                    {
+                        return go.name.IndexOf(name, System.StringComparison.OrdinalIgnoreCase) >= 0;
+                    }
+                });
+            }
+
+            return results.Where(go => go.name.IndexOf(name, System.StringComparison.OrdinalIgnoreCase) >= 0);
+        }
+
         private static Stack<string> _pathStackCache = new Stack<string>();
 
         private static JToken GetObjectPath(JToken p)
@@ -121,129 +149,5 @@ private static JToken PingObject(JToken p)
             EditorGUIUtility.PingObject(obj);
             return new JObject { ["status"] = "Success", ["message"] = "Pinged" };
         }
-
-        private static JToken FindReferences(JToken p)
-        {
-            string targetGuid = p?["target_guid"]?.ToString();
-            EntityId targetId = MCPServerMethods.ExtractId(p, "target_id");
-
-            if (string.IsNullOrEmpty(targetGuid) && targetId == default)
-                throw new System.Exception("Either target_guid or target_id is required.");
-
-            Object targetObject = null;
-            if (!string.IsNullOrEmpty(targetGuid))
-            {
-                string path = AssetDatabase.GUIDToAssetPath(targetGuid);
-                if (!string.IsNullOrEmpty(path))
-                    targetObject = AssetDatabase.LoadAssetAtPath<Object>(path);
-            }
-            else if (targetId != default)
-            {
-                targetObject = MCPServerMethods.IdToObject(targetId);
-            }
-
-            if (targetObject == null)
-                throw new System.Exception("Could not find the target object.");
-
-            var assetRefs = new JArray();
-            string searchGuid = targetGuid;
-
-            if (string.IsNullOrEmpty(searchGuid))
-            {
-                string path = AssetDatabase.GetAssetPath(targetObject);
-                if (!string.IsNullOrEmpty(path))
-                    searchGuid = AssetDatabase.AssetPathToGUID(path);
-            }
-
-            if (!string.IsNullOrEmpty(searchGuid))
-            {
-                string[] dependencies = AssetDatabase.FindAssets("ref:" + searchGuid);
-                foreach (var guid in dependencies)
-                {
-                    string path = AssetDatabase.GUIDToAssetPath(guid);
-                    if (!string.IsNullOrEmpty(path))
-                        assetRefs.Add(path);
-                }
-            }
-
-            var sceneRefs = new JArray();
-            var allGameObjects = Resources.FindObjectsOfTypeAll<GameObject>()
-                .Where(go => go.hideFlags == HideFlags.None || go.hideFlags == HideFlags.NotEditable);
-
-            var targetInstanceIds = new HashSet<EntityId>();
-            if (targetObject != null)
-                targetInstanceIds.Add(targetObject.GetId());
-
-            if (!string.IsNullOrEmpty(searchGuid))
-            {
-                string path = AssetDatabase.GUIDToAssetPath(searchGuid);
-                if (!string.IsNullOrEmpty(path))
-                {
-                    var allAssets = AssetDatabase.LoadAllAssetsAtPath(path);
-                    foreach (var a in allAssets)
-                    {
-                        if (a != null)
-                            targetInstanceIds.Add(a.GetId());
-                    }
-                }
-            }
-
-            using (UnityEngine.Pool.ListPool<Component>.Get(out var components))
-            {
-                foreach (var go in allGameObjects)
-                {
-                    if (go.scene == null || !go.scene.isLoaded) continue;
-
-                    go.GetComponents(components);
-                    var goMatches = new JArray();
-
-                    foreach (var comp in components)
-                    {
-                        if (comp == null) continue;
-
-                        using (var so = new SerializedObject(comp))
-                        {
-                            var prop = so.GetIterator();
-                            bool enterChildren = true;
-                            while (prop.Next(enterChildren))
-                            {
-                                enterChildren = false;
-                                if (prop.propertyType == SerializedPropertyType.ObjectReference)
-                                {
-                                    var propId = MCPServerMethods.GetObjectReferenceId(prop);
-                                    var objRef = prop.objectReferenceValue;
-                                    
-                                    bool directMatch = targetInstanceIds.Contains(propId);
-                                    bool indirectMatch = objRef != null && targetInstanceIds.Contains(objRef.GetId());
-
-                                    if (directMatch || indirectMatch)
-                                    {
-                                        var matchDetail = new JObject();
-                                        matchDetail["component"] = GetTypeName(comp.GetType());
-                                        matchDetail["field"] = prop.propertyPath;
-                                        goMatches.Add(matchDetail);
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    if (goMatches.Count > 0)
-                    {
-                        var goData = new JObject();
-                        goData["name"] = go.name;
-                        goData["instance_id"] = go.GetRawId();
-                        goData["references"] = goMatches;
-                        sceneRefs.Add(goData);
-                    }
-                }
-            }
-
-            var result = new JObject();
-            result["status"] = "Success";
-            result["asset_references"] = assetRefs;
-            result["scene_references"] = sceneRefs;
-            return result;
-        }
     }
 }
diff --git a/Editor/MCPServerMethods.Serialization.Properties.cs b/Editor/MCPServerMethods.Serialization.Properties.cs
new file mode 100644
index 0000000..2e57fa6
--- /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 d3127d0..c93db24 100644
--- a/Editor/MCPServerMethods.Serialization.cs
+++ b/Editor/MCPServerMethods.Serialization.cs
@@ -30,7 +30,7 @@ private static JToken InspectObject(JToken p)
 
             bool detailed = p["detailed"]?.Value<bool>() ?? false;
             var so = new SerializedObject(obj);
-            
+
             JObject result = new JObject();
             var prop = so.GetIterator();
             bool enterChildren = true;
@@ -44,100 +44,10 @@ private static JToken InspectObject(JToken p)
             result["type"] = obj.GetType().Name;
             result["name"] = obj.name;
             result["instance_id"] = obj.GetRawId();
-            
-            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)
                 {
-                    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; }
-                        }
-                    }
+                    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)
+                {
+                    if (asset == null) continue;
+                    AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out _, out long id);
+                    if (id == fileId) { prop.objectReferenceValue = asset; break; }
                 }
             }
         }
@@ -307,5 +218,16 @@ private static void ApplyValueToProperty(SerializedProperty prop, object value)
             else if (value is string s) prop.stringValue = s;
             else if (value is Vector3 v) prop.vector3Value = v;
         }
+
+        private static void ApplySimpleJTokenValue(SerializedProperty prop, JToken value, string unsupportedMessage)
+        {
+            if (value.Type == JTokenType.Boolean) prop.boolValue = value.Value<bool>();
+            else if (value.Type == JTokenType.Float) prop.floatValue = value.Value<float>();
+            else if (value.Type == JTokenType.Integer) prop.intValue = value.Value<int>();
+            else if (value.Type == JTokenType.String) prop.stringValue = value.Value<string>();
+            else if (value.Type == JTokenType.Object && value["x"] != null)
+                prop.vector3Value = new Vector3(value["x"].Value<float>(), value["y"].Value<float>(), value["z"].Value<float>());
+            else throw new Exception(unsupportedMessage);
+        }
     }
 }
diff --git a/Editor/MCPServerMethods.SerializationUtils.cs b/Editor/MCPServerMethods.SerializationUtils.cs
new file mode 100644
index 0000000..88ca849
--- /dev/null
+++ b/Editor/MCPServerMethods.SerializationUtils.cs
@@ -0,0 +1,136 @@
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        internal static JObject SerializeVector3(Vector3 v)
+        {
+            return new JObject { ["x"] = v.x, ["y"] = v.y, ["z"] = v.z };
+        }
+
+        internal static string SerializeColor(Color c)
+        {
+            return "#" + ColorUtility.ToHtmlStringRGBA(c);
+        }
+
+        private static EditorWindow FindWindow(string title)
+        {
+            return Resources.FindObjectsOfTypeAll<EditorWindow>().FirstOrDefault(w => w.titleContent.text == title);
+        }
+
+        private static VisualElement FindElementByName(VisualElement root, string name)
+        {
+            if (root == null) return null;
+            if (root.name == name) return root;
+            return root.Q(name);
+        }
+
+        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,
+                ["type"] = el.GetType().Name,
+                ["visible"] = el.resolvedStyle.display != DisplayStyle.None
+            };
+
+            if (el is TextElement te && !string.IsNullOrEmpty(te.text))
+                obj["text"] = te.text;
+
+            var classes = el.GetClasses().ToList();
+            if (classes.Count > 0)
+                obj["classes"] = new JArray(classes);
+
+            if (deep)
+            {
+                var rect = el.layout;
+                obj["layout"] = new JObject { ["x"] = rect.x, ["y"] = rect.y, ["width"] = rect.width, ["height"] = rect.height };
+
+                var style = new JObject();
+                style["display"] = el.resolvedStyle.display.ToString();
+                style["visibility"] = el.resolvedStyle.visibility.ToString();
+                style["opacity"] = el.resolvedStyle.opacity;
+                style["color"] = el.resolvedStyle.color.ToString();
+                style["backgroundColor"] = el.resolvedStyle.backgroundColor.ToString();
+                obj["computed_style"] = style;
+            }
+
+            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.SerializationUtils.cs.meta b/Editor/MCPServerMethods.SerializationUtils.cs.meta
new file mode 100644
index 0000000..14ccd3f
--- /dev/null
+++ b/Editor/MCPServerMethods.SerializationUtils.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/Editor/MCPServerMethods.Snapshot.cs b/Editor/MCPServerMethods.Snapshot.cs
index 5cc5968..14d471c 100644
--- a/Editor/MCPServerMethods.Snapshot.cs
+++ b/Editor/MCPServerMethods.Snapshot.cs
@@ -54,11 +54,11 @@ private static JToken DumpSceneGraph(JToken p)
                 }
             }
 
-            return new JObject 
-            { 
+            return new JObject
+            {
                 ["status"] = "Success",
                 ["scene_name"] = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name,
-                ["hierarchy"] = roots 
+                ["hierarchy"] = roots
             };
         }
 
@@ -72,33 +72,14 @@ internal static JObject SerializeSceneNode(GameObject go, int currentDepth, int
 
             if (compact)
             {
-                JArray components = new JArray();
-                using (UnityEngine.Pool.ListPool<Component>.Get(out var comps))
-                {
-                    go.GetComponents(comps);
-                    foreach (var comp in comps)
-                    {
-                        if (comp != null) components.Add(GetTypeName(comp.GetType()));
-                    }
-                }
-                node["components"] = components;
+                node["components"] = SerializeComponentNames(go);
             }
             else
             {
                 node["active"] = go.activeSelf;
                 node["tag"] = go.tag;
                 node["layer"] = LayerMask.LayerToName(go.layer);
-
-                JArray componentNodes = new JArray();
-                using (UnityEngine.Pool.ListPool<Component>.Get(out var comps))
-                {
-                    go.GetComponents(comps);
-                    foreach (var comp in comps)
-                    {
-                        if (comp != null) componentNodes.Add(SerializeComponentSnapshot(comp, includeAllProperties));
-                    }
-                }
-                node["components"] = componentNodes;
+                node["components"] = SerializeComponentSnapshots(go, includeAllProperties);
             }
 
             if (currentDepth < maxDepth)
@@ -114,6 +95,34 @@ internal static JObject SerializeSceneNode(GameObject go, int currentDepth, int
             return node;
         }
 
+        private static JArray SerializeComponentNames(GameObject go)
+        {
+            JArray components = new JArray();
+            using (UnityEngine.Pool.ListPool<Component>.Get(out var comps))
+            {
+                go.GetComponents(comps);
+                foreach (var comp in comps)
+                {
+                    if (comp != null) components.Add(GetTypeName(comp.GetType()));
+                }
+            }
+            return components;
+        }
+
+        private static JArray SerializeComponentSnapshots(GameObject go, bool includeAllProperties)
+        {
+            JArray componentNodes = new JArray();
+            using (UnityEngine.Pool.ListPool<Component>.Get(out var comps))
+            {
+                go.GetComponents(comps);
+                foreach (var comp in comps)
+                {
+                    if (comp != null) componentNodes.Add(SerializeComponentSnapshot(comp, includeAllProperties));
+                }
+            }
+            return componentNodes;
+        }
+
         private static JObject SerializeComponentSnapshot(Component comp, bool includeAllProperties)
         {
             var type = comp.GetType();
@@ -197,52 +206,65 @@ private static JToken GetSceneDependencies(JToken p)
                     go.GetComponents(components);
                     foreach (var comp in components)
                     {
-                        if (comp == null) 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)
-                                {
-                                    var target = prop.objectReferenceValue;
-                                    if (target != null && target is GameObject targetGO && targetGO.scene == activeScene)
-                                    {
-                                        var dep = new JObject();
-                                        dep["from_go"] = go.name;
-                                        dep["from_id"] = go.GetRawId();
-                                        dep["component"] = GetTypeName(comp.GetType());
-                                        dep["field"] = prop.name;
-                                        dep["to_go"] = targetGO.name;
-                                        dep["to_id"] = targetGO.GetRawId();
-                                        sceneRefs.Add(dep);
-                                    }
-                                    else if (target != null && target is Component targetComp && targetComp.gameObject.scene == activeScene)
-                                    {
-                                        var dep = new JObject();
-                                        dep["from_go"] = go.name;
-                                        dep["from_id"] = go.GetRawId();
-                                        dep["component"] = GetTypeName(comp.GetType());
-                                        dep["field"] = prop.name;
-                                        dep["to_go"] = targetComp.gameObject.name;
-                                        dep["to_comp"] = GetTypeName(targetComp.GetType());
-                                        dep["to_id"] = targetComp.gameObject.GetRawId();
-                                        sceneRefs.Add(dep);
-                                    }
-                                }
-                            }
-                        }
+                        if (comp != null) CollectComponentReferences(go, comp, activeScene, sceneRefs);
                     }
                 }
             }
 
-            return new JObject 
-            { 
+            return new JObject
+            {
                 ["status"] = "Success",
-                ["dependencies"] = sceneRefs 
+                ["dependencies"] = sceneRefs
+            };
+        }
+
+        // Walks a component's serialized object-reference fields and records any
+        // that point at another object in the active scene.
+        private static void CollectComponentReferences(GameObject go, Component comp, UnityEngine.SceneManagement.Scene activeScene, JArray sceneRefs)
+        {
+            using var so = new SerializedObject(comp);
+            var prop = so.GetIterator();
+            bool enterChildren = true;
+            while (prop.Next(enterChildren))
+            {
+                enterChildren = false;
+                if (prop.propertyType != SerializedPropertyType.ObjectReference) continue;
+
+                JObject dep = BuildSceneReference(go, comp, prop.name, prop.objectReferenceValue, activeScene);
+                if (dep != null) sceneRefs.Add(dep);
+            }
+        }
+
+        private static JObject BuildSceneReference(GameObject go, Component comp, string field, UnityEngine.Object target, UnityEngine.SceneManagement.Scene activeScene)
+        {
+            if (target is GameObject targetGO && targetGO.scene == activeScene)
+            {
+                JObject dep = MakeReferenceHeader(go, comp, field);
+                dep["to_go"] = targetGO.name;
+                dep["to_id"] = targetGO.GetRawId();
+                return dep;
+            }
+
+            if (target is Component targetComp && targetComp.gameObject.scene == activeScene)
+            {
+                JObject dep = MakeReferenceHeader(go, comp, field);
+                dep["to_go"] = targetComp.gameObject.name;
+                dep["to_comp"] = GetTypeName(targetComp.GetType());
+                dep["to_id"] = targetComp.gameObject.GetRawId();
+                return dep;
+            }
+
+            return null;
+        }
+
+        private static JObject MakeReferenceHeader(GameObject go, Component comp, string field)
+        {
+            return new JObject
+            {
+                ["from_go"] = go.name,
+                ["from_id"] = go.GetRawId(),
+                ["component"] = GetTypeName(comp.GetType()),
+                ["field"] = field
             };
         }
     }
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.ToolUsage.cs b/Editor/MCPServerMethods.ToolUsage.cs
index 0ef99ea..d7a820d 100644
--- a/Editor/MCPServerMethods.ToolUsage.cs
+++ b/Editor/MCPServerMethods.ToolUsage.cs
@@ -11,6 +11,109 @@ public static partial class MCPServerMethods
         private static readonly Dictionary<string, ToolUsageStat> _toolUsageStats = new Dictionary<string, ToolUsageStat>();
         private static DateTime _toolUsageStartedUtc = DateTime.UtcNow;
 
+        private static readonly System.Text.RegularExpressions.Regex _windowsPathRegex =
+            new System.Text.RegularExpressions.Regex(@"(?:[a-zA-Z]:[\\/]|\\\\[a-zA-Z0-9_.\-]+[\\/])[^\s""'<>]+", System.Text.RegularExpressions.RegexOptions.Compiled);
+
+        private static readonly System.Text.RegularExpressions.Regex _unixPathRegex =
+            new System.Text.RegularExpressions.Regex(@"/(?:Users|home|root|var|tmp|etc|private|Applications|Volumes|usr|opt|mnt|media|srv)/[^\s""'<>]+", System.Text.RegularExpressions.RegexOptions.Compiled);
+
+        private static readonly string _cachedUserProfile = GetUserProfilePath();
+        private static string _cachedDataPath;
+        private static string _cachedProjectPath;
+
+        private static string GetUserProfilePath()
+        {
+            try
+            {
+                string path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+                return string.IsNullOrEmpty(path) || path.Length <= 1 ? null : path;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        internal static void CacheEnvironmentPaths()
+        {
+            try
+            {
+                string dataPath = UnityEngine.Application.dataPath;
+                if (!string.IsNullOrEmpty(dataPath))
+                {
+                    _cachedDataPath = dataPath;
+                    _cachedProjectPath = System.IO.Directory.GetParent(dataPath)?.FullName;
+                }
+            }
+            catch
+            {
+                // Ignore when executed outside Unity runtime/main-thread
+            }
+        }
+
+        private static string GetDataPath()
+        {
+            if (!string.IsNullOrEmpty(_cachedDataPath)) return _cachedDataPath;
+            if (_isMainThread)
+            {
+                CacheEnvironmentPaths();
+                if (!string.IsNullOrEmpty(_cachedDataPath)) return _cachedDataPath;
+            }
+            return null;
+        }
+
+        private static string GetProjectPath()
+        {
+            if (!string.IsNullOrEmpty(_cachedProjectPath)) return _cachedProjectPath;
+            if (_isMainThread)
+            {
+                CacheEnvironmentPaths();
+                if (!string.IsNullOrEmpty(_cachedProjectPath)) return _cachedProjectPath;
+            }
+            try
+            {
+                return System.IO.Directory.GetCurrentDirectory();
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Exception UnwrapException(Exception ex)
+        {
+            Exception current = ex;
+            while (current != null)
+            {
+                if (current is System.Reflection.TargetInvocationException tie && tie.InnerException != null)
+                {
+                    current = tie.InnerException;
+                }
+                else if (current is AggregateException ae && ae.InnerExceptions.Count == 1)
+                {
+                    current = ae.InnerExceptions[0];
+                }
+                else
+                {
+                    break;
+                }
+            }
+            return current;
+        }
+
+        private static string ReplacePathVariations(string text, string pathToRedact, string replacement)
+        {
+            if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(pathToRedact)) return text;
+            text = text.Replace(pathToRedact, replacement);
+            string slashNormalized = pathToRedact.Replace('\\', '/');
+            if (slashNormalized != pathToRedact)
+                text = text.Replace(slashNormalized, replacement);
+            string backslashNormalized = pathToRedact.Replace('/', '\\');
+            if (backslashNormalized != pathToRedact)
+                text = text.Replace(backslashNormalized, replacement);
+            return text;
+        }
+
         private sealed class ToolUsageStat
         {
             public int Count;
@@ -20,13 +123,79 @@ private sealed class ToolUsageStat
             public DateTime LastCallUtc;
             public DateTime? LastSuccessUtc;
             public DateTime? LastErrorUtc;
+            public string LastErrorType;
             public string LastError;
         }
 
+        /// <summary>
+        /// Sanitizes raw exception messages before storing them in in-memory tool usage metrics.
+        /// </summary>
+        /// <param name="failure">The caught exception, or null.</param>
+        /// <param name="errorType">Outputs the unwrapped exception type name.</param>
+        /// <returns>A sanitized single-line summary with sensitive paths redacted.</returns>
+        internal static string SanitizeErrorMessage(Exception failure, out string errorType)
+        {
+            if (failure == null)
+            {
+                errorType = null;
+                return null;
+            }
+
+            Exception actual = UnwrapException(failure) ?? failure;
+            errorType = actual.GetType().Name;
+            string raw = actual.Message ?? string.Empty;
+
+            int newlineIdx = raw.IndexOfAny(new[] { '\r', '\n' });
+            string firstLine = newlineIdx >= 0 ? raw.Substring(0, newlineIdx) : raw;
+            firstLine = firstLine.Trim();
+
+            if (string.IsNullOrEmpty(firstLine))
+            {
+                return errorType;
+            }
+
+            string projectPath = GetProjectPath();
+            if (!string.IsNullOrEmpty(projectPath) && projectPath.Length > 1)
+            {
+                firstLine = ReplacePathVariations(firstLine, projectPath, "[project]");
+            }
+
+            string dataPath = GetDataPath();
+            if (!string.IsNullOrEmpty(dataPath) && dataPath.Length > 1)
+            {
+                firstLine = ReplacePathVariations(firstLine, dataPath, "[project]/Assets");
+            }
+
+            if (!string.IsNullOrEmpty(_cachedUserProfile))
+            {
+                firstLine = ReplacePathVariations(firstLine, _cachedUserProfile, "[user]");
+            }
+
+            firstLine = _windowsPathRegex.Replace(firstLine, "[path]");
+            firstLine = _unixPathRegex.Replace(firstLine, "[path]");
+
+            const int maxLen = 160;
+            if (firstLine.Length > maxLen)
+            {
+                firstLine = firstLine.Substring(0, maxLen - 3) + "...";
+            }
+
+            return firstLine;
+        }
+
         private static void RecordToolUsage(string method, double durationMs, Exception failure)
         {
             if (string.IsNullOrEmpty(method)) return;
 
+            string sanitizedError = null;
+            string errorType = null;
+            if (failure != null)
+            {
+                sanitizedError = SanitizeErrorMessage(failure, out errorType);
+            }
+
+            DateTime now = DateTime.UtcNow;
+
             lock (_toolUsageLock)
             {
                 if (!_toolUsageStats.TryGetValue(method, out ToolUsageStat stat))
@@ -35,7 +204,6 @@ private static void RecordToolUsage(string method, double durationMs, Exception
                     _toolUsageStats[method] = stat;
                 }
 
-                DateTime now = DateTime.UtcNow;
                 stat.Count++;
                 stat.TotalDurationMs += durationMs;
                 stat.LastDurationMs = durationMs;
@@ -49,7 +217,8 @@ private static void RecordToolUsage(string method, double durationMs, Exception
 
                 stat.ErrorCount++;
                 stat.LastErrorUtc = now;
-                stat.LastError = failure.Message;
+                stat.LastError = sanitizedError;
+                stat.LastErrorType = errorType;
             }
         }
 
@@ -77,6 +246,8 @@ private static JToken GetToolUsageStats(JToken p)
                         item["last_success_utc"] = stat.LastSuccessUtc.Value.ToString("o");
                     if (stat.LastErrorUtc.HasValue)
                         item["last_error_utc"] = stat.LastErrorUtc.Value.ToString("o");
+                    if (!string.IsNullOrEmpty(stat.LastErrorType))
+                        item["last_error_type"] = stat.LastErrorType;
                     if (!string.IsNullOrEmpty(stat.LastError))
                         item["last_error"] = stat.LastError;
 
diff --git a/Editor/MCPServerMethods.Tools.cs b/Editor/MCPServerMethods.Tools.cs
index 6d84cf3..964af76 100644
--- a/Editor/MCPServerMethods.Tools.cs
+++ b/Editor/MCPServerMethods.Tools.cs
@@ -264,7 +264,7 @@ private static void AddAssetTools(JArray tools)
             tools.Add(CreateTool("get_prefab_overrides", "Get list of property and component modifications on a prefab instance", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
             tools.Add(CreateTool("edit_prefab_asset", "Directly modify a prefab asset on disk without instantiating it", new JObject { ["path"] = new JObject { ["type"] = "string" }, ["component_name"] = new JObject { ["type"] = "string", ["description"] = "Optional component name to target" }, ["properties"] = new JObject { ["type"] = "object" } }, "path", "properties"));
             tools.Add(CreateTool("move_asset", "Move/Rename", new JObject { ["old_path"] = new JObject { ["type"] = "string" }, ["new_path"] = new JObject { ["type"] = "string" } }, "old_path", "new_path"));
-            tools.Add(CreateTool("delete_asset", "Delete file", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
+            tools.Add(CreateTool("delete_asset", "Delete file or folder (moves to OS trash)", new JObject { ["path"] = new JObject { ["type"] = "string" }, ["confirm"] = new JObject { ["type"] = "boolean", ["description"] = "Required: must be true to confirm asset deletion" } }, "path", "confirm"));
             tools.Add(CreateTool("copy_asset", "Duplicate file", new JObject { ["source_path"] = new JObject { ["type"] = "string" }, ["dest_path"] = new JObject { ["type"] = "string" } }, "source_path", "dest_path"));
             tools.Add(CreateTool("get_dependencies", "Get file deps", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
             tools.Add(CreateTool("create_folder", "Create directory", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
@@ -273,96 +273,6 @@ private static void AddAssetTools(JArray tools)
             tools.Add(CreateTool("write_files_batch", "Write multiple files in a single pass", new JObject { ["files"] = new JObject { ["type"] = "array", ["items"] = new JObject { ["type"] = "object", ["properties"] = new JObject { ["path"] = new JObject { ["type"] = "string" }, ["content"] = new JObject { ["type"] = "string" } }, ["required"] = new JArray { "path", "content" } } }, ["confirm"] = new JObject { ["type"] = "boolean", ["description"] = "Required when any file path ends in .cs because Unity compilation is triggered" } }, "files"));
         }
 
-        private static void AddEditorControlTools(JArray tools)
-        {
-            tools.Add(CreateTool("undo", "Unity Undo", new JObject { }));
-            tools.Add(CreateTool("redo", "Unity Redo", new JObject { }));
-            tools.Add(CreateTool("toggle_play_mode", "Start/Stop", new JObject { ["value"] = new JObject { ["type"] = "boolean" } }));
-            tools.Add(CreateTool("pause_play_mode", "Pause/Unpause", new JObject { ["value"] = new JObject { ["type"] = "boolean" } }));
-            tools.Add(CreateTool("step_frame", "Advance frame", new JObject { }));
-            tools.Add(CreateTool("execute_menu_item", "Execute Menu", new JObject { ["item_path"] = new JObject { ["type"] = "string" } }, "item_path"));
-            tools.Add(CreateTool("focus_scene_view", "Frame selection", new JObject { }));
-            tools.Add(CreateTool("open_prefab_stage", "Open prefab asset in isolation mode", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
-            tools.Add(CreateTool("close_prefab_stage", "Exit prefab isolation mode", new JObject { }));
-            tools.Add(CreateTool("read_logs", "Get Console logs with optional noise reduction", new JObject
-            {
-                ["count"] = new JObject { ["type"] = "integer", ["description"] = "Number of logs to retrieve" },
-                ["structured"] = new JObject { ["type"] = "boolean", ["description"] = "If true, collapses consecutive identical messages" },
-                ["filter_type"] = new JObject { ["type"] = "string", ["description"] = "Filter by type (Log, Warning, Error)" },
-                ["search_text"] = new JObject { ["type"] = "string", ["description"] = "Search in message or stacktrace" }
-            }));
-            tools.Add(CreateTool("read_logs_since_cursor", "Read only new logs since last poll with optional noise reduction", new JObject
-            {
-                ["cursor"] = new JObject { ["type"] = "integer", ["description"] = "Last seen log ID" },
-                ["structured"] = new JObject { ["type"] = "boolean", ["description"] = "If true, collapses consecutive identical messages" },
-                ["severities"] = new JObject { ["type"] = "array", ["items"] = new JObject { ["type"] = "string" }, ["description"] = "e.g. ['Error', 'Exception']" },
-                ["search_text"] = new JObject { ["type"] = "string", ["description"] = "Filter by content" }
-            }));
-            tools.Add(CreateTool("clear_logs", "Clear Console", new JObject { }));
-            tools.Add(CreateTool("attach_script", "Create & Link C#", new JObject { ["script_name"] = new JObject { ["type"] = "string" }, ["script_content"] = new JObject { ["type"] = "string" }, ["confirm"] = new JObject { ["type"] = "boolean", ["description"] = "Required because this writes a .cs file and triggers Unity compilation" } }, "script_name", "confirm"));
-            tools.Add(CreateTool("wait_for_ready", "Wait until server is responsive", new JObject { }));
-            tools.Add(CreateTool("run_tests", "Run NUnit tests in the editor", new JObject
-            {
-                ["filter"] = new JObject { ["type"] = "string", ["description"] = "Optional: name of test or class" },
-                ["mode"] = new JObject { ["type"] = "string", ["description"] = "EditMode or PlayMode" }
-            }));
-            tools.Add(CreateTool("get_test_results", "Read the latest Unity TestResults XML summary", new JObject
-            {
-                ["result_path"] = new JObject { ["type"] = "string", ["description"] = "Optional TestResults XML path inside the project or Unity persistent data path" }
-            }));
-        }
-
-        private static void AddDiscoveryTools(JArray tools)
-        {
-            tools.Add(CreateTool("get_game_object", "Get object data", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
-            tools.Add(CreateTool("get_active_game_object", "Get current selection", new JObject { }));
-            tools.Add(CreateTool("get_root_game_objects", "Get top-level objects", new JObject { }));
-            tools.Add(CreateTool("get_object_path", "Get hierarchy breadcrumb", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
-            tools.Add(CreateTool("find_objects", "Deep search", GetSearchSchema()));
-            tools.Add(CreateTool("find_by_path", "Search by exact path", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
-            tools.Add(CreateTool("find_references", "Find scene and asset references to a target object or GUID", new JObject
-            {
-                ["target_id"] = new JObject { ["type"] = "integer", ["description"] = "Optional scene instance/entity id" },
-                ["target_guid"] = new JObject { ["type"] = "string", ["description"] = "Optional asset GUID" }
-            }));
-            tools.Add(CreateTool("get_tags_and_layers", "Get Tags/Layers list", new JObject { }));
-            tools.Add(CreateTool("ping_object", "Ping in Editor", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
-            tools.Add(CreateTool("get_children", "Get direct children", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
-            tools.Add(CreateTool("get_editor_state", "Get Play/Paused/Compiling", new JObject { }));
-            tools.Add(CreateTool("get_project_info", "Get Project metadata", new JObject { }));
-            tools.Add(CreateTool("set_selection", "Select objects", new JObject { ["instance_ids"] = new JObject { ["type"] = "array", ["items"] = new JObject { ["type"] = "integer" } } }, "instance_ids"));
-        }
-
-        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_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
-            {
-                ["window_title"] = new JObject { ["type"] = "string" },
-                ["x"] = new JObject { ["type"] = "number" },
-                ["y"] = new JObject { ["type"] = "number" },
-                ["width"] = new JObject { ["type"] = "number" },
-                ["height"] = new JObject { ["type"] = "number" }
-            }, "window_title"));
-            tools.Add(CreateTool("ui_capture_window_snapshot", "Capture an EditorWindow rect, UI hierarchy, and optional PNG image", new JObject
-            {
-                ["window_title"] = new JObject { ["type"] = "string" },
-                ["include_image"] = new JObject { ["type"] = "boolean" },
-                ["include_hierarchy"] = new JObject { ["type"] = "boolean" }
-            }, "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" }
-            }, "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"));
-        }
-
         private static JObject CreateTool(string name, string desc, JObject props, params string[] required)
         {
             var tool = new JObject { ["name"] = name, ["description"] = desc };
@@ -371,79 +281,5 @@ private static JObject CreateTool(string name, string desc, JObject props, param
             tool["inputSchema"] = schema;
             return tool;
         }
-
-        private static JObject GetPrimitiveSchema()
-        {
-            var schema = new JObject();
-            var types = new JArray("Cube", "Sphere", "Capsule", "Cylinder", "Plane", "Quad");
-            schema["primitive_type"] = new JObject { ["type"] = "string", ["enum"] = types };
-            schema["name"] = new JObject { ["type"] = "string" };
-            schema["parent_id"] = new JObject { ["type"] = "integer" };
-            schema["position"] = GetVector3Schema();
-            schema["rotation"] = GetVector3Schema();
-            schema["scale"] = GetVector3Schema();
-            schema["material_path"] = new JObject { ["type"] = "string" };
-            return schema;
-        }
-        private static JObject GetSearchSchema() => new JObject { ["name"] = new JObject { ["type"] = "string" }, ["tag"] = new JObject { ["type"] = "string" }, ["type"] = new JObject { ["type"] = "string" } };
-        private static JObject GetTransformSchema() => new JObject
-        {
-            ["instance_id"] = new JObject { ["type"] = "integer" },
-            ["position"] = GetVector3Schema(),
-            ["rotation"] = GetVector3Schema(),
-            ["scale"] = GetVector3Schema(),
-            ["eulerAngles"] = GetVector3Schema(),
-            ["localScale"] = GetVector3Schema()
-        };
-
-        private static JObject GetVector3Schema() => new JObject
-        {
-            ["oneOf"] = new JArray(
-                new JObject
-                {
-                    ["type"] = "object",
-                    ["properties"] = new JObject
-                    {
-                        ["x"] = new JObject { ["type"] = "number" },
-                        ["y"] = new JObject { ["type"] = "number" },
-                        ["z"] = new JObject { ["type"] = "number" }
-                    }
-                },
-                new JObject
-                {
-                    ["type"] = "array",
-                    ["items"] = new JObject { ["type"] = "number" },
-                    ["minItems"] = 3,
-                    ["maxItems"] = 3
-                })
-        };
-
-        private static string SanitizeScriptName(string n) => System.Text.RegularExpressions.Regex.Replace(n, @"[^a-zA-Z0-9_]", "_");
-        private static string GetDefaultScript(string n) => $"using UnityEngine;\npublic class {n} : MonoBehaviour {{ void Start() {{ Debug.Log(\"Hello from {n}\"); }} }}";
-
-        private static List<LogEntry> CollapseLogs(List<LogEntry> logs)
-        {
-            if (logs == null || logs.Count == 0) return logs;
-
-            var collapsed = new List<LogEntry>();
-            foreach (var log in logs)
-            {
-                int lastIdx = collapsed.Count - 1;
-                if (lastIdx >= 0)
-                {
-                    var last = collapsed[lastIdx];
-                    if (last.Message == log.Message && last.Type == log.Type)
-                    {
-                        last.Count += log.Count;
-                        // Keep the lexicographically later timestamp (most recent within same day)
-                        if (string.Compare(last.Timestamp, log.Timestamp) < 0)
-                            last.Timestamp = log.Timestamp;
-                        continue;
-                    }
-                }
-                collapsed.Add(new LogEntry(log));
-            }
-            return collapsed;
-        }
     }
 }
diff --git a/Editor/MCPServerMethods.ToolsExtended.cs b/Editor/MCPServerMethods.ToolsExtended.cs
new file mode 100644
index 0000000..908a758
--- /dev/null
+++ b/Editor/MCPServerMethods.ToolsExtended.cs
@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static void AddEditorControlTools(JArray tools)
+        {
+            tools.Add(CreateTool("undo", "Unity Undo", new JObject { }));
+            tools.Add(CreateTool("redo", "Unity Redo", new JObject { }));
+            tools.Add(CreateTool("toggle_play_mode", "Start/Stop", new JObject { ["value"] = new JObject { ["type"] = "boolean" } }));
+            tools.Add(CreateTool("pause_play_mode", "Pause/Unpause", new JObject { ["value"] = new JObject { ["type"] = "boolean" } }));
+            tools.Add(CreateTool("step_frame", "Advance frame", new JObject { }));
+            tools.Add(CreateTool("execute_menu_item", "Execute Menu", new JObject { ["item_path"] = new JObject { ["type"] = "string" } }, "item_path"));
+            tools.Add(CreateTool("focus_scene_view", "Frame selection", new JObject { }));
+            tools.Add(CreateTool("open_prefab_stage", "Open prefab asset in isolation mode", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
+            tools.Add(CreateTool("close_prefab_stage", "Exit prefab isolation mode", new JObject { }));
+            tools.Add(CreateTool("read_logs", "Get Console logs with optional noise reduction", new JObject
+            {
+                ["count"] = new JObject { ["type"] = "integer", ["description"] = "Number of logs to retrieve" },
+                ["structured"] = new JObject { ["type"] = "boolean", ["description"] = "If true, collapses consecutive identical messages" },
+                ["filter_type"] = new JObject { ["type"] = "string", ["description"] = "Filter by type (Log, Warning, Error)" },
+                ["search_text"] = new JObject { ["type"] = "string", ["description"] = "Search in message or stacktrace" }
+            }));
+            tools.Add(CreateTool("read_logs_since_cursor", "Read only new logs since last poll with optional noise reduction", new JObject
+            {
+                ["cursor"] = new JObject { ["type"] = "integer", ["description"] = "Last seen log ID" },
+                ["structured"] = new JObject { ["type"] = "boolean", ["description"] = "If true, collapses consecutive identical messages" },
+                ["severities"] = new JObject { ["type"] = "array", ["items"] = new JObject { ["type"] = "string" }, ["description"] = "e.g. ['Error', 'Exception']" },
+                ["search_text"] = new JObject { ["type"] = "string", ["description"] = "Filter by content" }
+            }));
+            tools.Add(CreateTool("clear_logs", "Clear Console", new JObject { }));
+            tools.Add(CreateTool("attach_script", "Create & Link C#", new JObject { ["script_name"] = new JObject { ["type"] = "string" }, ["script_content"] = new JObject { ["type"] = "string" }, ["confirm"] = new JObject { ["type"] = "boolean", ["description"] = "Required because this writes a .cs file and triggers Unity compilation" } }, "script_name", "confirm"));
+            tools.Add(CreateTool("wait_for_ready", "Wait until server is responsive", new JObject { }));
+            tools.Add(CreateTool("run_tests", "Run NUnit tests in the editor", new JObject
+            {
+                ["filter"] = new JObject { ["type"] = "string", ["description"] = "Optional: name of test or class" },
+                ["mode"] = new JObject { ["type"] = "string", ["description"] = "EditMode or PlayMode" }
+            }));
+            tools.Add(CreateTool("get_test_results", "Read the latest Unity TestResults XML summary", new JObject
+            {
+                ["result_path"] = new JObject { ["type"] = "string", ["description"] = "Optional TestResults XML path inside the project or Unity persistent data path" }
+            }));
+        }
+
+        private static void AddDiscoveryTools(JArray tools)
+        {
+            tools.Add(CreateTool("get_game_object", "Get object data", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
+            tools.Add(CreateTool("get_active_game_object", "Get current selection", new JObject { }));
+            tools.Add(CreateTool("get_root_game_objects", "Get top-level objects", new JObject { }));
+            tools.Add(CreateTool("get_object_path", "Get hierarchy breadcrumb", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
+            tools.Add(CreateTool("find_objects", "Deep search", GetSearchSchema()));
+            tools.Add(CreateTool("find_by_path", "Search by exact path", new JObject { ["path"] = new JObject { ["type"] = "string" } }, "path"));
+            tools.Add(CreateTool("find_references", "Find scene and asset references to a target object or GUID", new JObject
+            {
+                ["target_id"] = new JObject { ["type"] = "integer", ["description"] = "Optional scene instance/entity id" },
+                ["target_guid"] = new JObject { ["type"] = "string", ["description"] = "Optional asset GUID" }
+            }));
+            tools.Add(CreateTool("get_tags_and_layers", "Get Tags/Layers list", new JObject { }));
+            tools.Add(CreateTool("ping_object", "Ping in Editor", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
+            tools.Add(CreateTool("get_children", "Get direct children", new JObject { ["instance_id"] = new JObject { ["type"] = "integer" } }, "instance_id"));
+            tools.Add(CreateTool("get_editor_state", "Get Play/Paused/Compiling", new JObject { }));
+            tools.Add(CreateTool("get_project_info", "Get Project metadata", new JObject { }));
+            tools.Add(CreateTool("set_selection", "Select objects", new JObject { ["instance_ids"] = new JObject { ["type"] = "array", ["items"] = new JObject { ["type"] = "integer" } } }, "instance_ids"));
+        }
+
+        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" },
+                ["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
+            {
+                ["window_title"] = new JObject { ["type"] = "string" },
+                ["x"] = new JObject { ["type"] = "number" },
+                ["y"] = new JObject { ["type"] = "number" },
+                ["width"] = new JObject { ["type"] = "number" },
+                ["height"] = new JObject { ["type"] = "number" }
+            }, "window_title"));
+            tools.Add(CreateTool("ui_capture_window_snapshot", "Capture an EditorWindow rect, UI hierarchy, and optional PNG image", new JObject
+            {
+                ["window_title"] = new JObject { ["type"] = "string" },
+                ["include_image"] = 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" },
+                ["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"));
+        }
+
+        private static JObject GetPrimitiveSchema()
+        {
+            var schema = new JObject();
+            var types = new JArray("Cube", "Sphere", "Capsule", "Cylinder", "Plane", "Quad");
+            schema["primitive_type"] = new JObject { ["type"] = "string", ["enum"] = types };
+            schema["name"] = new JObject { ["type"] = "string" };
+            schema["parent_id"] = new JObject { ["type"] = "integer" };
+            schema["position"] = GetVector3Schema();
+            schema["rotation"] = GetVector3Schema();
+            schema["scale"] = GetVector3Schema();
+            schema["material_path"] = new JObject { ["type"] = "string" };
+            return schema;
+        }
+
+        private static JObject GetSearchSchema() => new JObject { ["name"] = new JObject { ["type"] = "string" }, ["tag"] = new JObject { ["type"] = "string" }, ["type"] = new JObject { ["type"] = "string" } };
+
+        private static JObject GetTransformSchema() => new JObject
+        {
+            ["instance_id"] = new JObject { ["type"] = "integer" },
+            ["position"] = GetVector3Schema(),
+            ["rotation"] = GetVector3Schema(),
+            ["scale"] = GetVector3Schema(),
+            ["eulerAngles"] = GetVector3Schema(),
+            ["localScale"] = GetVector3Schema()
+        };
+
+        private static JObject GetVector3Schema() => new JObject
+        {
+            ["oneOf"] = new JArray(
+                new JObject
+                {
+                    ["type"] = "object",
+                    ["properties"] = new JObject
+                    {
+                        ["x"] = new JObject { ["type"] = "number" },
+                        ["y"] = new JObject { ["type"] = "number" },
+                        ["z"] = new JObject { ["type"] = "number" }
+                    }
+                },
+                new JObject
+                {
+                    ["type"] = "array",
+                    ["items"] = new JObject { ["type"] = "number" },
+                    ["minItems"] = 3,
+                    ["maxItems"] = 3
+                })
+        };
+
+        private static string SanitizeScriptName(string n) => System.Text.RegularExpressions.Regex.Replace(n, @"[^a-zA-Z0-9_]", "_");
+        private static string GetDefaultScript(string n) => $"using UnityEngine;\npublic class {n} : MonoBehaviour {{ void Start() {{ Debug.Log(\"Hello from {n}\"); }} }}";
+
+        private static List<LogEntry> CollapseLogs(List<LogEntry> logs)
+        {
+            if (logs == null || logs.Count == 0) return logs;
+
+            var collapsed = new List<LogEntry>();
+            foreach (var log in logs)
+            {
+                int lastIdx = collapsed.Count - 1;
+                if (lastIdx >= 0)
+                {
+                    var last = collapsed[lastIdx];
+                    if (last.Message == log.Message && last.Type == log.Type)
+                    {
+                        last.Count += log.Count;
+                        if (string.Compare(last.Timestamp, log.Timestamp) < 0)
+                            last.Timestamp = log.Timestamp;
+                        continue;
+                    }
+                }
+                collapsed.Add(new LogEntry(log));
+            }
+            return collapsed;
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.ToolsExtended.cs.meta b/Editor/MCPServerMethods.ToolsExtended.cs.meta
new file mode 100644
index 0000000..35680b7
--- /dev/null
+++ b/Editor/MCPServerMethods.ToolsExtended.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7a6b5c4d3e2f1a0b9c8d7e6f5a4b3c2d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/Editor/MCPServerMethods.TypeResolution.cs b/Editor/MCPServerMethods.TypeResolution.cs
new file mode 100644
index 0000000..d2cb517
--- /dev/null
+++ b/Editor/MCPServerMethods.TypeResolution.cs
@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+
+namespace UnityMCP.Editor
+{
+    public static partial class MCPServerMethods
+    {
+        private static readonly HashSet<string> DisallowedAssemblyPrefixes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "System",
+            "Microsoft",
+            "Mono",
+            "Newtonsoft",
+            "nunit",
+            "UnityEditorInternal",
+            "UnityEngine.Internal",
+            "UnityEditor.TestRunner",
+            "Unity.PerformanceTesting",
+            "mscorlib"
+        };
+
+        private static readonly HashSet<string> DisallowedNamespacePrefixes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "System",
+            "Microsoft",
+            "Mono",
+            "Newtonsoft",
+            "UnityEditorInternal",
+            "UnityEngine.Internal"
+        };
+
+        internal static bool IsAllowedAssembly(Assembly asm)
+        {
+            if (asm == null) return false;
+            string asmName = asm.GetName().Name;
+            if (string.IsNullOrEmpty(asmName)) return false;
+
+            foreach (var prefix in DisallowedAssemblyPrefixes)
+            {
+                if (asmName.Equals(prefix, StringComparison.OrdinalIgnoreCase) ||
+                    asmName.StartsWith(prefix + ".", StringComparison.OrdinalIgnoreCase))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        internal static bool IsAllowedNamespace(string ns)
+        {
+            if (string.IsNullOrEmpty(ns)) return true;
+
+            foreach (var prefix in DisallowedNamespacePrefixes)
+            {
+                if (ns.Equals(prefix, StringComparison.OrdinalIgnoreCase) ||
+                    ns.StartsWith(prefix + ".", StringComparison.OrdinalIgnoreCase))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        internal static bool IsAllowedType(Type type)
+        {
+            if (type == null) return false;
+            if (!IsAllowedAssembly(type.Assembly)) return false;
+            if (!IsAllowedNamespace(type.Namespace)) return false;
+            if (type.IsPointer || type.IsByRef) return false;
+            return true;
+        }
+
+        internal static Type FindType(string name)
+        {
+            if (string.IsNullOrEmpty(name)) return null;
+            if (_typeCache.TryGetValue(name, out var cachedType)) return cachedType;
+
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(IsAllowedAssembly).ToList();
+            Type resultType = FindTypeInPriorityAssemblies(assemblies, name);
+
+            if (resultType != null && IsAllowedType(resultType))
+            {
+                _typeCache[name] = resultType;
+                return resultType;
+            }
+
+            return null;
+        }
+
+        private static Type FindTypeInPriorityAssemblies(List<Assembly> assemblies, string name)
+        {
+            Type result = FindTypeInNamedAssembly(assemblies, "Assembly-CSharp", name);
+            if (result != null) return result;
+
+            var coreAssembly = typeof(Component).Assembly;
+            if (IsAllowedAssembly(coreAssembly))
+            {
+                result = GetTypeFromAssembly(coreAssembly, name);
+                if (result != null) return result;
+            }
+
+            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)
+            {
+                var result = GetTypeFromAssembly(assembly, name);
+                if (result != null) return result;
+            }
+            return null;
+        }
+
+        private static Type GetTypeFromAssembly(Assembly asm, string name)
+        {
+            try
+            {
+                var t = asm.GetType(name);
+                if (t != null && IsAllowedType(t)) return t;
+
+                Type[] types;
+                try
+                {
+                    types = asm.GetTypes();
+                }
+                catch (ReflectionTypeLoadException ex)
+                {
+                    types = ex.Types != null ? ex.Types.Where(x => x != null).ToArray() : Array.Empty<Type>();
+                }
+
+                return types.FirstOrDefault(x => x != null && IsAllowedType(x) && (x.Name == name || x.FullName == name));
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        internal static Type FindComponentType(string name)
+        {
+            if (string.IsNullOrEmpty(name)) return null;
+
+            Type type = FindType(name);
+            if (type == null) return null;
+
+            if (!typeof(Component).IsAssignableFrom(type)) return null;
+            if (type.IsAbstract || type.IsInterface) return null;
+
+            return type;
+        }
+
+        internal static Type FindScriptableObjectType(string name)
+        {
+            if (string.IsNullOrEmpty(name)) return null;
+
+            Type type = FindType(name);
+            if (type == null) return null;
+
+            if (!typeof(ScriptableObject).IsAssignableFrom(type)) return null;
+            if (type.IsAbstract || type.IsInterface) return null;
+
+            return type;
+        }
+    }
+}
diff --git a/Editor/MCPServerMethods.TypeResolution.cs.meta b/Editor/MCPServerMethods.TypeResolution.cs.meta
new file mode 100644
index 0000000..83e49ac
--- /dev/null
+++ b/Editor/MCPServerMethods.TypeResolution.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7a8f9c1d2e3b4a5f6071829304152637
diff --git a/Editor/MCPServerMethods.UI.cs b/Editor/MCPServerMethods.UI.cs
index 9b7dca4..dd13423 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;
+            if (el == null || ctx.ShouldStop(currentDepth)) return;
 
-            bool matches = true;
+            ctx.VisitedCount++;
 
-            if (!string.IsNullOrEmpty(nameMatch) && el.name != nameMatch)
-                matches = false;
-
-            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)
+                int childCount = el.childCount;
+                for (int i = 0; i < childCount; i++)
                 {
-                    if (string.IsNullOrEmpty(te.text) || !te.text.Contains(textMatch, StringComparison.OrdinalIgnoreCase))
-                        matches = false;
-                }
-                else
-                {
-                    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)
                 {
-                    jobj.Remove("children"); // Remove deep children for the query result, we just want the matched node
+                    if (string.IsNullOrEmpty(te.text) || !te.text.Contains(ctx.TextMatch, StringComparison.OrdinalIgnoreCase))
+                        return false;
+                }
+                else
+                {
+                    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)
@@ -178,7 +217,7 @@ private static JToken UIInputText(JToken p)
             if (w == null) throw new Exception($"Window not found: {p["window_title"]}");
             var el = FindElementByName(w.rootVisualElement, p["element_name"].ToString());
             if (el == null) throw new Exception($"Element not found: {p["element_name"]}");
-            
+
             if (el is TextField tf) tf.value = p["text"].ToString();
             else if (el is Label lbl) lbl.text = p["text"].ToString();
             else throw new Exception($"Element '{p["element_name"]}' is not a TextField or Label (it is a {el.GetType().Name})");
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 41b0010..156b983 100644
--- a/Editor/MCPServerMethods.Utils.cs
+++ b/Editor/MCPServerMethods.Utils.cs
@@ -4,6 +4,11 @@
 using UnityEngine;
 using UnityEngine.UIElements;
 using Newtonsoft.Json.Linq;
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using Microsoft.Win32.SafeHandles;
 
 [assembly: InternalsVisibleTo("UnityMCP.Editor.Tests")]
 namespace UnityMCP.Editor
@@ -17,6 +22,156 @@ namespace UnityMCP.Editor
     /// </remarks>
     public static partial class MCPServerMethods
     {
+        [DllImport("libc", EntryPoint = "realpath", SetLastError = true, CharSet = CharSet.Ansi)]
+        private static extern IntPtr sys_realpath(string path, IntPtr resolved_path);
+
+        [DllImport("libc", EntryPoint = "free")]
+        private static extern void sys_free(IntPtr ptr);
+
+        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Unicode)]
+        private delegate IntPtr CreateFileDelegate(
+            string lpFileName,
+            uint dwDesiredAccess,
+            uint dwShareMode,
+            IntPtr lpSecurityAttributes,
+            uint dwCreationDisposition,
+            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,
+            [Out] StringBuilder lpszFilePath,
+            uint cchFilePath,
+            uint dwFlags);
+
+        private const uint FILE_SHARE_READ = 0x00000001;
+        private const uint FILE_SHARE_WRITE = 0x00000002;
+        private const uint FILE_SHARE_DELETE = 0x00000004;
+        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)
+        {
+            IntPtr resolved = sys_realpath(path, IntPtr.Zero);
+            if (resolved == IntPtr.Zero)
+            {
+                return path;
+            }
+            try
+            {
+                return Marshal.PtrToStringAnsi(resolved);
+            }
+            finally
+            {
+                sys_free(resolved);
+            }
+        }
+
+        private static string ResolveWindowsPath(string path)
+        {
+            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);
+            using (var hFile = new SafeFileHandle(rawHandle, true))
+            {
+                if (hFile.IsInvalid)
+                {
+                    return path;
+                }
+
+                StringBuilder sb = new StringBuilder(4096);
+                uint result = GetFinalPathNameByHandle(hFile, sb, (uint)sb.Capacity, VOLUME_NAME_DOS);
+                if (result == 0)
+                {
+                    return path;
+                }
+
+                string resolved = sb.ToString();
+                if (resolved.StartsWith(@"\\?\UNC\", StringComparison.OrdinalIgnoreCase))
+                {
+                    resolved = @"\\" + resolved.Substring(8);
+                }
+                else if (resolved.StartsWith(@"\\?\", StringComparison.OrdinalIgnoreCase))
+                {
+                    resolved = resolved.Substring(4);
+                }
+                return resolved;
+            }
+        }
+
+        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))
+            {
+                return ResolveWindowsPath(path);
+            }
+            else
+            {
+                return ResolveUnixPath(path);
+            }
+        }
+
+        private static string ResolveRealPath(string path)
+        {
+            string absolutePath = Path.GetFullPath(path).Replace('\\', '/');
+            string current = absolutePath;
+            string remainder = "";
+
+            while (!string.IsNullOrEmpty(current) && !File.Exists(current) && !Directory.Exists(current))
+            {
+                string parent = Path.GetDirectoryName(current);
+                if (string.IsNullOrEmpty(parent) || parent == current)
+                {
+                    break;
+                }
+
+                string name = Path.GetFileName(current);
+                if (!string.IsNullOrEmpty(name))
+                {
+                    remainder = string.IsNullOrEmpty(remainder) ? name : name + "/" + remainder;
+                }
+                current = parent.Replace('\\', '/');
+            }
+
+            string resolvedCurrent = current;
+            if (File.Exists(current) || Directory.Exists(current))
+            {
+                resolvedCurrent = ResolveRealPathInternal(current);
+            }
+
+            string result = string.IsNullOrEmpty(remainder) ? resolvedCurrent : Path.Combine(resolvedCurrent, remainder);
+            return Path.GetFullPath(result).Replace('\\', '/');
+        }
+
         /// <summary>
         /// Validates that the path is within the project directory to prevent path traversal.
         /// Returns the absolute path if valid.
@@ -37,18 +192,21 @@ internal static string ValidatePath(string path)
                 cleanPath = System.IO.Path.Combine(projectRoot, cleanPath).Replace('\\', '/');
             }
 
-            // Resolve full path (handles .. and symlinks)
-            string fullPath = System.IO.Path.GetFullPath(cleanPath).Replace('\\', '/');
+            // Resolve real target path (resolving symbolic links and junctions)
+            string resolvedPath = ResolveRealPath(cleanPath);
+
+            // Get project root with resolved symlinks as well to allow matching when project itself is in symlinked dir
+            string resolvedProjectRoot = ResolveRealPath(projectRoot);
 
             // Check if path is within project root
-            string projectRootSlash = projectRoot.EndsWith("/") ? projectRoot : projectRoot + "/";
-            if (!fullPath.Equals(projectRoot, System.StringComparison.OrdinalIgnoreCase) &&
-                !fullPath.StartsWith(projectRootSlash, System.StringComparison.OrdinalIgnoreCase))
+            string projectRootSlash = resolvedProjectRoot.EndsWith("/") ? resolvedProjectRoot : resolvedProjectRoot + "/";
+            if (!resolvedPath.Equals(resolvedProjectRoot, System.StringComparison.OrdinalIgnoreCase) &&
+                !resolvedPath.StartsWith(projectRootSlash, System.StringComparison.OrdinalIgnoreCase))
             {
                 throw new System.Exception("Access denied: Path is outside project directory.");
             }
 
-            return fullPath;
+            return resolvedPath;
         }
 
         /// <summary>
@@ -88,76 +246,50 @@ internal static string ValidateAssetPath(string path)
             return relativePath;
         }
 
-        private static bool IsCSharpScriptPath(string path)
+        /// <summary>
+        /// Validates that an asset path is safe for write/modification operations.
+        /// Restricts targets to the 'Assets' folder (or optionally 'Assets' root directory itself).
+        /// Rejects any attempt to modify system folders (Packages, ProjectSettings).
+        /// Returns the relative, normalized asset path.
+        /// </summary>
+        internal static string ValidateWritableAssetPath(string path, bool allowAssetsRoot = false)
         {
-            return path.EndsWith(".cs", System.StringComparison.OrdinalIgnoreCase);
-        }
+            string relativePath = ValidateAssetPath(path);
+            string clean = relativePath.TrimEnd('/', '\\');
 
-        private static void RequireScriptWriteConfirmation(JToken p)
-        {
-            if (p?["confirm"]?.Value<bool>() != true)
+            if (clean.Equals("Packages", StringComparison.OrdinalIgnoreCase) ||
+                clean.Equals("ProjectSettings", StringComparison.OrdinalIgnoreCase) ||
+                clean.StartsWith("Packages/", StringComparison.OrdinalIgnoreCase) ||
+                clean.StartsWith("ProjectSettings/", StringComparison.OrdinalIgnoreCase))
             {
-                throw new System.ArgumentException("Writing C# scripts requires confirm: true because it triggers Unity compilation.");
+                throw new System.Exception($"Modifying root or system folders (Packages, ProjectSettings) is forbidden. Path: '{path}'");
             }
-        }
 
-        internal static JObject SerializeVector3(Vector3 v)
-        {
-            return new JObject { ["x"] = v.x, ["y"] = v.y, ["z"] = v.z };
-        }
+            if (clean.Equals("Assets", StringComparison.OrdinalIgnoreCase))
+            {
+                if (allowAssetsRoot) return relativePath;
+                throw new System.Exception("Cannot delete or overwrite the root 'Assets' folder directly.");
+            }
 
-        internal static string SerializeColor(Color c)
-        {
-            return "#" + ColorUtility.ToHtmlStringRGBA(c);
-        }
+            if (!clean.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
+            {
+                throw new System.Exception($"Modifying assets outside 'Assets/' is forbidden. Path: '{path}'");
+            }
 
-        private static EditorWindow FindWindow(string title)
-        {
-            return Resources.FindObjectsOfTypeAll<EditorWindow>().FirstOrDefault(w => w.titleContent.text == title);
+            return relativePath;
         }
 
-        private static VisualElement FindElementByName(VisualElement root, string name)
+        private static bool IsCSharpScriptPath(string path)
         {
-            if (root == null) return null;
-            if (root.name == name) return root;
-            return root.Q(name);
+            return path.EndsWith(".cs", System.StringComparison.OrdinalIgnoreCase);
         }
 
-        private static JToken SerializeVisualElement(VisualElement el, bool deep = false)
+        private static void RequireScriptWriteConfirmation(JToken p)
         {
-            var obj = new JObject
-            {
-                ["name"] = el.name,
-                ["type"] = el.GetType().Name,
-                ["visible"] = el.resolvedStyle.display != DisplayStyle.None
-            };
-
-            if (el is TextElement te && !string.IsNullOrEmpty(te.text))
-                obj["text"] = te.text;
-
-            var classes = el.GetClasses().ToList();
-            if (classes.Count > 0)
-                obj["classes"] = new JArray(classes);
-
-            if (deep)
-            {
-                var rect = el.layout;
-                obj["layout"] = new JObject { ["x"] = rect.x, ["y"] = rect.y, ["width"] = rect.width, ["height"] = rect.height };
-                
-                // Add useful computed styles
-                var style = new JObject();
-                style["display"] = el.resolvedStyle.display.ToString();
-                style["visibility"] = el.resolvedStyle.visibility.ToString();
-                style["opacity"] = el.resolvedStyle.opacity;
-                style["color"] = el.resolvedStyle.color.ToString();
-                style["backgroundColor"] = el.resolvedStyle.backgroundColor.ToString();
-                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;
+            if (p?["confirm"]?.Value<bool>() != true)
+            {
+                throw new System.ArgumentException("Writing C# scripts requires confirm: true because it triggers Unity compilation.");
+            }
         }
     }
 }
diff --git a/Editor/MCPServerMethods.cs b/Editor/MCPServerMethods.cs
index 8c1fb50..df50902 100644
--- a/Editor/MCPServerMethods.cs
+++ b/Editor/MCPServerMethods.cs
@@ -28,12 +28,12 @@ public static partial class MCPServerMethods
 
         internal static void Init()
         {
-            if (_mainThreadId == -1) 
+            if (_mainThreadId == -1)
             {
                 _mainThreadId = Thread.CurrentThread.ManagedThreadId;
                 NexusEditorLog.Log(NexusLogCategory.Api, $"[MCP] Main Thread ID captured: {_mainThreadId}");
             }
-            
+
             if (!_isMainThread)
             {
                 NexusEditorLog.Warning(NexusLogCategory.Api, "[MCP] MCPServerMethods.Init called from non-main thread. Registration skipped to avoid state corruption.");
@@ -41,6 +41,7 @@ internal static void Init()
             }
 
             MCPServer.RefreshMainThreadCachedState();
+            CacheEnvironmentPaths();
             NexusEditorLog.Log(NexusLogCategory.Api, "[MCP] MCPServerMethods.Init starting...");
             _methods.Clear();
             ClearCache();
@@ -113,7 +114,7 @@ private static string ProcessJsonRequest(JObject request)
             JToken id = request["id"];
             string method = request["method"]?.ToString();
             if (method == null) return CreateErrorResponse(id, -32600, "Method missing");
-            
+
             // Fast-path health checks run on the listener/current thread.
             // Handlers here must only read cached or thread-safe process state.
             if (method == "get_server_status" || method == "attach_existing_session" || method == "wait_for_asset_import_idle" || method == "wait_for_editor_idle") {
@@ -154,8 +155,8 @@ private static string ExecuteOnMainThread(string method, JToken requestParams, J
             using (var signal = new ManualResetEventSlim(false))
             {
                 MCPServer.Enqueue(() => {
-                    try { 
-                        result = ExecuteMethod(method, requestParams); 
+                    try {
+                        result = ExecuteMethod(method, requestParams);
                     }
                     catch (Exception e) { caughtException = e; }
                     finally { signal.Set(); }
diff --git a/Editor/MCPServerWindow.Integrations.cs b/Editor/MCPServerWindow.Integrations.cs
index 4838141..5d1fbb3 100644
--- a/Editor/MCPServerWindow.Integrations.cs
+++ b/Editor/MCPServerWindow.Integrations.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using UnityEditor;
@@ -42,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,
@@ -89,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)
@@ -107,7 +124,13 @@ private void AutoSetupIntegration(NexusMcpClientInfo client)
                 return;
             }
 
-            var refreshed = NexusMcpConfigGenerator.BuildAllForCurrentProject().First(item => item.Kind == client.Kind);
+            var refreshed = FindIntegrationByKind(NexusMcpConfigGenerator.BuildAllForCurrentProject(), client.Kind);
+            if (refreshed == null)
+            {
+                SetIntegrationMessage(client.DisplayName + " is no longer available. Refresh integrations and try again.");
+                return;
+            }
+
             refreshed.BridgePath = bridgePath.Replace("\\", "/");
 
             if (refreshed.CustomAutoSetup != null)
@@ -134,6 +157,11 @@ private void AutoSetupIntegration(NexusMcpClientInfo client)
             SetIntegrationMessage(message);
         }
 
+        internal static NexusMcpClientInfo FindIntegrationByKind(IEnumerable<NexusMcpClientInfo> clients, NexusMcpClientKind kind)
+        {
+            return clients.FirstOrDefault(item => item.Kind == kind);
+        }
+
         private void CopyIntegrationConfig(NexusMcpClientInfo client)
         {
             EditorGUIUtility.systemCopyBuffer = client.ConfigText;
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/MCPTestWindow.cs b/Editor/MCPTestWindow.cs
index 61ba84f..be33c69 100644
--- a/Editor/MCPTestWindow.cs
+++ b/Editor/MCPTestWindow.cs
@@ -9,7 +9,7 @@ namespace UnityMCP.Editor
     /// </summary>
     /// <remarks>
     /// The window builds a TextField, Button, and Label with stable names. Verification helpers show the window, reset state,
-    /// send UI automation JSON-RPC calls, and assert that UI callbacks update the static test state.
+    /// send UI automation JSON-RPC calls, and assert that UI callbacks update this window's test state.
     /// </remarks>
     public class MCPTestWindow : EditorWindow
     {
@@ -18,15 +18,15 @@ public class MCPTestWindow : EditorWindow
         /// <summary>
         /// Stores the last input value for verification.
         /// </summary>
-        public static string LastInputValue = "";
+        public string LastInputValue { get; private set; } = "";
 
         /// <summary>
         /// Tracks if the test button has been clicked.
         /// </summary>
-        public static bool ButtonClicked = false;
+        public bool ButtonClicked { get; private set; }
 
         /// <summary>
-        /// Resets static test flags and clears the UI Toolkit input/label elements in the current visual tree.
+        /// Resets this window's test state and clears the UI Toolkit input/label elements in the current visual tree.
         /// </summary>
         public void ResetState()
         {
@@ -58,7 +58,7 @@ private void OnEnable()
         /// Creates named UI Toolkit controls and event handlers used by Nexus Unity UI automation smoke tests.
         /// </summary>
         /// <remarks>
-        /// This method mutates <see cref="EditorWindow.rootVisualElement"/>, resets static test state, registers a text-change
+        /// This method mutates <see cref="EditorWindow.rootVisualElement"/>, preserves instance test state, registers a text-change
         /// callback, and wires the button click to update the label and <see cref="ButtonClicked"/>.
         /// </remarks>
         public void CreateGUI()
@@ -66,9 +66,6 @@ public void CreateGUI()
             NexusEditorUi.SetupRoot(rootVisualElement);
             rootVisualElement.name = "NexusTestWindowRoot";
 
-            LastInputValue = "";
-            ButtonClicked = false;
-
             var header = NexusEditorUi.Panel("TestWindowHeader");
             header.Add(NexusEditorUi.Label("UI Automation Test", 16, true));
             header.Add(NexusEditorUi.Label("Named controls used by Nexus Unity UI automation checks.", 11, false, NexusEditorUi.Muted));
@@ -76,7 +73,7 @@ public void CreateGUI()
 
             var panel = NexusEditorUi.Panel("TestWindowControls");
 
-            var label = new Label("Initial State");
+            var label = new Label(ButtonClicked ? "Button Clicked!" : "Initial State");
             label.name = "TestLabel";
             label.style.marginBottom = 8;
             label.style.unityFontStyleAndWeight = FontStyle.Bold;
@@ -85,8 +82,7 @@ public void CreateGUI()
             var textField = new TextField("Input:");
             textField.name = "TestInput";
             textField.style.marginBottom = 8;
-            textField.value = "";
-            LastInputValue = textField.value;
+            textField.value = LastInputValue;
             textField.RegisterValueChangedCallback(evt => LastInputValue = evt.newValue);
             panel.Add(textField);
 
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..662ab31 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.
@@ -44,7 +46,7 @@ public static void RunAuditMenu()
         public static string RunAudit(bool silent)
         {
             var result = new JObject();
-            
+
             try
             {
                 RunUnityProjectAuditor(result, silent);
@@ -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/UIVerification.cs b/Editor/UIVerification.cs
index 80c5680..a184091 100644
--- a/Editor/UIVerification.cs
+++ b/Editor/UIVerification.cs
@@ -21,12 +21,12 @@ public static class UIVerification
         public static void Verify()
         {
             NexusEditorLog.Log(NexusLogCategory.Diagnostics, "Starting UI Verification...", true);
-            
+
             var wnd = MCPTestWindow.ShowWindow();
             wnd.ResetState();
-            
+
             TestListAndHierarchy();
-            TestInputAndClick();
+            TestInputAndClick(wnd);
             NexusEditorLog.Log(NexusLogCategory.Diagnostics, "VERIFICATION SUCCESS", true);
         }
 
@@ -38,13 +38,13 @@ private static void TestListAndHierarchy()
             if (!hier.Contains("TestButton")) throw new System.Exception("Hierarchy failed");
         }
 
-        private static void TestInputAndClick()
+        private static void TestInputAndClick(MCPTestWindow wnd)
         {
             string txt = "Test";
             Call("ui_input_text", new JObject { ["window_title"] = MCPTestWindow.WindowTitle, ["element_name"] = "TestInput", ["text"] = txt });
-            if (MCPTestWindow.LastInputValue != txt) throw new System.Exception($"Input failed: expected '{txt}' but got '{MCPTestWindow.LastInputValue}'");
+            if (wnd.LastInputValue != txt) throw new System.Exception($"Input failed: expected '{txt}' but got '{wnd.LastInputValue}'");
             Call("ui_click", new JObject { ["window_title"] = MCPTestWindow.WindowTitle, ["element_name"] = "TestButton" });
-            if (!MCPTestWindow.ButtonClicked) throw new System.Exception("Click failed");
+            if (!wnd.ButtonClicked) throw new System.Exception("Click failed");
         }
 
         private static string Call(string m, JObject p)
diff --git a/Editor/UnityMCP.Editor.asmdef b/Editor/UnityMCP.Editor.asmdef
new file mode 100644
index 0000000..669d06b
--- /dev/null
+++ b/Editor/UnityMCP.Editor.asmdef
@@ -0,0 +1,20 @@
+{
+    "name": "UnityMCP.Editor",
+    "rootNamespace": "UnityMCP.Editor",
+    "references": [
+        "UnityMCP.Runtime",
+        "Unity.InputSystem",
+        "Unity.Newtonsoft.Json"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/Editor/UnityMCP.Editor.asmdef.meta b/Editor/UnityMCP.Editor.asmdef.meta
new file mode 100644
index 0000000..406fde0
--- /dev/null
+++ b/Editor/UnityMCP.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8ad53a52b1f1141de864e65b92f9d17e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
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/nexus_bridge/routes_base.py.meta b/Editor/nexus_bridge/routes_base.py.meta
new file mode 100644
index 0000000..32a54dd
--- /dev/null
+++ b/Editor/nexus_bridge/routes_base.py.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7539e4c40e5de427297b8ddf645d3023
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
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/nexus_bridge/routes_editor.py.meta b/Editor/nexus_bridge/routes_editor.py.meta
new file mode 100644
index 0000000..a40ba33
--- /dev/null
+++ b/Editor/nexus_bridge/routes_editor.py.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 0c7be7ae32b2a4d2ca7596f67ce621d1
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
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/nexus_bridge/routes_managers.py.meta b/Editor/nexus_bridge/routes_managers.py.meta
new file mode 100644
index 0000000..a5aeb17
--- /dev/null
+++ b/Editor/nexus_bridge/routes_managers.py.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8126d43a6b15945d38e4c31f8b21be91
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
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..2f38ac2
--- /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..fe11fa2
--- /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..d0ac7b0
--- /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.py.meta b/Editor/tests/test_routing.py.meta
deleted file mode 100644
index fd7c09d..0000000
--- a/Editor/tests/test_routing.py.meta
+++ /dev/null
@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 86f06c09336d401f98da3d3ec18dbcea
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
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.py.meta b/Editor/tests/test_schemas.py.meta
deleted file mode 100644
index 910a12a..0000000
--- a/Editor/tests/test_schemas.py.meta
+++ /dev/null
@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 9046bb8bd125460690905034f6644fcf
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
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.meta b/Editor/tests/test_transport.py.meta
deleted file mode 100644
index c7f8bab..0000000
--- a/Editor/tests/test_transport.py.meta
+++ /dev/null
@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 8a2b2ea69da94bffad2722e0436f81d8
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
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/README.md b/README.md
index 97704a2..5ee2e15 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Nexus Unity
 
-[![Tag](https://img.shields.io/github/v/tag/ForkHorizon/NexusUnity?sort=semver&label=release)](https://github.com/ForkHorizon/NexusUnity/releases/tag/v1.5.0)
+[![Tag](https://img.shields.io/github/v/tag/ForkHorizon/NexusUnity?sort=semver&label=release)](https://github.com/ForkHorizon/NexusUnity/releases/tag/v1.6.0)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE.md)
 [![Unity](https://img.shields.io/badge/Unity-6000.0%2B-black?logo=unity)](package.json)
 [![Validate package](https://github.com/ForkHorizon/NexusUnity/actions/workflows/validate.yml/badge.svg)](https://github.com/ForkHorizon/NexusUnity/actions/workflows/validate.yml)
@@ -8,13 +8,13 @@
 Nexus Unity is an open source Unity Editor automation package. It runs a local JSON-RPC server inside the Unity Editor and exposes scene, asset, code, log, test, inspection, and UI automation tools to trusted local developer workflows.
 
 - Package id: `com.forkhorizon.nexus.unity`
-- Version: `1.5.0`
+- Version: `1.6.0`
 - License: `MIT`
 - Public repository: `https://github.com/ForkHorizon/NexusUnity.git`
 
 ## Status
 
-Active public release. Current version: `1.5.0`.
+Active public release. Current version: `1.6.0`.
 
 The public API is maintained for local Unity Editor automation workflows, while new tools and bridge improvements are tracked under `[Unreleased]` in `CHANGELOG.md` until the next tagged release.
 
@@ -48,7 +48,7 @@ https://github.com/ForkHorizon/NexusUnity.git
 For reproducible installs, pin the public release tag:
 
 ```text
-https://github.com/ForkHorizon/NexusUnity.git#v1.5.0
+https://github.com/ForkHorizon/NexusUnity.git#v1.6.0
 ```
 
 Nexus Unity does not declare Unity Project Auditor packages. Its lint tool always runs Nexus style and scene checks, and only includes Unity Project Auditor findings when the host project explicitly has compatible Project Auditor rules installed.
@@ -191,7 +191,7 @@ Current development keeps the public API backward-compatible while tightening sc
 - `invoke_method.arguments` is an optional positional JSON array.
 - `click_object_in_game` accepts a documented `instance_id` target and still supports hierarchy `path` lookup.
 - Unity 6.x editor identity differences are handled internally: Nexus keeps JSON `instance_id` values stable while using Unity 6.4+ `EntityId` APIs when available and Unity 6.3-compatible instance ID APIs otherwise.
-- `get_test_results` reads Unity `TestResults*.xml` summaries from the project root or Unity persistent data path, using scoped failure/reason/output messages for non-passing cases; `unity_editor_controller` exposes `run_tests_wait` as a bridge-side polling workflow.
+- `run_tests` returns `Submitted` only after Unity accepts the asynchronous request; use `get_test_results` for completed `TestResults*.xml` summaries or `unity_editor_controller` `run_tests_wait` to poll for completion without blocking Unity's main thread.
 - `get_tool_usage_stats` reports in-memory raw tool counts, durations, and errors since Unity domain load without storing request payloads; `reset_tool_usage_stats` clears that state for scoped diagnostics. Both are also available through `unity_editor_controller`.
 - `ui_get_window_rect`, `ui_set_window_rect`, and `ui_capture_window_snapshot` support automated layout checks for editor windows.
 
@@ -265,9 +265,9 @@ For integration tests, open the Unity project, start the Nexus Unity server from
 
 ## Development Versioning
 
-Do not bump `package.json` for every change while development is unreleased. Keep the package at the latest public release version, currently `1.5.0`, and record user-visible work under `[Unreleased]` in `CHANGELOG.md`.
+Do not bump `package.json` for every change while development is unreleased. Keep the package at the latest public release version, currently `1.6.0`, and record user-visible work under `[Unreleased]` in `CHANGELOG.md`.
 
-When maintainers prepare a release, move the accumulated `[Unreleased]` entries to the new version section, update `package.json` and the visible version strings in `README.md`, `DOCUMENTATION.MD`, and `API_REFERENCE.MD`, then tag the release. Unity Package Manager and GitHub releases both use semantic `MAJOR.MINOR.PATCH` versions such as `1.5.0` and `v1.5.0`. Reserve patch bumps for urgent compatible hotfixes.
+When maintainers prepare a release, move the accumulated `[Unreleased]` entries to the new version section, update `package.json` and the visible version strings in `README.md`, `DOCUMENTATION.MD`, and `API_REFERENCE.MD`, then tag the release. Unity Package Manager and GitHub releases both use semantic `MAJOR.MINOR.PATCH` versions such as `1.6.0` and `v1.6.0`. Reserve patch bumps for urgent compatible hotfixes.
 
 ## Community
 
@@ -277,6 +277,8 @@ To support ongoing development, use the repository Sponsor button configured thr
 
 ## Release Notes
 
+The `1.6.0` release improves safe, reliable AI-driven Unity Editor automation. It adds bounded UI hierarchy and query traversal, non-blocking WebSocket request handling, persistent MCP authentication tokens, resilient PlayerPrefs support, safer asset and type handling, and better scene dependency, test-result, and editor-focus behavior. It also hardens destructive asset actions and trusted replay of external pull requests. See the complete change list in the `1.6.0` changelog entry.
+
 The `1.5.0` release relicenses Nexus Unity under MIT and hardens the public local-automation surface: every HTTP/WebSocket request now requires the session token; script writes and bulk PlayerPrefs deletion have explicit confirmation gates; raw batches are bounded; and readiness reports are safe during import and Play Mode transitions. It also improves cheap GameObject read-back, primitive validation, bridge resources, current MCP client setup, path-security coverage, test-result reporting, and cross-platform CLI launch reliability. See the complete, migration-relevant detail in the `1.5.0` changelog entry.
 
 The `1.4.2` patch removes direct Unity Project Auditor dependencies to avoid clean-install Console spam, keeps Nexus lint checks available without Project Auditor rules, and tightens the Python MCP bridge schemas, routing types, and compile/test polling behavior.
diff --git a/RELEASE.md b/RELEASE.md
index d7a8fff..ce8de58 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -7,7 +7,7 @@ This checklist is for publishing `com.forkhorizon.nexus.unity` as an open source
 - Package id: `com.forkhorizon.nexus.unity`
 - Public repository: `https://github.com/ForkHorizon/NexusUnity.git`
 - License: `MIT`
-- Current public version: `1.5.0`
+- Current public version: `1.6.0`
 - Minimum Unity version: `6000.0`
 
 ## Development Versioning
@@ -27,7 +27,7 @@ Use `CHANGELOG.md` as the source of truth during development:
 - Keep compatibility notes and migration guidance in the docs while the work is unreleased.
 - Prepare the next semantic version only when cutting a release branch or release commit.
 
-Unity Package Manager requires `MAJOR.MINOR.PATCH` in `package.json`, for example `1.5.0`. GitHub release tags, titles, and announcements use the same semantic version: `v1.5.0` for tags and `1.5.0` for release titles.
+Unity Package Manager requires `MAJOR.MINOR.PATCH` in `package.json`, for example `1.6.0`. GitHub release tags, titles, and announcements use the same semantic version: `v1.6.0` for tags and `1.6.0` for release titles.
 
 When preparing the release, choose the version by semantic versioning:
 
@@ -39,7 +39,7 @@ When preparing the release, choose the version by semantic versioning:
 
 1. Verify `Assets/NexusUnity/package.json`:
    - `name` is `com.forkhorizon.nexus.unity`.
-   - `version` matches the Unity package version, such as `1.5.0`.
+   - `version` matches the Unity package version, such as `1.6.0`.
    - `license` is `MIT`.
    - Repository, documentation, changelog, and license URLs point to the public repository.
 2. Verify docs:
diff --git a/Runtime/MCPRuntimeLogger.cs b/Runtime/MCPRuntimeLogger.cs
index 0c6bd92..cb9e2c3 100644
--- a/Runtime/MCPRuntimeLogger.cs
+++ b/Runtime/MCPRuntimeLogger.cs
@@ -18,6 +18,7 @@ public static class MCPRuntimeLogger
         [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
         private static void Init()
         {
+            Application.logMessageReceivedThreaded -= HandleLog;
             Application.logMessageReceivedThreaded += HandleLog;
         }
 
diff --git a/Runtime/MCPRuntimeLogger.cs.meta b/Runtime/MCPRuntimeLogger.cs.meta
index 2aa71e5..fa7de88 100644
--- a/Runtime/MCPRuntimeLogger.cs.meta
+++ b/Runtime/MCPRuntimeLogger.cs.meta
@@ -1,2 +1,2 @@
 fileFormatVersion: 2
-guid: 7846c308efe274b05b4968bb0002d6f4
\ No newline at end of file
+guid: 7846c308efe274b05b4968bb0002d6f4
diff --git a/Tests~/Editor/AgentToolingTests.cs b/Tests~/Editor/AgentToolingTests.cs
index 2c94f27..5195ac6 100644
--- a/Tests~/Editor/AgentToolingTests.cs
+++ b/Tests~/Editor/AgentToolingTests.cs
@@ -97,10 +97,49 @@ public void ToolUsageStatsTrackCountsAndErrorsWithoutPayloads()
             Assert.GreaterOrEqual(editorState["count"].Value<int>(), 1);
             Assert.IsNotNull(missing);
             Assert.GreaterOrEqual(missing["error_count"].Value<int>(), 1);
+            Assert.AreEqual("Exception", missing["last_error_type"]?.ToString());
+            Assert.IsTrue(missing["last_error"]?.ToString().Contains("agent_tooling_missing_method"));
             CollectionAssert.DoesNotContain(missing.Properties().Select(p => p.Name).ToArray(), "secret_payload");
             CollectionAssert.DoesNotContain(missing.Properties().Select(p => p.Name).ToArray(), "payload");
         }
 
+        [Test]
+        public void ToolUsageStatsSanitizesRawExceptionPathsAndDetails()
+        {
+            var exUnix = new System.InvalidOperationException("Failed to load /Users/daliys/SecretProjects/MyProject/Assets/Secret.cs\nStack trace line 1\nStack trace line 2");
+            string sanitizedUnix = MCPServerMethods.SanitizeErrorMessage(exUnix, out string errorTypeUnix);
+            Assert.AreEqual("InvalidOperationException", errorTypeUnix);
+            Assert.IsFalse(sanitizedUnix.Contains("/Users/daliys"));
+            Assert.IsFalse(sanitizedUnix.Contains("Stack trace"));
+            Assert.IsTrue(sanitizedUnix.Contains("[path]") || sanitizedUnix.Contains("[project]"));
+
+            var exWin = new System.IO.FileNotFoundException(@"Missing file at C:\Users\Admin\Documents\Unity\Secret.asset");
+            string sanitizedWin = MCPServerMethods.SanitizeErrorMessage(exWin, out string errorTypeWin);
+            Assert.AreEqual("FileNotFoundException", errorTypeWin);
+            Assert.IsFalse(sanitizedWin.Contains(@"C:\Users\Admin"));
+            Assert.IsTrue(sanitizedWin.Contains("[path]"));
+
+            var innerEx = new System.ArgumentNullException("paramName", @"Value cannot be null at /usr/local/share/data/config.json");
+            var wrappedTargetEx = new System.Reflection.TargetInvocationException("Exception has been thrown by the target of an invocation.", innerEx);
+            string sanitizedWrapped = MCPServerMethods.SanitizeErrorMessage(wrappedTargetEx, out string errorTypeWrapped);
+            Assert.AreEqual("ArgumentNullException", errorTypeWrapped);
+            Assert.IsFalse(sanitizedWrapped.Contains("/usr/local/share"));
+            Assert.IsTrue(sanitizedWrapped.Contains("[path]"));
+
+            var exOpt = new System.InvalidOperationException("Failed at /opt/unity/cache/temp.txt");
+            string sanitizedOpt = MCPServerMethods.SanitizeErrorMessage(exOpt, out string errorTypeOpt);
+            Assert.AreEqual("InvalidOperationException", errorTypeOpt);
+            Assert.IsFalse(sanitizedOpt.Contains("/opt/unity"));
+            Assert.IsTrue(sanitizedOpt.Contains("[path]"));
+
+            string longMsg = new string('x', 300);
+            var exLong = new System.Exception(longMsg);
+            string sanitizedLong = MCPServerMethods.SanitizeErrorMessage(exLong, out string errorTypeLong);
+            Assert.AreEqual("Exception", errorTypeLong);
+            Assert.LessOrEqual(sanitizedLong.Length, 160);
+            Assert.IsTrue(sanitizedLong.EndsWith("..."));
+        }
+
         [Test]
         public void ResetToolUsageStatsClearsPreviousCalls()
         {
@@ -226,6 +265,109 @@ 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()
+        {
+            var response = Rpc("create_scriptable_object_asset", new JObject
+            {
+                ["type"] = typeof(AbstractScriptableObjectProbe).FullName,
+                ["path"] = "Assets/AbstractProbe.asset"
+            });
+
+            Assert.IsNotNull(response["error"]);
+            string message = response["error"]["message"]?.ToString();
+            Assert.IsTrue(message.Contains("is abstract and cannot be instantiated"), message);
+        }
+
+        [Test]
+        public void ListFieldsForTypeRejectsAbstractTypes()
+        {
+            var response = Rpc("list_fields_for_type", new JObject
+            {
+                ["type"] = typeof(AbstractScriptableObjectProbe).FullName
+            });
+
+            Assert.IsNotNull(response["error"]);
+            string message = response["error"]["message"]?.ToString();
+            Assert.IsTrue(message.Contains("is abstract and cannot be instantiated"), message);
+        }
+
         private void WriteTestResults(string xml)
         {
             Directory.CreateDirectory(Path.GetDirectoryName(_resultPath));
@@ -252,4 +394,8 @@ private static JObject Rpc(string method, JObject parameters = null)
             return JObject.Parse(MCPServerMethods.ProcessJsonRpc(request.ToString(Formatting.None)));
         }
     }
+
+    public abstract class AbstractScriptableObjectProbe : ScriptableObject
+    {
+    }
 }
diff --git a/Tests~/Editor/AssetDeleteSecurityTests.cs b/Tests~/Editor/AssetDeleteSecurityTests.cs
new file mode 100644
index 0000000..2c7fcad
--- /dev/null
+++ b/Tests~/Editor/AssetDeleteSecurityTests.cs
@@ -0,0 +1,192 @@
+using System.IO;
+using NUnit.Framework;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityMCP.Editor.Tests
+{
+    [TestFixture]
+    public class AssetDeleteSecurityTests
+    {
+        private static JObject CallRaw(string method, JObject paramsObj)
+        {
+            var request = new JObject
+            {
+                ["jsonrpc"] = "2.0",
+                ["method"] = method,
+                ["params"] = paramsObj,
+                ["id"] = 1
+            };
+
+            string responseJson = MCPServerMethods.ProcessJsonRpc(request.ToString(Newtonsoft.Json.Formatting.None));
+            return JObject.Parse(responseJson);
+        }
+
+        private static void CleanupGeneratedAssetRoot(string root)
+        {
+            AssetDatabase.DeleteAsset(root);
+
+            string absoluteRoot = MCPServerMethods.ValidatePath(root);
+            if (Directory.Exists(absoluteRoot)) Directory.Delete(absoluteRoot, true);
+
+            string meta = absoluteRoot + ".meta";
+            if (File.Exists(meta)) File.Delete(meta);
+
+            AssetDatabase.Refresh();
+        }
+
+        [Test]
+        public void DeleteAsset_WithoutConfirm_ReturnsError()
+        {
+            string root = "Assets/NexusUnityGeneratedTests";
+            string path = $"{root}/DeleteNoConfirm.txt";
+            CleanupGeneratedAssetRoot(root);
+
+            try
+            {
+                CallRaw("write_file", new JObject { ["path"] = path, ["content"] = "test content" });
+                var res = CallRaw("delete_asset", new JObject { ["path"] = path });
+                Assert.IsNotNull(res["error"], "delete_asset without confirm should return error");
+                Assert.IsTrue(res["error"]["message"].ToString().Contains("confirm: true"), "Error message should mention confirm: true requirement");
+            }
+            finally
+            {
+                CleanupGeneratedAssetRoot(root);
+            }
+        }
+
+        [Test]
+        public void DeleteAsset_ProjectSettings_ReturnsError()
+        {
+            var res = CallRaw("delete_asset", new JObject { ["path"] = "ProjectSettings/ProjectSettings.asset", ["confirm"] = true });
+            Assert.IsNotNull(res["error"], "delete_asset on ProjectSettings should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state ProjectSettings deletion is forbidden");
+        }
+
+        [Test]
+        public void DeleteAsset_AssetsRootFolder_ReturnsError()
+        {
+            var res = CallRaw("delete_asset", new JObject { ["path"] = "Assets", ["confirm"] = true });
+            Assert.IsNotNull(res["error"], "delete_asset on Assets root folder should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state root folder deletion is forbidden");
+
+            var res2 = CallRaw("delete_asset", new JObject { ["path"] = "Assets/", ["confirm"] = true });
+            Assert.IsNotNull(res2["error"], "delete_asset on Assets/ root folder should return error");
+            Assert.IsTrue(res2["error"]["message"].ToString().Contains("forbidden"), "Error message should state root folder deletion is forbidden");
+        }
+
+        [Test]
+        public void DeleteAsset_MetaFileDirectly_ReturnsError()
+        {
+            var res = CallRaw("delete_asset", new JObject { ["path"] = "Assets/Test.cs.meta", ["confirm"] = true });
+            Assert.IsNotNull(res["error"], "delete_asset on .meta file directly should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("Cannot delete .meta files directly"), "Error message should state .meta deletion is blocked");
+        }
+
+        [Test]
+        public void DeleteAsset_NonExistentFile_ReturnsError()
+        {
+            var res = CallRaw("delete_asset", new JObject { ["path"] = "Assets/NexusNonExistentAsset_12345.png", ["confirm"] = true });
+            Assert.IsNotNull(res["error"], "delete_asset on non-existent file should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("Asset not found"), "Error message should state asset not found");
+        }
+
+        [Test]
+        public void DeleteAsset_WithConfirm_DeletesSuccessfully()
+        {
+            string root = "Assets/NexusUnityGeneratedTests";
+            string path = $"{root}/DeleteWithConfirm.txt";
+            CleanupGeneratedAssetRoot(root);
+
+            try
+            {
+                CallRaw("write_file", new JObject { ["path"] = path, ["content"] = "test content" });
+                Assert.IsTrue(File.Exists(MCPServerMethods.ValidatePath(path)), "Test file should exist before delete_asset");
+
+                var res = CallRaw("delete_asset", new JObject { ["path"] = path, ["confirm"] = true });
+                Assert.IsNotNull(res["result"], $"Expected success result, got error: {res["error"]}");
+                Assert.IsFalse(File.Exists(MCPServerMethods.ValidatePath(path)), "Test file should no longer exist after delete_asset");
+            }
+            finally
+            {
+                CleanupGeneratedAssetRoot(root);
+            }
+        }
+
+        [Test]
+        public void MoveAsset_ToProjectSettings_ReturnsError()
+        {
+            var res = CallRaw("move_asset", new JObject { ["old_path"] = "Assets/Test.txt", ["new_path"] = "ProjectSettings/ProjectSettings.asset" });
+            Assert.IsNotNull(res["error"], "move_asset to ProjectSettings should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying ProjectSettings is forbidden");
+        }
+
+        [Test]
+        public void MoveAsset_FromPackagesOrProjectSettings_ReturnsError()
+        {
+            var res = CallRaw("move_asset", new JObject { ["old_path"] = "Packages/com.unity.textmeshpro", ["new_path"] = "Assets/TMP_Backup" });
+            Assert.IsNotNull(res["error"], "move_asset from Packages should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying Packages is forbidden");
+        }
+
+        [Test]
+        public void MoveAsset_ToAssetsRoot_Succeeds()
+        {
+            string root = "Assets/NexusUnityGeneratedTests";
+            string oldPath = $"{root}/Sub/MoveToRoot.txt";
+            CleanupGeneratedAssetRoot(root);
+
+            try
+            {
+                CallRaw("create_folder", new JObject { ["path"] = $"{root}/Sub" });
+                CallRaw("write_file", new JObject { ["path"] = oldPath, ["content"] = "test" });
+                AssetDatabase.Refresh();
+
+                var res = CallRaw("move_asset", new JObject { ["old_path"] = oldPath, ["new_path"] = root });
+                Assert.IsNotNull(res["result"], $"Expected success result, got error: {res["error"]}");
+                Assert.IsTrue(File.Exists(MCPServerMethods.ValidatePath($"{root}/MoveToRoot.txt")), "File should be moved into target folder");
+            }
+            finally
+            {
+                CleanupGeneratedAssetRoot(root);
+            }
+        }
+
+        [Test]
+        public void CopyAsset_ToProjectSettings_ReturnsError()
+        {
+            var res = CallRaw("copy_asset", new JObject { ["source_path"] = "Assets/Test.txt", ["dest_path"] = "ProjectSettings/ProjectSettings.asset" });
+            Assert.IsNotNull(res["error"], "copy_asset to ProjectSettings should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying ProjectSettings is forbidden");
+        }
+
+        [Test]
+        public void CreateFolder_InProjectSettingsOrPackages_ReturnsError()
+        {
+            var res1 = CallRaw("create_folder", new JObject { ["path"] = "ProjectSettings/ForbiddenDir" });
+            Assert.IsNotNull(res1["error"], "create_folder in ProjectSettings should return error");
+            Assert.IsTrue(res1["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying ProjectSettings is forbidden");
+
+            var res2 = CallRaw("create_folder", new JObject { ["path"] = "Packages/ForbiddenDir" });
+            Assert.IsNotNull(res2["error"], "create_folder in Packages should return error");
+            Assert.IsTrue(res2["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying Packages is forbidden");
+        }
+
+        [Test]
+        public void CreateMaterial_InProjectSettingsOrPackages_ReturnsError()
+        {
+            var res = CallRaw("create_material", new JObject { ["name"] = "BadMat", ["path"] = "ProjectSettings/BadMat.mat" });
+            Assert.IsNotNull(res["error"], "create_material in ProjectSettings should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying ProjectSettings is forbidden");
+        }
+
+        [Test]
+        public void ImportAsset_InProjectSettingsOrPackages_ReturnsError()
+        {
+            var res = CallRaw("import_asset", new JObject { ["path"] = "ProjectSettings/ProjectSettings.asset" });
+            Assert.IsNotNull(res["error"], "import_asset in ProjectSettings should return error");
+            Assert.IsTrue(res["error"]["message"].ToString().Contains("forbidden"), "Error message should state modifying ProjectSettings is forbidden");
+        }
+    }
+}
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/Tests~/Editor/EditorWindowUiToolkitTests.cs b/Tests~/Editor/EditorWindowUiToolkitTests.cs
index a175794..a0cc5a8 100644
--- a/Tests~/Editor/EditorWindowUiToolkitTests.cs
+++ b/Tests~/Editor/EditorWindowUiToolkitTests.cs
@@ -84,6 +84,13 @@ public void ServerWindowBuildsResponsiveUiToolkitSurface()
             }
         }
 
+        [Test]
+        public void IntegrationLookupReturnsNullWhenTheClientIsNoLongerAvailable()
+        {
+            Assert.IsNull(MCPServerWindow.FindIntegrationByKind(
+                Enumerable.Empty<NexusMcpClientInfo>(), NexusMcpClientKind.Codex));
+        }
+
         [Test]
         public void VerificationWindowBuildsNamedControls()
         {
@@ -123,6 +130,29 @@ public void TestWindowPreservesAutomationElementNames()
             }
         }
 
+        [Test]
+        public void TestWindowPreservesVerificationStateWhenRebuilt()
+        {
+            var window = ScriptableObject.CreateInstance<MCPTestWindow>();
+            try
+            {
+                window.CreateGUI();
+                window.rootVisualElement.Q<TextField>("TestInput").value = "Persisted";
+                window.rootVisualElement.Q<Button>("TestButton").Click();
+
+                window.CreateGUI();
+
+                Assert.AreEqual("Persisted", window.LastInputValue);
+                Assert.IsTrue(window.ButtonClicked);
+                Assert.AreEqual("Persisted", window.rootVisualElement.Q<TextField>("TestInput").value);
+                Assert.AreEqual("Button Clicked!", window.rootVisualElement.Q<Label>("TestLabel").text);
+            }
+            finally
+            {
+                Object.DestroyImmediate(window);
+            }
+        }
+
         [Test]
         public void ServerWindowAppliesMinimumUsableSize()
         {
diff --git a/Tests~/Editor/FindObjectsTests.cs b/Tests~/Editor/FindObjectsTests.cs
new file mode 100644
index 0000000..b9187d7
--- /dev/null
+++ b/Tests~/Editor/FindObjectsTests.cs
@@ -0,0 +1,65 @@
+using System.Linq;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UnityMCP.Editor.Tests
+{
+    public class FindObjectsTests
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            MCPServerMethods.Init();
+        }
+
+        [Test]
+        public void FindObjectsHandlesInvalidRegexAndPerformsLiteralSearch()
+        {
+            var go = new GameObject("TestObject (1)");
+            try
+            {
+                JObject result = RpcResult("find_objects", new JObject { ["name"] = "TestObject (1)" });
+                JArray objects = (JArray)result["objects"];
+                Assert.IsNotNull(objects);
+                Assert.IsTrue(objects.Any(o => o["name"]?.ToString() == "TestObject (1)"));
+            }
+            finally
+            {
+                Object.DestroyImmediate(go);
+            }
+        }
+
+        [Test]
+        public void FindObjectsMatchesValidRegexPattern()
+        {
+            var go = new GameObject("RegexObject123");
+            try
+            {
+                JObject result = RpcResult("find_objects", new JObject { ["name"] = "^RegexObject\\d+$" });
+                JArray objects = (JArray)result["objects"];
+                Assert.IsNotNull(objects);
+                Assert.IsTrue(objects.Any(o => o["name"]?.ToString() == "RegexObject123"));
+            }
+            finally
+            {
+                Object.DestroyImmediate(go);
+            }
+        }
+
+        private static JObject RpcResult(string method, JObject parameters = null)
+        {
+            var request = new JObject
+            {
+                ["jsonrpc"] = "2.0",
+                ["method"] = method,
+                ["params"] = parameters ?? new JObject(),
+                ["id"] = 1
+            };
+
+            JObject response = JObject.Parse(MCPServerMethods.ProcessJsonRpc(request.ToString(Formatting.None)));
+            Assert.IsNull(response["error"], response.ToString(Formatting.None));
+            return (JObject)response["result"];
+        }
+    }
+}
diff --git a/Tests~/Editor/PathSecurityTests.cs b/Tests~/Editor/PathSecurityTests.cs
index e06c734..564114f 100644
--- a/Tests~/Editor/PathSecurityTests.cs
+++ b/Tests~/Editor/PathSecurityTests.cs
@@ -139,6 +139,61 @@ public void WriteFilesBatch_CSharpRequiresConfirmBeforeAnyWrite()
             }
         }
 
+        [Test]
+        public void ValidatePath_PreventsSymlinkTraversalOutsideProject()
+        {
+            string projectRoot = Path.GetDirectoryName(Application.dataPath).Replace('\\', '/');
+            string outsideDir = Path.Combine(Path.GetDirectoryName(projectRoot), "nexus-test-outside-" + Guid.NewGuid().ToString("N")).Replace('\\', '/');
+            Directory.CreateDirectory(outsideDir);
+
+            string symlinkPath = Path.Combine(Application.dataPath, "OutsideSymlinkTemp").Replace('\\', '/');
+
+            try
+            {
+                if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows))
+                {
+                    var processInfo = new System.Diagnostics.ProcessStartInfo("cmd", $"/c mklink /d \"{symlinkPath.Replace('/', '\\')}\" \"{outsideDir.Replace('/', '\\')}\"")
+                    {
+                        CreateNoWindow = true,
+                        UseShellExecute = false
+                    };
+                    System.Diagnostics.Process.Start(processInfo).WaitForExit();
+                }
+                else
+                {
+                    System.Diagnostics.Process.Start("ln", $"-s \"{outsideDir}\" \"{symlinkPath}\"").WaitForExit();
+                }
+
+                if (!Directory.Exists(symlinkPath))
+                {
+                    Assert.Ignore("Symlink could not be created (possible permission/platform limitation).");
+                }
+
+                string maliciousPath = Path.Combine(symlinkPath, "file.txt").Replace('\\', '/');
+
+                var ex = Assert.Throws<Exception>(() => MCPServerMethods.ValidatePath(maliciousPath));
+                Assert.That(ex.Message, Does.Contain("Access denied"));
+            }
+            finally
+            {
+                if (File.Exists(symlinkPath) || Directory.Exists(symlinkPath))
+                {
+                    if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows))
+                    {
+                        Directory.Delete(symlinkPath);
+                    }
+                    else
+                    {
+                        File.Delete(symlinkPath);
+                    }
+                }
+                if (Directory.Exists(outsideDir))
+                {
+                    Directory.Delete(outsideDir);
+                }
+            }
+        }
+
         [Test]
         public void AttachScript_RequiresConfirm()
         {
diff --git a/Tests~/Editor/PlayerPrefsTests.cs b/Tests~/Editor/PlayerPrefsTests.cs
new file mode 100644
index 0000000..e2247e1
--- /dev/null
+++ b/Tests~/Editor/PlayerPrefsTests.cs
@@ -0,0 +1,97 @@
+using NUnit.Framework;
+using UnityEngine;
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+
+namespace UnityMCP.Editor.Tests
+{
+    public class PlayerPrefsTests
+    {
+        [Test]
+        public void UnescapeWindowsRegistryKeyName_StripsHashSuffix_WhenValidHashPresent()
+        {
+            string input = "my_setting_key_h1234567890";
+            string result = MCPServerMethods.UnescapeWindowsRegistryKeyName(input);
+            Assert.AreEqual("my_setting_key", result);
+        }
+
+        [Test]
+        public void UnescapeWindowsRegistryKeyName_PreservesKey_WhenNoHashSuffix()
+        {
+            string input = "user_profile_volume_level";
+            string result = MCPServerMethods.UnescapeWindowsRegistryKeyName(input);
+            Assert.AreEqual("user_profile_volume_level", result);
+        }
+
+        [Test]
+        public void ParseMacOsDefaultsOutput_ExtractsQuotedAndUnquotedKeys()
+        {
+            string mockOutput = @"{
+    ""player_session_count"" = 5;
+    music_volume = 0.8;
+    ""custom.key.name"" = ""some_value"";
+    ""escaped\\\""quote"" = ""val"";
+}";
+            List<string> keys = MCPServerMethods.ParseMacOsDefaultsOutput(mockOutput);
+            Assert.Contains("player_session_count", keys);
+            Assert.Contains("music_volume", keys);
+            Assert.Contains("custom.key.name", keys);
+            Assert.Contains("escaped\"quote", keys);
+        }
+
+        [Test]
+        public void ReadPlayerPrefValue_CorrectlyIdentifiesIntMinValue()
+        {
+            string testKey = "NexusTest_IntMin_" + System.Guid.NewGuid().ToString("N");
+            try
+            {
+                PlayerPrefs.SetInt(testKey, int.MinValue);
+                PlayerPrefs.Save();
+
+                JToken val = MCPServerMethods.ReadPlayerPrefValue(testKey);
+                Assert.AreEqual(int.MinValue, val.Value<int>());
+            }
+            finally
+            {
+                PlayerPrefs.DeleteKey(testKey);
+            }
+        }
+
+        [Test]
+        public void ReadPlayerPrefValue_CorrectlyIdentifiesString()
+        {
+            string testKey = "NexusTest_String_" + System.Guid.NewGuid().ToString("N");
+            try
+            {
+                PlayerPrefs.SetString(testKey, "hello_world");
+                PlayerPrefs.Save();
+
+                JToken val = MCPServerMethods.ReadPlayerPrefValue(testKey);
+                Assert.AreEqual("hello_world", val.ToString());
+            }
+            finally
+            {
+                PlayerPrefs.DeleteKey(testKey);
+            }
+        }
+
+        [Test]
+        public void ReadPlayerPrefValue_DoesNotConfuseIntForString()
+        {
+            string testKey = "NexusTest_IntForStr_" + System.Guid.NewGuid().ToString("N");
+            try
+            {
+                PlayerPrefs.SetInt(testKey, 42);
+                PlayerPrefs.Save();
+
+                JToken val = MCPServerMethods.ReadPlayerPrefValue(testKey);
+                Assert.AreEqual(JTokenType.Integer, val.Type);
+                Assert.AreEqual(42, val.Value<int>());
+            }
+            finally
+            {
+                PlayerPrefs.DeleteKey(testKey);
+            }
+        }
+    }
+}
diff --git a/Tests~/Editor/ServerPortTests.cs b/Tests~/Editor/ServerPortTests.cs
index 3de66a5..c3fced4 100644
--- a/Tests~/Editor/ServerPortTests.cs
+++ b/Tests~/Editor/ServerPortTests.cs
@@ -36,7 +36,7 @@ public void IsPortBusy_DetectsLocalListener()
             try
             {
                 listener.Start();
-                
+
                 // The new logic should catch it via TcpClient connect.
                 bool isBusy = (bool)InvokePrivateMethod("IsPortBusy", TEST_PORT);
                 Assert.IsTrue(isBusy, "IsPortBusy should detect the active TcpListener on Loopback");
@@ -58,6 +58,23 @@ public void AuthToken_IsRequiredForNetworkRequests()
             Assert.IsTrue((bool)InvokePrivateMethod("IsAuthorizedToken", token));
         }
 
+        [Test]
+        public void AuthToken_PersistsAcrossSessionStateReset()
+        {
+            string initialToken = MCPServer.AuthToken;
+            Assert.IsFalse(string.IsNullOrEmpty(initialToken), "Auth token should be non-empty");
+
+            var authTokenField = typeof(MCPServer).GetField("_authToken", BindingFlags.NonPublic | BindingFlags.Static);
+            authTokenField?.SetValue(null, null);
+
+            var sessionKeyField = typeof(MCPServer).GetField("AuthSessionStateKey", BindingFlags.NonPublic | BindingFlags.Static);
+            string sessionKey = (string)sessionKeyField?.GetValue(null) ?? "NexusUnity_AuthToken";
+            SessionState.SetString(sessionKey, string.Empty);
+
+            string restoredToken = MCPServer.AuthToken;
+            Assert.AreEqual(initialToken, restoredToken, "AuthToken should persist across SessionState resets");
+        }
+
         [Test]
         public void GetPortOwner_IdentifiesProcess()
         {
@@ -66,7 +83,7 @@ public void GetPortOwner_IdentifiesProcess()
             {
                 listener.Start();
                 string owner = (string)InvokePrivateMethod("GetPortOwner", TEST_PORT);
-                
+
                 // Should contain "Unity" on Mac/Windows if running from Editor
                 Assert.IsFalse(string.IsNullOrEmpty(owner), "GetPortOwner should not return empty string");
                 Assert.AreNotEqual("Unknown Process", owner, "Should identify the process");
@@ -80,34 +97,15 @@ public void GetPortOwner_IdentifiesProcess()
         [Test]
         public async Task Start_WithPort0_AssignsDynamicPort()
         {
-            // We expect some background noise from Init() auto-starts in some environments
             LogAssert.ignoreFailingMessages = true;
-
             try
             {
-                // Ensure server is stopped
-                if (MCPServer.State != ServerState.Stopped)
-                {
-                    MCPServer.Stop();
-                    await Task.Delay(200);
-                }
-
-                // Save current port setting
                 int originalPort = MCPSettings.Port;
                 MCPSettings.Port = 0;
 
                 try
                 {
-                    MCPServer.Start();
-                    
-                    // Wait for it to start (it happens async)
-                    int timeout = 50; // 5 seconds max
-                    while (MCPServer.State == ServerState.Starting && timeout-- > 0)
-                    {
-                        await Task.Delay(100);
-                    }
-
-                    Assert.AreEqual(ServerState.Running, MCPServer.State, "Server should be running");
+                    await StartTestServerAsync();
                     Assert.Greater(MCPServer.Port, 0, "Server should have a dynamic port > 0");
                 }
                 finally
@@ -127,11 +125,91 @@ public async Task ServerState_Lifecycle()
         {
             // Wait for any background activity to settle
             await Task.Delay(500);
-            
+
             // This is a loose test because background auto-start might be happening
             Assert.That(MCPServer.State, Is.Not.EqualTo(ServerState.Starting), "Should not be stuck in Starting");
         }
 
+        [Test]
+        public async Task WebSocketConnection_DoesNotBlockConcurrentHttpRequests()
+        {
+            LogAssert.ignoreFailingMessages = true;
+            try
+            {
+                int originalPort = MCPSettings.Port;
+                MCPSettings.Port = 0;
+
+                try
+                {
+                    await StartTestServerAsync();
+                    int port = MCPServer.Port;
+                    string token = MCPServer.AuthToken;
+
+                    using (var ws = new System.Net.WebSockets.ClientWebSocket())
+                    {
+                        ws.Options.SetRequestHeader("X-Nexus-Unity-Token", token);
+                        var connectTask = ws.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);
+                        var completedTask = await Task.WhenAny(connectTask, Task.Delay(2000));
+                        Assert.AreEqual(connectTask, completedTask, "WebSocket should connect within 2s");
+
+                        await VerifyConcurrentHttpRequestAsync(port, token);
+
+                        if (ws.State == System.Net.WebSockets.WebSocketState.Open)
+                        {
+                            await ws.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, "Test done", CancellationToken.None);
+                        }
+                    }
+                }
+                finally
+                {
+                    MCPServer.Stop();
+                    MCPSettings.Port = originalPort;
+                }
+            }
+            finally
+            {
+                LogAssert.ignoreFailingMessages = false;
+            }
+        }
+
+        private async Task StartTestServerAsync()
+        {
+            if (MCPServer.State != ServerState.Stopped)
+            {
+                MCPServer.Stop();
+                await Task.Delay(200);
+            }
+
+            MCPServer.Start();
+            int timeout = 50;
+            while (MCPServer.State == ServerState.Starting && timeout-- > 0)
+            {
+                await Task.Delay(100);
+            }
+
+            Assert.AreEqual(ServerState.Running, MCPServer.State, "Server should be running");
+        }
+
+        private async Task VerifyConcurrentHttpRequestAsync(int port, string token)
+        {
+            using (var httpClient = new System.Net.Http.HttpClient())
+            {
+                var requestContent = new System.Net.Http.StringContent(
+                    "{\"jsonrpc\":\"2.0\",\"method\":\"get_server_status\",\"id\":1}",
+                    System.Text.Encoding.UTF8,
+                    "application/json"
+                );
+                requestContent.Headers.Add("X-Nexus-Unity-Token", token);
+
+                var httpTask = httpClient.PostAsync($"http://127.0.0.1:{port}/", requestContent);
+                var finished = await Task.WhenAny(httpTask, Task.Delay(2000));
+
+                Assert.AreEqual(httpTask, finished, "HTTP request should respond while WebSocket connection is active");
+                var response = await httpTask;
+                Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+            }
+        }
+
         private object InvokePrivateMethod(string methodName, params object[] args)
         {
             var method = typeof(MCPServer).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static);
diff --git a/Tests~/Editor/TypeSecurityTests.cs b/Tests~/Editor/TypeSecurityTests.cs
new file mode 100644
index 0000000..b6422c1
--- /dev/null
+++ b/Tests~/Editor/TypeSecurityTests.cs
@@ -0,0 +1,76 @@
+using System;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEditor;
+
+namespace UnityMCP.Editor.Tests
+{
+    /// <summary>
+    /// Tests for type resolution security, assembly/namespace filtering, and component/ScriptableObject allowlists.
+    /// </summary>
+    public class TypeSecurityTests
+    {
+        [SetUp]
+        public void InitRegistry()
+        {
+            MCPServerMethods.Init();
+        }
+
+        [Test]
+        public void FindType_AllowsValidUnityEngineTypes()
+        {
+            Type type = MCPServerMethods.FindType("BoxCollider");
+            Assert.IsNotNull(type);
+            Assert.AreEqual(typeof(BoxCollider), type);
+
+            type = MCPServerMethods.FindType("Camera");
+            Assert.IsNotNull(type);
+            Assert.AreEqual(typeof(Camera), type);
+        }
+
+        [Test]
+        public void FindType_BlocksDisallowedSystemAndInternalTypes()
+        {
+            Assert.IsNull(MCPServerMethods.FindType("System.String"));
+            Assert.IsNull(MCPServerMethods.FindType("System.AppDomain"));
+            Assert.IsNull(MCPServerMethods.FindType("UnityEditorInternal.InternalEditorUtility"));
+            Assert.IsNull(MCPServerMethods.FindType("Mono.Cecil.TypeDefinition"));
+        }
+
+        [Test]
+        public void FindComponentType_ResolvesValidConcreteComponents()
+        {
+            Type boxCollider = MCPServerMethods.FindComponentType("BoxCollider");
+            Assert.IsNotNull(boxCollider);
+            Assert.AreEqual(typeof(BoxCollider), boxCollider);
+
+            Type camera = MCPServerMethods.FindComponentType("Camera");
+            Assert.IsNotNull(camera);
+            Assert.AreEqual(typeof(Camera), camera);
+        }
+
+        [Test]
+        public void FindComponentType_RejectsAbstractComponentsAndNonComponents()
+        {
+            // Abstract Component base classes must be rejected
+            Assert.IsNull(MCPServerMethods.FindComponentType("Component"));
+            Assert.IsNull(MCPServerMethods.FindComponentType("MonoBehaviour"));
+            Assert.IsNull(MCPServerMethods.FindComponentType("Collider"));
+
+            // Non-components must be rejected
+            Assert.IsNull(MCPServerMethods.FindComponentType("GameObject"));
+            Assert.IsNull(MCPServerMethods.FindComponentType("System.String"));
+        }
+
+        [Test]
+        public void FindScriptableObjectType_RejectsAbstractScriptableObjectsAndNonScriptableObjects()
+        {
+            // Abstract ScriptableObject base class must be rejected
+            Assert.IsNull(MCPServerMethods.FindScriptableObjectType("ScriptableObject"));
+
+            // Components or non-ScriptableObjects must be rejected
+            Assert.IsNull(MCPServerMethods.FindScriptableObjectType("BoxCollider"));
+            Assert.IsNull(MCPServerMethods.FindScriptableObjectType("System.String"));
+        }
+    }
+}
diff --git a/Tests~/Editor/UnityMCP.Editor.Tests.asmdef b/Tests~/Editor/UnityMCP.Editor.Tests.asmdef
new file mode 100644
index 0000000..464facc
--- /dev/null
+++ b/Tests~/Editor/UnityMCP.Editor.Tests.asmdef
@@ -0,0 +1,24 @@
+{
+    "name": "UnityMCP.Editor.Tests",
+    "references": [
+        "UnityMCP.Editor",
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner",
+        "Unity.Newtonsoft.Json"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/package.json b/package.json
index 55c3294..602c07b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.forkhorizon.nexus.unity",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "displayName": "Nexus Unity",
   "description": "Open source Unity Editor automation server for local AI tools and developer workflows.",
   "unity": "6000.0",
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
 
diff --git a/scripts/prepush-validate.sh b/scripts/prepush-validate.sh
index abd345e..a379752 100755
--- a/scripts/prepush-validate.sh
+++ b/scripts/prepush-validate.sh
@@ -216,6 +216,28 @@ import urllib.request
 url = sys.argv[1]
 mode = sys.argv[2]
 
+import os
+
+def get_auth_token():
+    token = os.environ.get("NEXUS_UNITY_AUTH_TOKEN")
+    if token:
+        return token
+    for candidate in (
+        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, "r", encoding="utf-8") as handle:
+                    val = handle.read().strip()
+                    if val:
+                        return val
+            except Exception:
+                pass
+    return None
+
+auth_token = get_auth_token()
+
 TRANSIENT_ERRORS = (
     OSError,
     TimeoutError,
@@ -240,13 +262,17 @@ def rpc(method, params=None, timeout=2, retries=0):
         "id": 1,
     }).encode("utf-8")
 
+    headers = {"Content-Type": "application/json"}
+    if auth_token:
+        headers["X-Nexus-Unity-Token"] = auth_token
+
     last_error = None
     for attempt in range(retries + 1):
         try:
             request = urllib.request.Request(
                 url,
                 data=payload,
-                headers={"Content-Type": "application/json"},
+                headers=headers,
             )
             with urllib.request.urlopen(request, timeout=timeout) as response:
                 data = json.loads(response.read().decode("utf-8"))
@@ -342,6 +368,7 @@ check_nexus_server_ready() {
   local unity_project_root="$1"
   python3 - "$unity_project_root" <<'PY'
 import json
+import os
 import sys
 import time
 import urllib.error
@@ -356,11 +383,34 @@ payload = json.dumps({
 }).encode("utf-8")
 deadline = time.time() + 10
 
+def get_auth_token():
+    token = os.environ.get("NEXUS_UNITY_AUTH_TOKEN")
+    if token:
+        return token
+    for candidate in (
+        os.path.join(project_root, "Library", "NexusUnityAuthToken.txt"),
+        os.path.join(os.getcwd(), "Library", "NexusUnityAuthToken.txt"),
+    ):
+        if os.path.isfile(candidate):
+            try:
+                with open(candidate, "r", encoding="utf-8") as handle:
+                    val = handle.read().strip()
+                    if val:
+                        return val
+            except Exception:
+                pass
+    return None
+
+auth_token = get_auth_token()
+
 while time.time() < deadline:
+    headers = {"Content-Type": "application/json"}
+    if auth_token:
+        headers["X-Nexus-Unity-Token"] = auth_token
     request = urllib.request.Request(
         "http://127.0.0.1:8081/",
         data=payload,
-        headers={"Content-Type": "application/json"},
+        headers=headers,
     )
     try:
         with urllib.request.urlopen(request, timeout=3) as response:
diff --git a/tools~/NexusQualityGate/OllamaChecklistReviewer.cs b/tools~/NexusQualityGate/OllamaChecklistReviewer.cs
index a3ead54..57356ea 100644
--- a/tools~/NexusQualityGate/OllamaChecklistReviewer.cs
+++ b/tools~/NexusQualityGate/OllamaChecklistReviewer.cs
@@ -11,7 +11,7 @@ public sealed class OllamaChecklistReviewer
     private const string RubricVersion = "2026-05-27-pr-checklist-review-v1";
 
     private readonly QualityGateOptions _options;
-    private readonly HttpClient _client = new();
+    private readonly HttpClient _client;
     private readonly Dictionary<string, CachedChecklistVerdict> _cache;
     private readonly string _cachePath;
     private bool _contactedOllama;
@@ -19,10 +19,9 @@ public sealed class OllamaChecklistReviewer
     public OllamaChecklistReviewer(QualityGateOptions options)
     {
         _options = options;
-        _client.Timeout = TimeSpan.FromSeconds(Math.Max(1, options.AiTimeoutSeconds));
-        Directory.CreateDirectory(options.CacheDirectory);
-        _cachePath = Path.Combine(options.CacheDirectory, "ollama-checklist-verdicts.json");
-        _cache = LoadCache(_cachePath);
+        _client = OllamaReviewSupport.CreateClient(options);
+        _cachePath = OllamaReviewSupport.GetCachePath(options, "ollama-checklist-verdicts.json");
+        _cache = OllamaReviewSupport.LoadCache<CachedChecklistVerdict>(_cachePath);
     }
 
     public async Task<IReadOnlyList<QualityGateIssue>> ReviewAsync()
@@ -69,7 +68,7 @@ public async Task<IReadOnlyList<QualityGateIssue>> ReviewAsync()
         }
 
         await Task.WhenAll(tasks);
-        SaveCache(_cachePath, _cache);
+        OllamaReviewSupport.SaveCache(_cachePath, _cache);
         return issues.OrderBy(issue => issue.File, StringComparer.Ordinal).ThenBy(issue => issue.Line).ToList();
     }
 
@@ -146,7 +145,7 @@ private async Task<CachedChecklistVerdict> RequestVerdictAsync(ChecklistItem ite
 
         using var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
         _contactedOllama = true;
-        using HttpResponseMessage response = await _client.PostAsync(BuildOllamaEndpoint(), content);
+        using HttpResponseMessage response = await _client.PostAsync(OllamaReviewSupport.BuildChatEndpoint(_options), content);
         string responseBody = await response.Content.ReadAsStringAsync();
         response.EnsureSuccessStatusCode();
 
@@ -171,9 +170,9 @@ private async Task<CachedChecklistVerdict> RequestVerdictAsync(ChecklistItem ite
             };
 
             using var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
-            using HttpResponseMessage response = await _client.PostAsync(BuildOllamaGenerateEndpoint(), content);
+            using HttpResponseMessage response = await _client.PostAsync(OllamaReviewSupport.BuildGenerateEndpoint(_options), content);
             string responseBody = await response.Content.ReadAsStringAsync();
-            return response.IsSuccessStatusCode ? null : $"{(int)response.StatusCode} {response.ReasonPhrase}: {TrimForLog(responseBody)}";
+            return response.IsSuccessStatusCode ? null : $"{(int)response.StatusCode} {response.ReasonPhrase}: {OllamaReviewSupport.TrimForLog(responseBody)}";
         }
         catch (Exception ex)
         {
@@ -407,13 +406,9 @@ private static string[] BuildSearchTerms(string itemText)
         return terms.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
     }
 
-    private Uri BuildOllamaEndpoint() => new(_options.OllamaUrl.TrimEnd('/') + "/api/chat");
-
-    private Uri BuildOllamaGenerateEndpoint() => new(_options.OllamaUrl.TrimEnd('/') + "/api/generate");
-
     private CachedChecklistVerdict ParseModelVerdict(string content)
     {
-        string json = ExtractJsonObject(content);
+        string json = OllamaReviewSupport.ExtractJsonObject(content);
         AiChecklistVerdict verdict = JsonSerializer.Deserialize<AiChecklistVerdict>(json, new JsonSerializerOptions
         {
             PropertyNameCaseInsensitive = true,
@@ -426,16 +421,6 @@ private CachedChecklistVerdict ParseModelVerdict(string content)
             verdict.NextAction?.Trim() ?? string.Empty);
     }
 
-    private static string ExtractJsonObject(string content)
-    {
-        int start = content.IndexOf('{', StringComparison.Ordinal);
-        int end = content.LastIndexOf('}');
-        if (start < 0 || end <= start)
-            throw new InvalidOperationException("Model did not return a JSON object.");
-
-        return content[start..(end + 1)];
-    }
-
     private QualityGateIssue? ToIssue(ChecklistItem item, CachedChecklistVerdict verdict)
     {
         if (verdict.Pass)
@@ -459,36 +444,6 @@ private string BuildCacheKey(ChecklistItem item, string evidence)
         return Convert.ToHexString(hash);
     }
 
-    private static Dictionary<string, CachedChecklistVerdict> LoadCache(string path)
-    {
-        if (!File.Exists(path))
-            return new Dictionary<string, CachedChecklistVerdict>(StringComparer.Ordinal);
-
-        try
-        {
-            return JsonSerializer.Deserialize<Dictionary<string, CachedChecklistVerdict>>(File.ReadAllText(path))
-                ?? new Dictionary<string, CachedChecklistVerdict>(StringComparer.Ordinal);
-        }
-        catch
-        {
-            return new Dictionary<string, CachedChecklistVerdict>(StringComparer.Ordinal);
-        }
-    }
-
-    private static void SaveCache(string path, Dictionary<string, CachedChecklistVerdict> cache)
-    {
-        string tempPath = path + ".tmp";
-        File.WriteAllText(tempPath, JsonSerializer.Serialize(cache, new JsonSerializerOptions { WriteIndented = true }));
-        File.Move(tempPath, path, true);
-    }
-
-    private static string TrimForLog(string value)
-    {
-        const int maxLength = 500;
-        value = value.ReplaceLineEndings(" ").Trim();
-        return value.Length <= maxLength ? value : value[..maxLength] + "...";
-    }
-
     private sealed record CachedChecklistVerdict(bool Pass, string Severity, string Reason, string NextAction);
 
     private sealed class AiChecklistVerdict
diff --git a/tools~/NexusQualityGate/OllamaDocumentationReviewer.cs b/tools~/NexusQualityGate/OllamaDocumentationReviewer.cs
index d215c50..fb1db64 100644
--- a/tools~/NexusQualityGate/OllamaDocumentationReviewer.cs
+++ b/tools~/NexusQualityGate/OllamaDocumentationReviewer.cs
@@ -10,7 +10,7 @@ public sealed class OllamaDocumentationReviewer
     private const string RubricVersion = "2026-05-23-pragmatic-doc-review-v2";
 
     private readonly QualityGateOptions _options;
-    private readonly HttpClient _client = new();
+    private readonly HttpClient _client;
     private readonly Dictionary<string, CachedVerdict> _cache;
     private readonly string _cachePath;
     private bool _contactedOllama;
@@ -18,10 +18,9 @@ public sealed class OllamaDocumentationReviewer
     public OllamaDocumentationReviewer(QualityGateOptions options)
     {
         _options = options;
-        _client.Timeout = TimeSpan.FromSeconds(Math.Max(1, options.AiTimeoutSeconds));
-        Directory.CreateDirectory(options.CacheDirectory);
-        _cachePath = Path.Combine(options.CacheDirectory, "ollama-verdicts.json");
-        _cache = LoadCache(_cachePath);
+        _client = OllamaReviewSupport.CreateClient(options);
+        _cachePath = OllamaReviewSupport.GetCachePath(options, "ollama-verdicts.json");
+        _cache = OllamaReviewSupport.LoadCache<CachedVerdict>(_cachePath);
     }
 
     public async Task<IReadOnlyList<QualityGateIssue>> ReviewAsync(IReadOnlyList<DocumentationCandidate> candidates)
@@ -59,7 +58,7 @@ public async Task<IReadOnlyList<QualityGateIssue>> ReviewAsync(IReadOnlyList<Doc
         }
 
         await Task.WhenAll(tasks);
-        SaveCache(_cachePath, _cache);
+        OllamaReviewSupport.SaveCache(_cachePath, _cache);
         return issues.OrderBy(issue => issue.File, StringComparer.Ordinal).ThenBy(issue => issue.Line).ToList();
     }
 
@@ -124,7 +123,7 @@ private async Task<CachedVerdict> RequestVerdictAsync(DocumentationCandidate can
 
         using var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
         _contactedOllama = true;
-        using HttpResponseMessage response = await _client.PostAsync(BuildOllamaEndpoint(), content);
+        using HttpResponseMessage response = await _client.PostAsync(OllamaReviewSupport.BuildChatEndpoint(_options), content);
         string responseBody = await response.Content.ReadAsStringAsync();
         response.EnsureSuccessStatusCode();
 
@@ -149,10 +148,10 @@ private async Task<CachedVerdict> RequestVerdictAsync(DocumentationCandidate can
             };
 
             using var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
-            using HttpResponseMessage response = await _client.PostAsync(BuildOllamaGenerateEndpoint(), content);
+            using HttpResponseMessage response = await _client.PostAsync(OllamaReviewSupport.BuildGenerateEndpoint(_options), content);
             string responseBody = await response.Content.ReadAsStringAsync();
             if (!response.IsSuccessStatusCode)
-                return $"{(int)response.StatusCode} {response.ReasonPhrase}: {TrimForLog(responseBody)}";
+                return $"{(int)response.StatusCode} {response.ReasonPhrase}: {OllamaReviewSupport.TrimForLog(responseBody)}";
 
             return null;
         }
@@ -162,18 +161,6 @@ private async Task<CachedVerdict> RequestVerdictAsync(DocumentationCandidate can
         }
     }
 
-    private Uri BuildOllamaEndpoint()
-    {
-        string baseUrl = _options.OllamaUrl.TrimEnd('/');
-        return new Uri(baseUrl + "/api/chat");
-    }
-
-    private Uri BuildOllamaGenerateEndpoint()
-    {
-        string baseUrl = _options.OllamaUrl.TrimEnd('/');
-        return new Uri(baseUrl + "/api/generate");
-    }
-
     private static string BuildPrompt(DocumentationCandidate candidate)
     {
         return $"""
@@ -193,7 +180,7 @@ private static string BuildPrompt(DocumentationCandidate candidate)
 
     private CachedVerdict ParseModelVerdict(string content)
     {
-        string json = ExtractJsonObject(content);
+        string json = OllamaReviewSupport.ExtractJsonObject(content);
         AiVerdict verdict = JsonSerializer.Deserialize<AiVerdict>(json, new JsonSerializerOptions
         {
             PropertyNameCaseInsensitive = true,
@@ -207,16 +194,6 @@ private CachedVerdict ParseModelVerdict(string content)
         return new CachedVerdict(pass, severity, reason, suggestedDoc);
     }
 
-    private static string ExtractJsonObject(string content)
-    {
-        int start = content.IndexOf('{', StringComparison.Ordinal);
-        int end = content.LastIndexOf('}');
-        if (start < 0 || end <= start)
-            throw new InvalidOperationException("Model did not return a JSON object.");
-
-        return content[start..(end + 1)];
-    }
-
     private QualityGateIssue? ToIssue(DocumentationCandidate candidate, CachedVerdict verdict)
     {
         if (verdict.Pass)
@@ -240,36 +217,6 @@ private string BuildCacheKey(DocumentationCandidate candidate)
         return Convert.ToHexString(hash);
     }
 
-    private static Dictionary<string, CachedVerdict> LoadCache(string path)
-    {
-        if (!File.Exists(path))
-            return new Dictionary<string, CachedVerdict>(StringComparer.Ordinal);
-
-        try
-        {
-            return JsonSerializer.Deserialize<Dictionary<string, CachedVerdict>>(File.ReadAllText(path))
-                ?? new Dictionary<string, CachedVerdict>(StringComparer.Ordinal);
-        }
-        catch
-        {
-            return new Dictionary<string, CachedVerdict>(StringComparer.Ordinal);
-        }
-    }
-
-    private static void SaveCache(string path, Dictionary<string, CachedVerdict> cache)
-    {
-        string tempPath = path + ".tmp";
-        File.WriteAllText(tempPath, JsonSerializer.Serialize(cache, new JsonSerializerOptions { WriteIndented = true }));
-        File.Move(tempPath, path, true);
-    }
-
-    private static string TrimForLog(string value)
-    {
-        const int maxLength = 500;
-        value = value.ReplaceLineEndings(" ").Trim();
-        return value.Length <= maxLength ? value : value[..maxLength] + "...";
-    }
-
     private sealed record CachedVerdict(bool Pass, string Severity, string Reason, string SuggestedDoc);
 
     private sealed class AiVerdict
diff --git a/tools~/NexusQualityGate/OllamaReviewSupport.cs b/tools~/NexusQualityGate/OllamaReviewSupport.cs
new file mode 100644
index 0000000..225f1f2
--- /dev/null
+++ b/tools~/NexusQualityGate/OllamaReviewSupport.cs
@@ -0,0 +1,61 @@
+using System.Text.Json;
+
+namespace NexusQualityGate;
+
+internal static class OllamaReviewSupport
+{
+    public static HttpClient CreateClient(QualityGateOptions options) => new()
+    {
+        Timeout = TimeSpan.FromSeconds(Math.Max(1, options.AiTimeoutSeconds)),
+    };
+
+    public static string GetCachePath(QualityGateOptions options, string fileName)
+    {
+        Directory.CreateDirectory(options.CacheDirectory);
+        return Path.Combine(options.CacheDirectory, fileName);
+    }
+
+    public static Uri BuildChatEndpoint(QualityGateOptions options) => new(options.OllamaUrl.TrimEnd('/') + "/api/chat");
+
+    public static Uri BuildGenerateEndpoint(QualityGateOptions options) => new(options.OllamaUrl.TrimEnd('/') + "/api/generate");
+
+    public static string ExtractJsonObject(string content)
+    {
+        int start = content.IndexOf('{', StringComparison.Ordinal);
+        int end = content.LastIndexOf('}');
+        if (start < 0 || end <= start)
+            throw new InvalidOperationException("Model did not return a JSON object.");
+
+        return content[start..(end + 1)];
+    }
+
+    public static Dictionary<string, T> LoadCache<T>(string path)
+    {
+        if (!File.Exists(path))
+            return new Dictionary<string, T>(StringComparer.Ordinal);
+
+        try
+        {
+            return JsonSerializer.Deserialize<Dictionary<string, T>>(File.ReadAllText(path))
+                ?? new Dictionary<string, T>(StringComparer.Ordinal);
+        }
+        catch
+        {
+            return new Dictionary<string, T>(StringComparer.Ordinal);
+        }
+    }
+
+    public static void SaveCache<T>(string path, Dictionary<string, T> cache)
+    {
+        string tempPath = path + ".tmp";
+        File.WriteAllText(tempPath, JsonSerializer.Serialize(cache, new JsonSerializerOptions { WriteIndented = true }));
+        File.Move(tempPath, path, true);
+    }
+
+    public static string TrimForLog(string value)
+    {
+        const int maxLength = 500;
+        value = value.ReplaceLineEndings(" ").Trim();
+        return value.Length <= maxLength ? value : value[..maxLength] + "...";
+    }
+}