@akiojin/unity-mcp-server 3.0.0 → 3.2.0

package/bin/unity-mcp-server.js

@@ -34,7 +34,7 @@ const args = process.argv.slice(2);
 const command = args[0] && !args[0].startsWith('--') ? args[0] : null;
 const rest = command ? args.slice(1) : args;
 
-let httpEnabled = false;
+let httpEnabled;
 let httpPort;
 let stdioEnabled = true;
 let telemetryEnabled;
@@ -114,11 +114,12 @@ async function main() {
 
     // Start MCP server (dynamic import)
     const { startServer } = await import('../src/core/server.js');
+    const http = {};
+    if (httpEnabled !== undefined) http.enabled = httpEnabled;
+    if (httpPort !== undefined) http.port = httpPort;
+
     await startServer({
-      http: {
-        enabled: httpEnabled,
-        port: httpPort
-      },
+      http: Object.keys(http).length > 0 ? http : undefined,
       telemetry: telemetryEnabled === undefined ? undefined : { enabled: telemetryEnabled },
       stdioEnabled
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",

package/src/core/config.js

@@ -1,12 +1,8 @@
 import fs from 'fs';
-import os from 'os';
 import path from 'path';
 import * as findUpPkg from 'find-up';
 import { MCPLogger } from './mcpLogger.js';
 
-// Diagnostic log: confirm module loading reached this point
-process.stderr.write('[unity-mcp-server] Config module loading...\n');
-
 function findUpSyncCompat(matcher, options = {}) {
   if (typeof matcher === 'function') {
     let dir = options.cwd || process.cwd();
@@ -39,6 +35,30 @@ function merge(a, b) {
   return out;
 }
 
+function parseBoolEnv(value) {
+  if (typeof value !== 'string') return undefined;
+  const v = value.trim().toLowerCase();
+  if (v === '') return undefined;
+  if (v === '1' || v === 'true' || v === 'yes' || v === 'y' || v === 'on') return true;
+  if (v === '0' || v === 'false' || v === 'no' || v === 'n' || v === 'off') return false;
+  return undefined;
+}
+
+function parseIntEnv(value) {
+  if (typeof value !== 'string') return undefined;
+  const v = value.trim();
+  if (v === '') return undefined;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function envString(key) {
+  const raw = process.env[key];
+  if (typeof raw !== 'string') return undefined;
+  const v = raw.trim();
+  return v.length > 0 ? v : undefined;
+}
+
 function resolvePackageVersion() {
   const candidates = [];
 
@@ -71,16 +91,23 @@ function resolvePackageVersion() {
 const baseConfig = {
   // Unity connection settings
   unity: {
-    unityHost: null,
-    mcpHost: null,
-    bindHost: null,
+    unityHost: 'localhost',
+    mcpHost: 'localhost',
+    bindHost: 'localhost',
     port: 6400,
     reconnectDelay: 1000,
     maxReconnectDelay: 30000,
     reconnectBackoffMultiplier: 2,
+    connectTimeout: 3000,
     commandTimeout: 30000
   },
 
+  // Project settings (primarily for code index paths)
+  project: {
+    root: null,
+    codeIndexRoot: null
+  },
+
   // Server settings
   server: {
     name: 'unity-mcp-server',
@@ -136,83 +163,124 @@ const baseConfig = {
   }
 };
 
-/**
- * External config resolution:
- * - Uses the nearest `.unity/config.json` found by walking up from the current working directory.
- * - Intentionally ignores `~/.unity/config.json` (user-global).
- */
-function loadExternalConfig() {
-  if (typeof findUpSyncCompat !== 'function') {
-    return {};
+function loadEnvConfig() {
+  const unityHost = envString('UNITY_MCP_UNITY_HOST');
+  const mcpHost = envString('UNITY_MCP_MCP_HOST');
+  const unityPort = parseIntEnv(process.env.UNITY_MCP_PORT);
+
+  const projectRoot = envString('UNITY_PROJECT_ROOT');
+
+  const logLevel = envString('UNITY_MCP_LOG_LEVEL');
+
+  const httpEnabled = parseBoolEnv(process.env.UNITY_MCP_HTTP_ENABLED);
+  const httpPort = parseIntEnv(process.env.UNITY_MCP_HTTP_PORT);
+
+  const telemetryEnabled = parseBoolEnv(process.env.UNITY_MCP_TELEMETRY_ENABLED);
+  const lspRequestTimeoutMs = parseIntEnv(process.env.UNITY_MCP_LSP_REQUEST_TIMEOUT_MS);
+
+  const out = {};
+
+  if (unityHost || mcpHost || unityPort !== undefined) {
+    out.unity = {};
+    if (unityHost) out.unity.unityHost = unityHost;
+    if (mcpHost) out.unity.mcpHost = mcpHost;
+    if (unityPort !== undefined) out.unity.port = unityPort;
+    if (out.unity.unityHost) out.unity.bindHost = out.unity.unityHost;
   }
-  let userGlobalPath = null;
-  try {
-    const homeDir = os.homedir();
-    userGlobalPath = homeDir ? path.resolve(homeDir, '.unity', 'config.json') : null;
-  } catch {}
 
-  const projectPath = findUpSyncCompat(
-    directory => {
-      const candidate = path.resolve(directory, '.unity', 'config.json');
-      if (userGlobalPath && path.resolve(candidate) === userGlobalPath) return undefined;
-      return fs.existsSync(candidate) ? candidate : undefined;
-    },
-    { cwd: process.cwd() }
-  );
+  if (projectRoot) {
+    out.project = {};
+    if (projectRoot) out.project.root = projectRoot;
+  }
 
-  if (!projectPath) return {};
-  try {
-    const raw = fs.readFileSync(projectPath, 'utf8');
-    const json = JSON.parse(raw);
-    const out = json && typeof json === 'object' ? json : {};
-    out.__configPath = projectPath;
-    return out;
-  } catch (e) {
-    return { __configLoadError: `${projectPath}: ${e.message}` };
+  if (logLevel) {
+    out.logging = { level: logLevel };
   }
-}
 
-const external = loadExternalConfig();
-export const config = merge(baseConfig, external);
+  if (httpEnabled !== undefined || httpPort !== undefined) {
+    out.http = {};
+    if (httpEnabled !== undefined) out.http.enabled = httpEnabled;
+    if (httpPort !== undefined) out.http.port = httpPort;
+  }
 
-const normalizeUnityConfig = () => {
-  const unityConfig = config.unity || (config.unity = {});
+  if (telemetryEnabled !== undefined) {
+    out.telemetry = { enabled: telemetryEnabled };
+  }
 
-  // Legacy aliases coming from config files
-  const legacyHost = unityConfig.host;
-  const legacyClientHost = unityConfig.clientHost;
-  const legacyBindHost = unityConfig.bindHost;
+  if (lspRequestTimeoutMs !== undefined) {
+    out.lsp = { requestTimeoutMs: lspRequestTimeoutMs };
+  }
 
-  if (!unityConfig.unityHost) {
-    unityConfig.unityHost = legacyBindHost || legacyHost || 'localhost';
+  return out;
+}
+
+function validateAndNormalizeConfig(cfg) {
+  // Unity port
+  if (!Number.isInteger(cfg.unity.port) || cfg.unity.port <= 0 || cfg.unity.port >= 65536) {
+    console.error(
+      `[unity-mcp-server] WARN: Invalid UNITY_MCP_PORT (${cfg.unity.port}); using default 6400`
+    );
+    cfg.unity.port = 6400;
   }
 
-  if (!unityConfig.mcpHost) {
-    unityConfig.mcpHost = legacyClientHost || legacyHost || unityConfig.unityHost;
+  // HTTP port
+  if (cfg.http?.port !== undefined) {
+    if (!Number.isInteger(cfg.http.port) || cfg.http.port <= 0 || cfg.http.port >= 65536) {
+      console.error(
+        `[unity-mcp-server] WARN: Invalid UNITY_MCP_HTTP_PORT (${cfg.http.port}); using default 6401`
+      );
+      cfg.http.port = 6401;
+    }
   }
 
-  // Keep bindHost for backwards compatibility with legacy code paths
-  if (!unityConfig.bindHost) {
-    unityConfig.bindHost = legacyBindHost || unityConfig.unityHost;
+  // logging.level
+  if (cfg.logging?.level) {
+    const level = String(cfg.logging.level).toLowerCase();
+    const allowed = new Set(['debug', 'info', 'warn', 'warning', 'error']);
+    if (!allowed.has(level)) {
+      console.error(
+        `[unity-mcp-server] WARN: Invalid UNITY_MCP_LOG_LEVEL (${cfg.logging.level}); using default info`
+      );
+      cfg.logging.level = 'info';
+    } else {
+      cfg.logging.level = level === 'warning' ? 'warn' : level;
+    }
   }
 
-  // Maintain legacy properties so older handlers keep working
-  unityConfig.host = unityConfig.unityHost;
-  unityConfig.clientHost = unityConfig.mcpHost;
-};
+  // unity hosts
+  if (typeof cfg.unity.unityHost !== 'string' || cfg.unity.unityHost.trim() === '') {
+    cfg.unity.unityHost = 'localhost';
+  }
+  if (typeof cfg.unity.mcpHost !== 'string' || cfg.unity.mcpHost.trim() === '') {
+    cfg.unity.mcpHost = cfg.unity.unityHost;
+  }
+  cfg.unity.bindHost = cfg.unity.unityHost;
 
-normalizeUnityConfig();
+  // project roots (keep as-is; resolved later)
+  if (cfg.project?.root && typeof cfg.project.root !== 'string') {
+    cfg.project.root = null;
+  }
+  if (cfg.project?.codeIndexRoot && typeof cfg.project.codeIndexRoot !== 'string') {
+    cfg.project.codeIndexRoot = null;
+  }
 
-// Workspace root detection: directory that contains .unity/config.json used
-const initialCwd = process.cwd();
-let workspaceRoot = initialCwd;
-try {
-  if (config.__configPath) {
-    const cfgDir = path.dirname(config.__configPath); // <workspace>/.unity
-    workspaceRoot = path.dirname(cfgDir); // <workspace>
+  // lsp timeout sanity
+  if (cfg.lsp?.requestTimeoutMs !== undefined) {
+    const t = Number(cfg.lsp.requestTimeoutMs);
+    if (!Number.isFinite(t) || t <= 0) {
+      console.error(
+        `[unity-mcp-server] WARN: Invalid UNITY_MCP_LSP_REQUEST_TIMEOUT_MS (${cfg.lsp.requestTimeoutMs}); using default 60000`
+      );
+      cfg.lsp.requestTimeoutMs = 60000;
+    }
   }
-} catch {}
-export const WORKSPACE_ROOT = workspaceRoot;
+}
+
+export const config = merge(baseConfig, loadEnvConfig());
+validateAndNormalizeConfig(config);
+
+// Workspace root: current working directory (used for cache/capture roots)
+export const WORKSPACE_ROOT = process.cwd();
 
 /**
  * Logger utility
@@ -224,18 +292,9 @@ export const WORKSPACE_ROOT = workspaceRoot;
  */
 export const logger = new MCPLogger(config);
 
-// Late log if external config failed to load
-if (config.__configLoadError) {
-  console.error(
-    `${baseConfig.logging.prefix} WARN: Failed to load external config: ${config.__configLoadError}`
-  );
-  delete config.__configLoadError;
-}
-
 // Startup debug log: output config info to stderr for troubleshooting
 // This helps diagnose connection issues (especially in WSL2/Docker environments)
 console.error(`[unity-mcp-server] Startup config:`);
-console.error(`[unity-mcp-server]   Config file: ${config.__configPath || '(not found)'}`);
 console.error(
   `[unity-mcp-server]   Unity host: ${config.unity.mcpHost || config.unity.unityHost || 'localhost'}`
 );

package/src/core/projectInfo.js

@@ -46,7 +46,23 @@ export class ProjectInfoProvider {
 
   async get() {
     if (this.cached) return this.cached;
-    // Config-driven project root (no env fallback)
+    // Env-driven project root override (explicit, deterministic)
+    const envRootRaw = process.env.UNITY_PROJECT_ROOT;
+    if (typeof envRootRaw === 'string' && envRootRaw.trim().length > 0) {
+      const envRoot = envRootRaw.trim();
+      const projectRoot = normalize(path.resolve(envRoot));
+      const codeIndexRoot = normalize(resolveDefaultCodeIndexRoot(projectRoot));
+      this.cached = {
+        projectRoot,
+        assetsPath: normalize(path.join(projectRoot, 'Assets')),
+        packagesPath: normalize(path.join(projectRoot, 'Packages')),
+        packageCachePath: normalize(path.join(projectRoot, 'Library/PackageCache')),
+        codeIndexRoot
+      };
+      return this.cached;
+    }
+
+    // Config-driven project root (env is mapped into config.project.root)
     const cfgRootRaw = config?.project?.root;
     if (typeof cfgRootRaw === 'string' && cfgRootRaw.trim().length > 0) {
       const cfgRoot = cfgRootRaw.trim();
@@ -61,6 +77,7 @@ export class ProjectInfoProvider {
         projectRoot,
         assetsPath: normalize(path.join(projectRoot, 'Assets')),
         packagesPath: normalize(path.join(projectRoot, 'Packages')),
+        packageCachePath: normalize(path.join(projectRoot, 'Library/PackageCache')),
         codeIndexRoot
       };
       return this.cached;
@@ -76,6 +93,9 @@ export class ProjectInfoProvider {
             projectRoot: info.projectRoot,
             assetsPath: info.assetsPath,
             packagesPath: normalize(info.packagesPath || path.join(info.projectRoot, 'Packages')),
+            packageCachePath: normalize(
+              info.packageCachePath || path.join(info.projectRoot, 'Library/PackageCache')
+            ),
             codeIndexRoot: normalize(
               info.codeIndexRoot || resolveDefaultCodeIndexRoot(info.projectRoot)
             )
@@ -96,18 +116,14 @@ export class ProjectInfoProvider {
         projectRoot,
         assetsPath: normalize(path.join(projectRoot, 'Assets')),
         packagesPath: normalize(path.join(projectRoot, 'Packages')),
+        packageCachePath: normalize(path.join(projectRoot, 'Library/PackageCache')),
         codeIndexRoot
       };
       return this.cached;
     }
 
-    if (typeof cfgRootRaw === 'string') {
-      throw new Error(
-        'project.root is configured but empty. Set a valid path in .unity/config.json.'
-      );
-    }
     throw new Error(
-      'Unable to resolve Unity project root. Start the server inside a Unity project (directory containing Assets/ and Packages/) or configure project.root in .unity/config.json.'
+      'Unable to resolve Unity project root. Start the server inside a Unity project (directory containing Assets/ and Packages/) or set UNITY_PROJECT_ROOT.'
     );
   }
 

package/src/core/server.js

@@ -91,6 +91,12 @@ async function ensureInitialized() {
 // Initialize server
 export async function startServer(options = {}) {
   try {
+    // MCP stdio transport requires stdout to stay clean (JSON-RPC only).
+    // Guard against accidental console.log usage breaking the protocol.
+    if (options.stdioEnabled !== false && process.env.UNITY_MCP_ALLOW_STDOUT !== '1') {
+      console.log = (...args) => console.error(...args);
+    }
+
     // Step 1: Load minimal config for server metadata
     // (config import is lightweight; avoid importing the MCP TS SDK on startup)
     const { config: serverConfig, logger: serverLogger } = await import('./config.js');

package/src/core/unityConnection.js

@@ -22,6 +22,7 @@ export class UnityConnection extends EventEmitter {
     this.inFlight = 0;
     this.maxInFlight = 1; // process one command at a time by default
     this.connectedAt = null; // Timestamp when connection was established
+    this.hasConnectedOnce = false;
   }
 
   /**
@@ -86,6 +87,7 @@ export class UnityConnection extends EventEmitter {
         this.connected = true;
         this.reconnectAttempts = 0;
         this.connectPromise = null;
+        this.hasConnectedOnce = true;
         this.emit('connected');
         this._pumpQueue(); // flush any queued commands that arrived during reconnect
         settle(resolve);
@@ -120,7 +122,7 @@ export class UnityConnection extends EventEmitter {
           // Destroy the socket to clean up properly
           this.socket.destroy();
           this.isDisconnecting = false;
-          reject(error);
+          reject(wrapUnityConnectError(error, targetHost, config.unity.port));
         } else if (this.connected) {
           // Force close to trigger reconnect logic
           try {
@@ -175,9 +177,11 @@ export class UnityConnection extends EventEmitter {
           this.socket.removeAllListeners();
           this.socket.destroy();
           this.connectPromise = null;
-          settle(reject, new Error('Connection timeout'));
+          const timeoutError = new Error('Connection timeout');
+          timeoutError.code = 'ETIMEDOUT';
+          settle(reject, wrapUnityConnectError(timeoutError, targetHost, config.unity.port));
         }
-      }, config.unity.commandTimeout);
+      }, config.unity.connectTimeout ?? config.unity.commandTimeout);
     });
     return this.connectPromise;
   }
@@ -361,7 +365,7 @@ export class UnityConnection extends EventEmitter {
     if (!this.connected) {
       logger.warning('[Unity] Not connected; waiting for reconnection before sending command');
       await this.ensureConnected({
-        timeoutMs: config.unity.commandTimeout
+        timeoutMs: config.unity.connectTimeout ?? config.unity.commandTimeout
       });
     }
 
@@ -518,6 +522,13 @@ export class UnityConnection extends EventEmitter {
         if (/test environment/i.test(msg)) {
           throw error;
         }
+        if (
+          !this.hasConnectedOnce &&
+          (error?.code === 'UNITY_CONNECTION_REFUSED' || error?.code === 'ECONNREFUSED')
+        ) {
+          // Fail fast for the initial connection when Unity isn't listening.
+          throw error;
+        }
       }
 
       if (this.connected) return;
@@ -525,8 +536,9 @@ export class UnityConnection extends EventEmitter {
     }
 
     if (!this.connected) {
+      const targetHost = config.unity.mcpHost || config.unity.unityHost || 'localhost';
       const error = new Error(
-        `Failed to reconnect to Unity within ${timeoutMs}ms${lastError ? `: ${lastError.message}` : ''}`
+        `Failed to connect to Unity at ${targetHost}:${config.unity.port} within ${timeoutMs}ms${lastError ? `: ${lastError.message}` : ''}`
       );
       error.code = 'UNITY_RECONNECT_TIMEOUT';
       throw error;
@@ -545,3 +557,33 @@ export class UnityConnection extends EventEmitter {
 function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, Math.max(0, ms || 0)));
 }
+
+function wrapUnityConnectError(error, host, port) {
+  const code = error?.code || '';
+  if (code === 'ECONNREFUSED') {
+    const hint = buildUnityConnectionHint(host, port);
+    const wrapped = new Error(
+      `Unity TCP connection refused (ECONNREFUSED) at ${host}:${port}. ${hint}`
+    );
+    wrapped.code = 'UNITY_CONNECTION_REFUSED';
+    wrapped.cause = error;
+    return wrapped;
+  }
+  if (code === 'ETIMEDOUT') {
+    const hint = buildUnityConnectionHint(host, port);
+    const wrapped = new Error(`Unity TCP Connection timeout at ${host}:${port}. ${hint}`);
+    wrapped.code = 'UNITY_CONNECTION_TIMEOUT';
+    wrapped.cause = error;
+    return wrapped;
+  }
+  return error;
+}
+
+function buildUnityConnectionHint(_host, _port) {
+  const configPath = config.__configPath || '.unity/config.json';
+  return (
+    `Start Unity Editor and ensure the Unity MCP package is running (TCP listener). ` +
+    `Check ${configPath} (unity.mcpHost/unity.port). ` +
+    `If using WSL2/Docker → Windows Unity, set unity.mcpHost=host.docker.internal.`
+  );
+}

package/src/core/workers/indexBuildWorker.js

@@ -15,7 +15,7 @@
  */
 
 import { parentPort, workerData } from 'worker_threads';
-import { spawn } from 'child_process';
+import { spawn, execFile } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -107,6 +107,111 @@ function walkCs(root, files, seen) {
   }
 }
 
+/**
+ * Fast file enumeration using OS native commands (find on Unix, PowerShell on Windows)
+ * Falls back to walkCs on failure
+ * @param {string[]} roots - Array of root directories to scan
+ * @returns {Promise<string[]>} Array of absolute C# file paths
+ */
+async function fastWalkCs(roots) {
+  const isWindows = process.platform === 'win32';
+  const allFiles = [];
+  const seen = new Set();
+
+  for (const root of roots) {
+    if (!fs.existsSync(root)) {
+      log('info', `[worker] Skipping non-existent root: ${root}`);
+      continue;
+    }
+
+    log('info', `[worker] Scanning ${path.basename(root)}...`);
+    const startTime = Date.now();
+
+    try {
+      const files = await new Promise((resolve, reject) => {
+        if (isWindows) {
+          // Windows: Use PowerShell (secure - no shell interpretation)
+          execFile(
+            'powershell',
+            [
+              '-NoProfile',
+              '-Command',
+              `Get-ChildItem -Path '${root.replace(/'/g, "''")}' -Recurse -Include *.cs -File -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName`
+            ],
+            { maxBuffer: 50 * 1024 * 1024 }, // 50MB buffer for large projects
+            (error, stdout) => {
+              if (error) {
+                reject(error);
+                return;
+              }
+              const files = stdout
+                .split('\r\n')
+                .map(f => f.trim())
+                .filter(f => f && f.endsWith('.cs'));
+              resolve(files);
+            }
+          );
+        } else {
+          // Unix: Use find command (secure - no shell interpretation)
+          // Note: We intentionally don't exclude hidden directories (*/.*) because:
+          // - The search root may be inside .worktrees which contains a dot
+          // - -name '*.cs' already filters to only C# files (excluding .meta etc.)
+          execFile(
+            'find',
+            [
+              root,
+              '-name',
+              '*.cs',
+              '-type',
+              'f',
+              '-not',
+              '-path',
+              '*/obj/*',
+              '-not',
+              '-path',
+              '*/bin/*'
+            ],
+            { maxBuffer: 50 * 1024 * 1024 }, // 50MB buffer for large projects
+            (error, stdout) => {
+              if (error) {
+                reject(error);
+                return;
+              }
+              const files = stdout
+                .split('\n')
+                .map(f => f.trim())
+                .filter(f => f && f.endsWith('.cs'));
+              resolve(files);
+            }
+          );
+        }
+      });
+
+      const elapsed = Date.now() - startTime;
+      log('info', `[worker] Found ${files.length} files in ${path.basename(root)} (${elapsed}ms)`);
+
+      // Add unique files
+      for (const f of files) {
+        if (!seen.has(f)) {
+          seen.add(f);
+          allFiles.push(f);
+        }
+      }
+    } catch (e) {
+      // Fallback to walkCs on error
+      log(
+        'warn',
+        `[worker] Fast scan failed for ${path.basename(root)}: ${e.message}. Using fallback.`
+      );
+      const fallbackFiles = [];
+      walkCs(root, fallbackFiles, seen);
+      allFiles.push(...fallbackFiles);
+    }
+  }
+
+  return allFiles;
+}
+
 /**
  * Convert absolute path to relative path
  */
@@ -406,7 +511,9 @@ async function runBuild() {
     concurrency: _concurrency = 1, // Reserved for future parallel processing
     throttleMs = 0,
     retry = 2,
-    reportPercentage = 10
+    reportPercentage = 10,
+    excludePackageCache = false,
+    forceRebuild = false // Skip change detection and rebuild all files
   } = workerData;
   void _concurrency; // Explicitly mark as intentionally unused
 
@@ -473,36 +580,72 @@ async function runBuild() {
     runSQL(db, 'CREATE INDEX IF NOT EXISTS idx_symbols_path ON symbols(path)');
 
     // Scan for C# files
-    const roots = [
-      path.resolve(projectRoot, 'Assets'),
-      path.resolve(projectRoot, 'Packages'),
-      path.resolve(projectRoot, 'Library/PackageCache')
-    ];
-    const files = [];
-    const seen = new Set();
-    for (const r of roots) walkCs(r, files, seen);
+    // Build roots list based on excludePackageCache option
+    const roots = [path.resolve(projectRoot, 'Assets'), path.resolve(projectRoot, 'Packages')];
+    if (!excludePackageCache) {
+      roots.push(path.resolve(projectRoot, 'Library/PackageCache'));
+    }
+    log(
+      'info',
+      `[worker] Scanning roots: ${roots.map(r => path.basename(r)).join(', ')}${excludePackageCache ? ' (PackageCache excluded)' : ''}`
+    );
 
+    // Use fast find command when available, fallback to walkCs
+    const files = await fastWalkCs(roots);
     log('info', `[worker] Found ${files.length} C# files to process`);
 
-    // Get current indexed files
-    const currentResult = querySQL(db, 'SELECT path, sig FROM files');
-    const current = new Map();
-    if (currentResult.length > 0) {
-      for (const row of currentResult[0].values) {
-        current.set(row[0], row[1]);
+    let changed = [];
+    let removed = [];
+    const wanted = new Map();
+
+    if (forceRebuild) {
+      // Skip change detection - process all files
+      log('info', `[worker] forceRebuild=true, skipping change detection`);
+      // Clear all existing data
+      runSQL(db, 'DELETE FROM symbols');
+      runSQL(db, 'DELETE FROM files');
+      // Mark all files as changed
+      for (const abs of files) {
+        const rel = toRel(abs, projectRoot);
+        wanted.set(rel, '0-0'); // Dummy signature for forceRebuild
+        changed.push(rel);
+      }
+      log('info', `[worker] All ${changed.length} files marked for processing`);
+    } else {
+      // Normal change detection
+      // Get current indexed files
+      const currentResult = querySQL(db, 'SELECT path, sig FROM files');
+      const current = new Map();
+      if (currentResult.length > 0) {
+        for (const row of currentResult[0].values) {
+          current.set(row[0], row[1]);
+        }
       }
-    }
 
-    // Determine changes
-    const wanted = new Map(files.map(abs => [toRel(abs, projectRoot), makeSig(abs)]));
-    const changed = [];
-    const removed = [];
+      // Determine changes (this calls makeSig for each file)
+      log('info', `[worker] Computing file signatures (${files.length} files)...`);
+      const sigStartTime = Date.now();
+      let sigProcessed = 0;
+      for (const abs of files) {
+        const rel = toRel(abs, projectRoot);
+        const sig = makeSig(abs);
+        wanted.set(rel, sig);
+        sigProcessed++;
+        // Report progress every 10000 files
+        if (sigProcessed % 10000 === 0) {
+          const elapsed = ((Date.now() - sigStartTime) / 1000).toFixed(1);
+          log('info', `[worker] Signature progress: ${sigProcessed}/${files.length} (${elapsed}s)`);
+        }
+      }
+      const sigTime = ((Date.now() - sigStartTime) / 1000).toFixed(1);
+      log('info', `[worker] Signatures computed in ${sigTime}s`);
 
-    for (const [rel, sig] of wanted) {
-      if (current.get(rel) !== sig) changed.push(rel);
-    }
-    for (const [rel] of current) {
-      if (!wanted.has(rel)) removed.push(rel);
+      for (const [rel, sig] of wanted) {
+        if (current.get(rel) !== sig) changed.push(rel);
+      }
+      for (const [rel] of current) {
+        if (!wanted.has(rel)) removed.push(rel);
+      }
     }
 
     log('info', `[worker] Changes: ${changed.length} to update, ${removed.length} to remove`);

package/src/handlers/scene/SceneCreateToolHandler.js

@@ -64,17 +64,16 @@ export class SceneCreateToolHandler extends BaseToolHandler {
     // Send command to Unity
     const result = await this.unityConnection.sendCommand('create_scene', params);
 
-    // Check for Unity-side errors
-    if (result.status === 'error') {
+    // Unity returns errors as { error: "..." } payloads (still wrapped in a success response)
+    if (result && result.error) {
       const error = new Error(result.error);
       error.code = 'UNITY_ERROR';
       throw error;
     }
 
-    // Handle undefined or null results from Unity
-    if (result.result === undefined || result.result === null) {
+    // Handle undefined or null results from Unity (best-effort)
+    if (result === undefined || result === null) {
       return {
-        status: 'success',
         sceneName: params.sceneName,
         path: params.path || 'Assets/Scenes/',
         loadScene: params.loadScene !== false,
@@ -83,6 +82,6 @@ export class SceneCreateToolHandler extends BaseToolHandler {
       };
     }
 
-    return result.result;
+    return result;
   }
 }

package/src/handlers/scene/SceneLoadToolHandler.js

@@ -67,17 +67,16 @@ export class SceneLoadToolHandler extends BaseToolHandler {
     // Send command to Unity
     const result = await this.unityConnection.sendCommand('load_scene', params);
 
-    // Check for Unity-side errors
-    if (result.status === 'error') {
+    // Unity returns errors as { error: "..." } payloads (still wrapped in a success response)
+    if (result && result.error) {
       const error = new Error(result.error);
       error.code = 'UNITY_ERROR';
       throw error;
     }
 
-    // Handle undefined or null results from Unity
-    if (result.result === undefined || result.result === null) {
+    // Handle undefined or null results from Unity (best-effort)
+    if (result === undefined || result === null) {
       return {
-        status: 'success',
         sceneName: params.sceneName || 'Unknown',
         scenePath: params.scenePath || 'Unknown',
         loadMode: params.loadMode || 'Single',
@@ -85,6 +84,6 @@ export class SceneLoadToolHandler extends BaseToolHandler {
       };
     }
 
-    return result.result;
+    return result;
   }
 }

package/src/handlers/scene/SceneSaveToolHandler.js

@@ -51,23 +51,22 @@ export class SceneSaveToolHandler extends BaseToolHandler {
     // Send command to Unity
     const result = await this.unityConnection.sendCommand('save_scene', params);
 
-    // Check for Unity-side errors
-    if (result.status === 'error') {
+    // Unity returns errors as { error: "..." } payloads (still wrapped in a success response)
+    if (result && result.error) {
       const error = new Error(result.error);
       error.code = 'UNITY_ERROR';
       throw error;
     }
 
-    // Handle undefined or null results from Unity
-    if (result.result === undefined || result.result === null) {
+    // Handle undefined or null results from Unity (best-effort)
+    if (result === undefined || result === null) {
       return {
-        status: 'success',
         scenePath: params.scenePath || 'Current scene path',
         saveAs: params.saveAs === true,
         message: 'Scene save completed but Unity returned no details'
       };
     }
 
-    return result.result;
+    return result;
   }
 }

package/src/handlers/script/CodeIndexBuildToolHandler.js

@@ -23,6 +23,11 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
             minimum: 0,
             maximum: 5,
             description: 'Number of retries for LSP requests (default: 2).'
+          },
+          excludePackageCache: {
+            type: 'boolean',
+            description:
+              'Exclude Library/PackageCache from indexing (default: false). Set to true for faster builds when package symbols are not needed.'
           }
         },
         required: []
@@ -54,7 +59,8 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
       return {
         success: false,
         error: 'build_already_running',
-        message: 'Code index build is already running (Worker Thread). Use code_index_status to check progress.',
+        message:
+          'Code index build is already running (Worker Thread). Use code_index_status to check progress.',
         jobId: this.currentJobId
       };
     }
@@ -86,7 +92,8 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
           concurrency: 1, // Worker Thread uses sequential processing for stability
           throttleMs: Math.max(0, Number(params?.throttleMs ?? 0)),
           retry: Math.max(0, Math.min(5, Number(params?.retry ?? 2))),
-          reportPercentage: 10
+          reportPercentage: 10,
+          excludePackageCache: Boolean(params?.excludePackageCache)
         });
 
         // Clear current job tracking on success

package/src/handlers/script/ScriptRefsFindToolHandler.js

@@ -213,42 +213,48 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
       }
     }
 
-    // Phase 3.2: Build pathTable for deduplication (62% size reduction)
-    const pathSet = new Set();
-    for (const [p] of perFile) {
-      pathSet.add(p);
-    }
-    const pathTable = [...pathSet];
-    const pathIndex = new Map(pathTable.map((p, i) => [p, i]));
-
-    // Pagination and byte limits with compact format
+    // Phase 3.3: Grouped output format (more compact, LLM-friendly)
+    // Pagination and byte limits with grouped format
     const results = [];
     let bytes = 0;
+    let total = 0;
+    let truncated = false;
+
     for (const [filePath, arr] of perFile) {
-      const fileId = pathIndex.get(filePath);
+      const references = [];
       for (const it of arr) {
-        // Compact format: fileId reference + only essential fields
-        const compact = {
-          fileId,
+        const ref = {
           line: it.line,
           column: it.column,
           snippet: it.snippet
         };
-        const json = JSON.stringify(compact);
-        const size = Buffer.byteLength(json, 'utf8');
-        if (results.length >= pageSize || bytes + size > maxBytes) {
-          return { success: true, pathTable, results, total: results.length, truncated: true };
+        const refJson = JSON.stringify(ref);
+        const refSize = Buffer.byteLength(refJson, 'utf8');
+
+        // Check limits before adding
+        if (total >= pageSize || bytes + refSize > maxBytes) {
+          truncated = true;
+          break;
         }
-        results.push(compact);
-        bytes += size;
+        references.push(ref);
+        bytes += refSize;
+        total++;
       }
+
+      if (references.length > 0) {
+        results.push({ path: filePath, references });
+      }
+
+      if (truncated) break;
     }
 
     // Edge case: extreme limits
     const extremeLimits = pageSize <= 1 || maxBytes <= 1;
-    const truncated = extremeLimits && results.length === 0 ? true : false;
+    if (extremeLimits && results.length === 0) {
+      truncated = true;
+    }
 
-    return { success: true, pathTable, results, total: results.length, truncated };
+    return { success: true, results, total, truncated };
   }
 }
 

package/src/handlers/script/ScriptSearchToolHandler.js

@@ -8,7 +8,7 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'script_search',
-      '[OFFLINE] No Unity connection required. Search C# by substring/regex/glob with pagination and snippet context. PRIORITY: Use to locate symbols/files; avoid full contents. Use returnMode="snippets" (or "metadata") with small snippetContext (1–2). Narrow aggressively via include globs under Assets/** or Packages/** and semantic filters (namespace/container/identifier). Do NOT prefix repository folders.',
+      '[OFFLINE] No Unity connection required. Search C# by substring/regex/glob with pagination and snippet context. PRIORITY: Use to locate symbols/files; avoid full contents. Use returnMode="snippets" (or "metadata") with small snippetContext (1–2). Narrow aggressively via include globs under Assets/**, Packages/**, or Library/PackageCache/** and semantic filters (namespace/container/identifier). Do NOT prefix repository folders.',
       {
         type: 'object',
         properties: {
@@ -29,9 +29,9 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
           },
           scope: {
             type: 'string',
-            enum: ['assets', 'packages', 'embedded', 'all'],
+            enum: ['assets', 'packages', 'embedded', 'library', 'all'],
             description:
-              'Search scope: assets (Assets/, default), packages (Packages/), embedded, or all.'
+              'Search scope: assets (Assets/), packages (Packages/), embedded, library (Library/PackageCache/), or all. Default: all.'
           },
           include: {
             type: 'string',
@@ -151,6 +151,7 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
       if (scope === 'assets' || scope === 'all') roots.push(info.assetsPath);
       if (scope === 'packages' || scope === 'embedded' || scope === 'all')
         roots.push(info.packagesPath);
+      if (scope === 'library' || scope === 'all') roots.push(info.packageCachePath);
 
       const includeRx = globToRegExp(include);
       const excludeRx = exclude ? globToRegExp(exclude) : null;
@@ -160,9 +161,8 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
       }
       const matcher = buildMatcher(patternType, pattern, flags);
 
+      // Phase 3.3: Grouped output format (more compact, LLM-friendly)
       const results = [];
-      const pathTable = [];
-      const pathId = new Map();
       let bytes = 0;
       let afterFound = !startAfter;
 
@@ -199,13 +199,8 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
         }
         if (matches === 0) continue;
 
-        const id = pathId.has(rel)
-          ? pathId.get(rel)
-          : (pathTable.push(rel) - 1, pathTable.length - 1);
-        pathId.set(rel, id);
-
         const lineRanges = toRanges(matchedLines);
-        const item = { fileId: id, lineRanges };
+        const item = { path: rel, lineRanges };
 
         if (normalizedReturnMode === 'snippets') {
           // Build minimal snippets around first few matches
@@ -228,10 +223,9 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
       return {
         success: true,
         total: results.length,
-        pathTable,
         results,
         cursor:
-          results.length && results.length >= pageSize ? pathTable[pathTable.length - 1] : null
+          results.length && results.length >= pageSize ? results[results.length - 1].path : null
       };
     } catch (e) {
       logger.error(`[script_search] failed: ${e.message}`);

package/src/handlers/script/ScriptSymbolFindToolHandler.js

@@ -22,7 +22,7 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
             type: 'string',
             enum: ['assets', 'packages', 'embedded', 'all'],
             description:
-              'Search scope: assets (Assets/), packages (Packages/), embedded, or all (default: all).'
+              'Search scope: assets (Assets/), packages (Packages/), embedded, or all (default: assets).'
           },
           exact: {
             type: 'boolean',
@@ -110,18 +110,15 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
       filteredRows = filteredRows.filter(r => r.name === target);
     }
 
-    // Phase 3.1: Optimized output format with pathTable (60% size reduction)
-    // Build pathTable for deduplication
-    const pathSet = new Set();
+    // Phase 3.2: Grouped output format (40% more compact than pathTable)
+    // Group symbols by file path
+    const grouped = new Map();
+    let total = 0;
     for (const r of filteredRows) {
-      pathSet.add((r.path || '').replace(/\\/g, '/'));
-    }
-    const pathTable = [...pathSet];
-    const pathIndex = new Map(pathTable.map((p, i) => [p, i]));
-
-    // Build compact results with fileId reference
-    const results = filteredRows.map(r => {
       const p = (r.path || '').replace(/\\/g, '/');
+      if (!grouped.has(p)) {
+        grouped.set(p, []);
+      }
       const symbol = {
         name: r.name,
         kind: r.kind,
@@ -131,10 +128,16 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
       // Only include non-null optional fields
       if (r.ns) symbol.namespace = r.ns;
       if (r.container) symbol.container = r.container;
+      grouped.get(p).push(symbol);
+      total++;
+    }
 
-      return { fileId: pathIndex.get(p), symbol };
-    });
+    // Convert to array format
+    const results = [];
+    for (const [path, symbols] of grouped) {
+      results.push({ path, symbols });
+    }
 
-    return { success: true, pathTable, results, total: results.length };
+    return { success: true, results, total };
   }
 }

package/src/handlers/ui/UIFindElementsToolHandler.js

@@ -24,6 +24,10 @@ export class UIFindElementsToolHandler extends BaseToolHandler {
         canvasFilter: {
           type: 'string',
           description: 'Filter by parent Canvas name.'
+        },
+        uiSystem: {
+          type: 'string',
+          description: 'Filter by UI system: ugui|uitk|imgui|all (default: all).'
         }
       },
       required: []
@@ -32,7 +36,14 @@ export class UIFindElementsToolHandler extends BaseToolHandler {
   }
 
   async execute(params = {}) {
-    const { elementType, tagFilter, namePattern, includeInactive = false, canvasFilter } = params;
+    const {
+      elementType,
+      tagFilter,
+      namePattern,
+      includeInactive = false,
+      canvasFilter,
+      uiSystem
+    } = params;
 
     // Ensure connected
     if (!this.unityConnection.isConnected()) {
@@ -44,7 +55,8 @@ export class UIFindElementsToolHandler extends BaseToolHandler {
       tagFilter,
       namePattern,
       includeInactive,
-      canvasFilter
+      canvasFilter,
+      uiSystem
     });
 
     // Return the result for the BaseToolHandler to format

package/src/tools/analysis/getComponentValues.js

@@ -106,14 +106,10 @@ export async function getComponentValuesHandler(unityConnection, args) {
       };
     }
 
-    // Success response - result is already the unwrapped data
-    console.log('[DEBUG] GetComponentValues - Full result:', JSON.stringify(result, null, 2));
-
     let responseText = result.summary || `Component values retrieved`;
 
     // Add detailed property information if available
     if (result.properties && Object.keys(result.properties).length > 0) {
-      console.log('[DEBUG] Properties found:', Object.keys(result.properties).length);
       responseText += '\n\nProperties:';
       for (const [key, value] of Object.entries(result.properties)) {
         if (value && typeof value === 'object') {
@@ -144,9 +140,6 @@ export async function getComponentValuesHandler(unityConnection, args) {
           }
         }
       }
-    } else {
-      console.log('[DEBUG] No properties found in result');
-      console.log('[DEBUG] Result keys:', Object.keys(result));
     }
 
     // Add debug information if available

package/src/tools/scene/getSceneInfo.js

@@ -57,10 +57,10 @@ export async function getSceneInfoHandler(unityConnection, args) {
     }
 
     // Send command to Unity
-    const result = await unityConnection.sendCommand('scene_info_get', args);
+    const result = await unityConnection.sendCommand('get_scene_info', args);
 
-    // Handle Unity response
-    if (result.status === 'error') {
+    // Unity returns errors as { error: "..." } payloads (still wrapped in a success response)
+    if (result && result.error) {
       return {
         content: [
           {
@@ -77,7 +77,7 @@ export async function getSceneInfoHandler(unityConnection, args) {
       content: [
         {
           type: 'text',
-          text: result.result.summary || `Scene information retrieved`
+          text: result?.summary || `Scene information retrieved`
         }
       ],
       isError: false