uloop-cli 0.64.1 → 0.66.0

package/dist/cli.bundle.cjs

@@ -5383,8 +5383,8 @@ var require_semver2 = __commonJS({
 });
 
 // src/cli.ts
-var import_fs6 = require("fs");
-var import_path7 = require("path");
+var import_fs7 = require("fs");
+var import_path8 = require("path");
 var import_os2 = require("os");
 var import_child_process = require("child_process");
 
@@ -5407,8 +5407,8 @@ var {
 
 // src/execute-tool.ts
 var readline = __toESM(require("readline"), 1);
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 var semver = __toESM(require_semver2(), 1);
 
 // src/direct-unity-client.ts
@@ -5486,13 +5486,13 @@ var DirectUnityClient = class {
   requestId = 0;
   receiveBuffer = Buffer.alloc(0);
   async connect() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       this.socket = new net.Socket();
       this.socket.on("error", (error) => {
         reject(new Error(`Connection error: ${error.message}`));
       });
       this.socket.connect(this.port, this.host, () => {
-        resolve5();
+        resolve6();
       });
     });
   }
@@ -5508,9 +5508,16 @@ var DirectUnityClient = class {
     };
     const requestJson = JSON.stringify(request);
     const framedMessage = createFrame(requestJson);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const socket = this.socket;
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        socket.off("data", onData);
+        socket.off("error", onError);
+        socket.off("close", onClose);
+      };
       const timeoutId = setTimeout(() => {
+        cleanup();
         reject(
           new Error(
             `Request timed out after ${NETWORK_TIMEOUT_MS}ms. Unity may be frozen or busy. [For AI] Run 'uloop focus-window' to bring Unity to the front, then retry the tool. If the issue persists, report this to the user and ask how to proceed. Do NOT kill Unity processes without user permission.`
@@ -5531,17 +5538,26 @@ var DirectUnityClient = class {
         if (extractResult.jsonContent === null) {
           return;
         }
-        clearTimeout(timeoutId);
-        socket.off("data", onData);
+        cleanup();
         this.receiveBuffer = extractResult.remainingData;
         const response = JSON.parse(extractResult.jsonContent);
         if (response.error) {
           reject(new Error(`Unity error: ${response.error.message}`));
           return;
         }
-        resolve5(response.result);
+        resolve6(response.result);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(new Error(`Connection lost: ${error.message}`));
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("UNITY_NO_RESPONSE"));
       };
       socket.on("data", onData);
+      socket.on("error", onError);
+      socket.on("close", onClose);
       socket.write(framedMessage);
     });
   }
@@ -5743,13 +5759,41 @@ function resolvePortFromUnitySettings(settings) {
   }
   return null;
 }
-async function resolveUnityPort(explicitPort) {
+function validateProjectPath(projectPath) {
+  const resolved = (0, import_path2.resolve)(projectPath);
+  if (!(0, import_fs2.existsSync)(resolved)) {
+    throw new Error(`Path does not exist: ${resolved}`);
+  }
+  if (!isUnityProject(resolved)) {
+    throw new Error(`Not a Unity project (Assets/ or ProjectSettings/ not found): ${resolved}`);
+  }
+  if (!hasUloopInstalled(resolved)) {
+    throw new Error(
+      `uLoopMCP is not installed in this project (UserSettings/UnityMcpSettings.json not found): ${resolved}`
+    );
+  }
+  return resolved;
+}
+async function resolveUnityPort(explicitPort, projectPath) {
+  if (explicitPort !== void 0 && projectPath !== void 0) {
+    throw new Error("Cannot specify both --port and --project-path. Use one or the other.");
+  }
   if (explicitPort !== void 0) {
     return explicitPort;
   }
+  if (projectPath !== void 0) {
+    const resolved = validateProjectPath(projectPath);
+    const settingsPort2 = await readPortFromSettings(resolved);
+    if (settingsPort2 !== null) {
+      return settingsPort2;
+    }
+    return DEFAULT_PORT;
+  }
   const projectRoot = findUnityProjectRoot();
   if (projectRoot === null) {
-    throw new Error("Unity project not found. Use --port option to specify the port explicitly.");
+    throw new Error(
+      "Unity project not found. Use --port or --project-path option to specify the target."
+    );
   }
   const settingsPort = await readPortFromSettings(projectRoot);
   if (settingsPort !== null) {
@@ -5783,7 +5827,7 @@ var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.64.1",
+  version: "0.66.0",
   tools: [
     {
       name: "compile",
@@ -5794,6 +5838,10 @@ var default_tools_default = {
           ForceRecompile: {
             type: "boolean",
             description: "Force full recompilation"
+          },
+          WaitForDomainReload: {
+            type: "boolean",
+            description: "Wait for domain reload completion before returning"
           }
         }
       }
@@ -6227,7 +6275,7 @@ function getCachedServerVersion() {
 }
 
 // src/version.ts
-var VERSION = "0.64.1";
+var VERSION = "0.66.0";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -6261,6 +6309,206 @@ function createSpinner(initialMessage) {
   };
 }
 
+// src/compile-helpers.ts
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_fs4 = require("fs");
+var net2 = __toESM(require("net"), 1);
+var import_path4 = require("path");
+var SAFE_REQUEST_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var COMPILE_FORCE_RECOMPILE_ARG_KEYS = [
+  "ForceRecompile",
+  "forceRecompile",
+  "force_recompile",
+  "force-recompile"
+];
+var COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS = [
+  "WaitForDomainReload",
+  "waitForDomainReload",
+  "wait_for_domain_reload",
+  "wait-for-domain-reload"
+];
+var LOCK_GRACE_PERIOD_MS = 500;
+var READINESS_CHECK_TIMEOUT_MS = 3e3;
+var DEFAULT_HOST2 = "127.0.0.1";
+var CONTENT_LENGTH_HEADER2 = "Content-Length:";
+var HEADER_SEPARATOR2 = "\r\n\r\n";
+function toBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.toLowerCase() === "true";
+  }
+  return false;
+}
+function getCompileBooleanArg(args, keys) {
+  for (const key of keys) {
+    if (!(key in args)) {
+      continue;
+    }
+    return toBoolean(args[key]);
+  }
+  return false;
+}
+function resolveCompileExecutionOptions(args) {
+  return {
+    forceRecompile: getCompileBooleanArg(args, COMPILE_FORCE_RECOMPILE_ARG_KEYS),
+    waitForDomainReload: getCompileBooleanArg(args, COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS)
+  };
+}
+function createCompileRequestId() {
+  const timestamp = Date.now();
+  const randomToken = Math.floor(Math.random() * 1e6).toString().padStart(6, "0");
+  return `compile_${timestamp}_${randomToken}`;
+}
+function ensureCompileRequestId(args) {
+  const existingRequestId = args["RequestId"];
+  if (typeof existingRequestId === "string" && existingRequestId.length > 0) {
+    if (SAFE_REQUEST_ID_PATTERN.test(existingRequestId)) {
+      return existingRequestId;
+    }
+  }
+  const requestId = createCompileRequestId();
+  args["RequestId"] = requestId;
+  return requestId;
+}
+function getCompileResultFilePath(projectRoot, requestId) {
+  (0, import_node_assert.default)(
+    SAFE_REQUEST_ID_PATTERN.test(requestId),
+    `requestId contains unsafe characters: '${requestId}'`
+  );
+  return (0, import_path4.join)(projectRoot, "Temp", "uLoopMCP", "compile-results", `${requestId}.json`);
+}
+function isUnityBusyByLockFiles(projectRoot) {
+  const compilingLockPath = (0, import_path4.join)(projectRoot, "Temp", "compiling.lock");
+  if ((0, import_fs4.existsSync)(compilingLockPath)) {
+    return true;
+  }
+  const domainReloadLockPath = (0, import_path4.join)(projectRoot, "Temp", "domainreload.lock");
+  if ((0, import_fs4.existsSync)(domainReloadLockPath)) {
+    return true;
+  }
+  const serverStartingLockPath = (0, import_path4.join)(projectRoot, "Temp", "serverstarting.lock");
+  return (0, import_fs4.existsSync)(serverStartingLockPath);
+}
+function stripUtf8Bom(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+function tryReadCompileResult(projectRoot, requestId) {
+  const resultFilePath = getCompileResultFilePath(projectRoot, requestId);
+  if (!(0, import_fs4.existsSync)(resultFilePath)) {
+    return void 0;
+  }
+  try {
+    const content = (0, import_fs4.readFileSync)(resultFilePath, "utf-8");
+    const parsed = JSON.parse(stripUtf8Bom(content));
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function canSendRequestToUnity(port) {
+  return new Promise((resolve6) => {
+    const socket = new net2.Socket();
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve6(false);
+    }, READINESS_CHECK_TIMEOUT_MS);
+    const cleanup = () => {
+      clearTimeout(timer);
+      socket.destroy();
+    };
+    socket.connect(port, DEFAULT_HOST2, () => {
+      const rpcRequest = JSON.stringify({
+        jsonrpc: "2.0",
+        method: "get-tool-details",
+        params: { IncludeDevelopmentOnly: false },
+        id: 0
+      });
+      const contentLength = Buffer.byteLength(rpcRequest, "utf8");
+      const frame = `${CONTENT_LENGTH_HEADER2} ${contentLength}${HEADER_SEPARATOR2}${rpcRequest}`;
+      socket.write(frame);
+    });
+    let buffer = Buffer.alloc(0);
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      const sepIndex = buffer.indexOf(HEADER_SEPARATOR2);
+      if (sepIndex !== -1) {
+        cleanup();
+        resolve6(true);
+      }
+    });
+    socket.on("error", () => {
+      cleanup();
+      resolve6(false);
+    });
+    socket.on("close", () => {
+      clearTimeout(timer);
+      resolve6(false);
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+async function waitForCompileCompletion(options) {
+  const startTime = Date.now();
+  let idleSinceTimestamp = null;
+  while (Date.now() - startTime < options.timeoutMs) {
+    const result = tryReadCompileResult(options.projectRoot, options.requestId);
+    const isBusy = isUnityBusyByLockFiles(options.projectRoot);
+    if (result !== void 0 && !isBusy) {
+      const now = Date.now();
+      if (idleSinceTimestamp === null) {
+        idleSinceTimestamp = now;
+      }
+      const idleDuration = now - idleSinceTimestamp;
+      if (idleDuration >= LOCK_GRACE_PERIOD_MS) {
+        if (options.unityPort !== void 0) {
+          const isReady = await canSendRequestToUnity(options.unityPort);
+          if (isReady) {
+            return { outcome: "completed", result };
+          }
+        } else if (options.isUnityReadyWhenIdle) {
+          const isReady = await options.isUnityReadyWhenIdle();
+          if (isReady) {
+            return { outcome: "completed", result };
+          }
+        } else {
+          return { outcome: "completed", result };
+        }
+      }
+    } else {
+      idleSinceTimestamp = null;
+    }
+    await sleep(options.pollIntervalMs);
+  }
+  const lastResult = tryReadCompileResult(options.projectRoot, options.requestId);
+  if (lastResult !== void 0 && !isUnityBusyByLockFiles(options.projectRoot)) {
+    await sleep(LOCK_GRACE_PERIOD_MS);
+    if (isUnityBusyByLockFiles(options.projectRoot)) {
+      return { outcome: "timed_out" };
+    }
+    if (options.unityPort !== void 0) {
+      const isReady = await canSendRequestToUnity(options.unityPort);
+      if (isReady) {
+        return { outcome: "completed", result: lastResult };
+      }
+    } else if (options.isUnityReadyWhenIdle) {
+      const isReady = await options.isUnityReadyWhenIdle();
+      if (isReady) {
+        return { outcome: "completed", result: lastResult };
+      }
+    } else {
+      return { outcome: "completed", result: lastResult };
+    }
+  }
+  return { outcome: "timed_out" };
+}
+
 // src/execute-tool.ts
 function suppressStdinEcho() {
   if (!process.stdin.isTTY) {
@@ -6287,10 +6535,23 @@ function suppressStdinEcho() {
     rl.close();
   };
 }
+function stripInternalFields(result) {
+  const cleaned = { ...result };
+  delete cleaned["ProjectRoot"];
+  return cleaned;
+}
 var RETRY_DELAY_MS = 500;
 var MAX_RETRIES = 3;
-function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+var COMPILE_WAIT_TIMEOUT_MS = 9e4;
+var COMPILE_WAIT_POLL_INTERVAL_MS = 100;
+function getCompileExecutionOptions(toolName, params) {
+  if (toolName !== "compile") {
+    return {
+      forceRecompile: false,
+      waitForDomainReload: false
+    };
+  }
+  return resolveCompileExecutionOptions(params);
 }
 function isRetryableError(error) {
   if (!(error instanceof Error)) {
@@ -6299,6 +6560,13 @@ function isRetryableError(error) {
   const message = error.message;
   return message.includes("ECONNREFUSED") || message.includes("EADDRNOTAVAIL") || message === "UNITY_NO_RESPONSE";
 }
+function isTransportDisconnectError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message;
+  return message === "UNITY_NO_RESPONSE" || message.startsWith("Connection lost:");
+}
 function isVersionOlder(v1, v2) {
   const parsed1 = semver.valid(v1);
   const parsed2 = semver.valid(v2);
@@ -6325,21 +6593,21 @@ function checkServerVersion(result) {
     printVersionWarning(VERSION, serverVersion);
   }
 }
-function checkUnityBusyState() {
-  const projectRoot = findUnityProjectRoot();
+function checkUnityBusyState(projectPath) {
+  const projectRoot = projectPath !== void 0 ? validateProjectPath(projectPath) : findUnityProjectRoot();
   if (projectRoot === null) {
     return;
   }
-  const compilingLock = (0, import_path4.join)(projectRoot, "Temp", "compiling.lock");
-  if ((0, import_fs4.existsSync)(compilingLock)) {
+  const compilingLock = (0, import_path5.join)(projectRoot, "Temp", "compiling.lock");
+  if ((0, import_fs5.existsSync)(compilingLock)) {
     throw new Error("UNITY_COMPILING");
   }
-  const domainReloadLock = (0, import_path4.join)(projectRoot, "Temp", "domainreload.lock");
-  if ((0, import_fs4.existsSync)(domainReloadLock)) {
+  const domainReloadLock = (0, import_path5.join)(projectRoot, "Temp", "domainreload.lock");
+  if ((0, import_fs5.existsSync)(domainReloadLock)) {
     throw new Error("UNITY_DOMAIN_RELOAD");
   }
-  const serverStartingLock = (0, import_path4.join)(projectRoot, "Temp", "serverstarting.lock");
-  if ((0, import_fs4.existsSync)(serverStartingLock)) {
+  const serverStartingLock = (0, import_path5.join)(projectRoot, "Temp", "serverstarting.lock");
+  if ((0, import_fs5.existsSync)(serverStartingLock)) {
     throw new Error("UNITY_SERVER_STARTING");
   }
 }
@@ -6352,28 +6620,48 @@ async function executeToolCommand(toolName, params, globalOptions) {
     }
     portNumber = parsed;
   }
-  const port = await resolveUnityPort(portNumber);
+  const port = await resolveUnityPort(portNumber, globalOptions.projectPath);
+  const compileOptions = getCompileExecutionOptions(toolName, params);
+  const shouldWaitForDomainReload = compileOptions.waitForDomainReload;
+  const compileRequestId = shouldWaitForDomainReload ? ensureCompileRequestId(params) : void 0;
   const restoreStdin = suppressStdinEcho();
   const spinner = createSpinner("Connecting to Unity...");
   let lastError;
+  let immediateResult;
+  const projectRoot = globalOptions.projectPath !== void 0 ? validateProjectPath(globalOptions.projectPath) : findUnityProjectRoot();
+  let requestDispatched = false;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    checkUnityBusyState();
+    checkUnityBusyState(globalOptions.projectPath);
     const client = new DirectUnityClient(port);
     try {
       await client.connect();
       spinner.update(`Executing ${toolName}...`);
+      requestDispatched = true;
       const result = await client.sendRequest(toolName, params);
       if (result === void 0 || result === null) {
         throw new Error("UNITY_NO_RESPONSE");
       }
-      spinner.stop();
-      restoreStdin();
-      checkServerVersion(result);
-      console.log(JSON.stringify(result, null, 2));
-      return;
+      immediateResult = result;
+      if (!shouldWaitForDomainReload) {
+        spinner.stop();
+        restoreStdin();
+        checkServerVersion(result);
+        console.log(JSON.stringify(stripInternalFields(result), null, 2));
+        return;
+      }
+      break;
     } catch (error) {
       lastError = error;
       client.disconnect();
+      if (requestDispatched && shouldWaitForDomainReload) {
+        if (isTransportDisconnectError(error)) {
+          spinner.update("Connection lost during compile. Waiting for result file...");
+          break;
+        }
+        spinner.stop();
+        restoreStdin();
+        throw error instanceof Error ? error : new Error(String(error));
+      }
       if (!isRetryableError(error) || attempt >= MAX_RETRIES) {
         break;
       }
@@ -6383,9 +6671,70 @@ async function executeToolCommand(toolName, params, globalOptions) {
       client.disconnect();
     }
   }
+  if (shouldWaitForDomainReload && compileRequestId) {
+    if (immediateResult === void 0 && !requestDispatched) {
+      spinner.stop();
+      restoreStdin();
+      if (lastError instanceof Error) {
+        throw lastError;
+      }
+      throw new Error(
+        "Compile request never reached Unity. Check that Unity is running and retry."
+      );
+    }
+    const projectRootFromUnity = immediateResult !== void 0 ? immediateResult["ProjectRoot"] : void 0;
+    const effectiveProjectRoot = projectRootFromUnity ?? projectRoot;
+    if (effectiveProjectRoot === null) {
+      spinner.stop();
+      restoreStdin();
+      if (immediateResult !== void 0) {
+        checkServerVersion(immediateResult);
+        console.log(JSON.stringify(stripInternalFields(immediateResult), null, 2));
+        return;
+      }
+      if (lastError instanceof Error) {
+        throw lastError;
+      }
+      throw new Error(
+        "Compile request failed and project root is unknown. Check connection and retry."
+      );
+    }
+    spinner.update("Waiting for domain reload to complete...");
+    const { outcome, result: storedResult } = await waitForCompileCompletion({
+      projectRoot: effectiveProjectRoot,
+      requestId: compileRequestId,
+      timeoutMs: COMPILE_WAIT_TIMEOUT_MS,
+      pollIntervalMs: COMPILE_WAIT_POLL_INTERVAL_MS,
+      unityPort: port
+    });
+    if (outcome === "timed_out") {
+      lastError = new Error(
+        `Compile wait timed out after ${COMPILE_WAIT_TIMEOUT_MS}ms. Run 'uloop fix' and retry.`
+      );
+    } else {
+      const finalResult = storedResult ?? immediateResult;
+      if (finalResult !== void 0) {
+        spinner.stop();
+        restoreStdin();
+        checkServerVersion(finalResult);
+        console.log(JSON.stringify(stripInternalFields(finalResult), null, 2));
+        return;
+      }
+    }
+  }
   spinner.stop();
   restoreStdin();
-  throw lastError;
+  if (lastError === void 0) {
+    throw new Error("Tool execution failed without error details.");
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  if (typeof lastError === "string") {
+    throw new Error(lastError);
+  }
+  const serializedError = JSON.stringify(lastError);
+  throw new Error(serializedError ?? "Unknown error");
 }
 async function listAvailableTools(globalOptions) {
   let portNumber;
@@ -6396,12 +6745,12 @@ async function listAvailableTools(globalOptions) {
     }
     portNumber = parsed;
   }
-  const port = await resolveUnityPort(portNumber);
+  const port = await resolveUnityPort(portNumber, globalOptions.projectPath);
   const restoreStdin = suppressStdinEcho();
   const spinner = createSpinner("Connecting to Unity...");
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    checkUnityBusyState();
+    checkUnityBusyState(globalOptions.projectPath);
     const client = new DirectUnityClient(port);
     try {
       await client.connect();
@@ -6453,12 +6802,12 @@ async function syncTools(globalOptions) {
     }
     portNumber = parsed;
   }
-  const port = await resolveUnityPort(portNumber);
+  const port = await resolveUnityPort(portNumber, globalOptions.projectPath);
   const restoreStdin = suppressStdinEcho();
   const spinner = createSpinner("Connecting to Unity...");
   let lastError;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    checkUnityBusyState();
+    checkUnityBusyState(globalOptions.projectPath);
     const client = new DirectUnityClient(port);
     try {
       await client.connect();
@@ -6515,8 +6864,8 @@ function pascalToKebabCase(pascal) {
 }
 
 // src/skills/skills-manager.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 var import_os = require("os");
 
 // src/skills/deprecated-skills.ts
@@ -6563,7 +6912,7 @@ var SkillsPathConstants = class _SkillsPathConstants {
   ];
 };
 function getGlobalSkillsDir(target) {
-  return (0, import_path5.join)((0, import_os.homedir)(), target.projectDir, "skills");
+  return (0, import_path6.join)((0, import_os.homedir)(), target.projectDir, "skills");
 }
 function getProjectSkillsDir(target) {
   const status = getUnityProjectStatus();
@@ -6578,35 +6927,35 @@ function getProjectSkillsDir(target) {
 Please install uLoopMCP package first, then run this command again.`
     );
   }
-  return (0, import_path5.join)(status.path, target.projectDir, "skills");
+  return (0, import_path6.join)(status.path, target.projectDir, "skills");
 }
 function getSkillPath(skillDirName, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  return (0, import_path5.join)(baseDir, skillDirName, target.skillFileName);
+  return (0, import_path6.join)(baseDir, skillDirName, target.skillFileName);
 }
 function isSkillInstalled(skill, target, global) {
   const skillPath = getSkillPath(skill.dirName, target, global);
-  return (0, import_fs5.existsSync)(skillPath);
+  return (0, import_fs6.existsSync)(skillPath);
 }
 function isSkillOutdated(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
-  const skillPath = (0, import_path5.join)(skillDir, target.skillFileName);
-  if (!(0, import_fs5.existsSync)(skillPath)) {
+  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
+  const skillPath = (0, import_path6.join)(skillDir, target.skillFileName);
+  if (!(0, import_fs6.existsSync)(skillPath)) {
     return false;
   }
-  const installedContent = (0, import_fs5.readFileSync)(skillPath, "utf-8");
+  const installedContent = (0, import_fs6.readFileSync)(skillPath, "utf-8");
   if (installedContent !== skill.content) {
     return true;
   }
   if ("additionalFiles" in skill && skill.additionalFiles) {
     const additionalFiles = skill.additionalFiles;
     for (const [relativePath, expectedContent] of Object.entries(additionalFiles)) {
-      const filePath = (0, import_path5.join)(skillDir, relativePath);
-      if (!(0, import_fs5.existsSync)(filePath)) {
+      const filePath = (0, import_path6.join)(skillDir, relativePath);
+      if (!(0, import_fs6.existsSync)(filePath)) {
         return true;
       }
-      const installedFileContent = (0, import_fs5.readFileSync)(filePath);
+      const installedFileContent = (0, import_fs6.readFileSync)(filePath);
       if (!installedFileContent.equals(expectedContent)) {
         return true;
       }
@@ -6670,24 +7019,24 @@ function warnLegacySkillStructure(toolPath, legacySkillMdPath) {
   console.error("");
 }
 function scanEditorFolderForSkills(editorPath, skills, sourceType, warnLegacy = true) {
-  if (!(0, import_fs5.existsSync)(editorPath)) {
+  if (!(0, import_fs6.existsSync)(editorPath)) {
     return;
   }
-  const entries = (0, import_fs5.readdirSync)(editorPath, { withFileTypes: true });
+  const entries = (0, import_fs6.readdirSync)(editorPath, { withFileTypes: true });
   for (const entry of entries) {
     if (EXCLUDED_DIRS2.has(entry.name)) {
       continue;
     }
-    const fullPath = (0, import_path5.join)(editorPath, entry.name);
+    const fullPath = (0, import_path6.join)(editorPath, entry.name);
     if (entry.isDirectory()) {
-      const skillDir = (0, import_path5.join)(fullPath, SkillsPathConstants.SKILL_DIR);
-      const skillMdPath = (0, import_path5.join)(skillDir, SkillsPathConstants.SKILL_FILE);
-      const legacySkillMdPath = (0, import_path5.join)(fullPath, SkillsPathConstants.SKILL_FILE);
-      if (warnLegacy && !(0, import_fs5.existsSync)(skillMdPath) && (0, import_fs5.existsSync)(legacySkillMdPath)) {
+      const skillDir = (0, import_path6.join)(fullPath, SkillsPathConstants.SKILL_DIR);
+      const skillMdPath = (0, import_path6.join)(skillDir, SkillsPathConstants.SKILL_FILE);
+      const legacySkillMdPath = (0, import_path6.join)(fullPath, SkillsPathConstants.SKILL_FILE);
+      if (warnLegacy && !(0, import_fs6.existsSync)(skillMdPath) && (0, import_fs6.existsSync)(legacySkillMdPath)) {
         warnLegacySkillStructure(fullPath, legacySkillMdPath);
       }
-      if ((0, import_fs5.existsSync)(skillMdPath)) {
-        const content = (0, import_fs5.readFileSync)(skillMdPath, "utf-8");
+      if ((0, import_fs6.existsSync)(skillMdPath)) {
+        const content = (0, import_fs6.readFileSync)(skillMdPath, "utf-8");
         const frontmatter = parseFrontmatter(content);
         if (frontmatter.internal === true) {
           continue;
@@ -6710,15 +7059,15 @@ function scanEditorFolderForSkills(editorPath, skills, sourceType, warnLegacy =
 function findEditorFolders(basePath, maxDepth = 2) {
   const editorFolders = [];
   function scan(currentPath, depth) {
-    if (depth > maxDepth || !(0, import_fs5.existsSync)(currentPath)) {
+    if (depth > maxDepth || !(0, import_fs6.existsSync)(currentPath)) {
       return;
     }
-    const entries = (0, import_fs5.readdirSync)(currentPath, { withFileTypes: true });
+    const entries = (0, import_fs6.readdirSync)(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || EXCLUDED_DIRS2.has(entry.name)) {
         continue;
       }
-      const fullPath = (0, import_path5.join)(currentPath, entry.name);
+      const fullPath = (0, import_path6.join)(currentPath, entry.name);
       if (entry.name === "Editor") {
         editorFolders.push(fullPath);
       } else {
@@ -6737,12 +7086,12 @@ function collectProjectSkills(excludedRoots = []) {
   const skills = [];
   const seenNames = /* @__PURE__ */ new Set();
   const searchPaths = [
-    (0, import_path5.join)(projectRoot, SkillsPathConstants.ASSETS_DIR),
-    (0, import_path5.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR),
-    (0, import_path5.join)(projectRoot, SkillsPathConstants.LIBRARY_DIR, SkillsPathConstants.PACKAGE_CACHE_DIR)
+    (0, import_path6.join)(projectRoot, SkillsPathConstants.ASSETS_DIR),
+    (0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR),
+    (0, import_path6.join)(projectRoot, SkillsPathConstants.LIBRARY_DIR, SkillsPathConstants.PACKAGE_CACHE_DIR)
   ];
   for (const searchPath of searchPaths) {
-    if (!(0, import_fs5.existsSync)(searchPath)) {
+    if (!(0, import_fs6.existsSync)(searchPath)) {
       continue;
     }
     const editorFolders = findEditorFolders(searchPath, 3);
@@ -6773,26 +7122,26 @@ function getAllSkillStatuses(target, global) {
 }
 function installSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
-  const skillPath = (0, import_path5.join)(skillDir, target.skillFileName);
-  (0, import_fs5.mkdirSync)(skillDir, { recursive: true });
-  (0, import_fs5.writeFileSync)(skillPath, skill.content, "utf-8");
+  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
+  const skillPath = (0, import_path6.join)(skillDir, target.skillFileName);
+  (0, import_fs6.mkdirSync)(skillDir, { recursive: true });
+  (0, import_fs6.writeFileSync)(skillPath, skill.content, "utf-8");
   if ("additionalFiles" in skill && skill.additionalFiles) {
     const additionalFiles = skill.additionalFiles;
     for (const [relativePath, content] of Object.entries(additionalFiles)) {
-      const fullPath = (0, import_path5.join)(skillDir, relativePath);
-      (0, import_fs5.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
-      (0, import_fs5.writeFileSync)(fullPath, content);
+      const fullPath = (0, import_path6.join)(skillDir, relativePath);
+      (0, import_fs6.mkdirSync)((0, import_path6.dirname)(fullPath), { recursive: true });
+      (0, import_fs6.writeFileSync)(fullPath, content);
     }
   }
 }
 function uninstallSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
-  if (!(0, import_fs5.existsSync)(skillDir)) {
+  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
+  if (!(0, import_fs6.existsSync)(skillDir)) {
     return false;
   }
-  (0, import_fs5.rmSync)(skillDir, { recursive: true, force: true });
+  (0, import_fs6.rmSync)(skillDir, { recursive: true, force: true });
   return true;
 }
 function installAllSkills(target, global) {
@@ -6806,9 +7155,9 @@ function installAllSkills(target, global) {
   };
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   for (const deprecatedName of DEPRECATED_SKILLS) {
-    const deprecatedDir = (0, import_path5.join)(baseDir, deprecatedName);
-    if ((0, import_fs5.existsSync)(deprecatedDir)) {
-      (0, import_fs5.rmSync)(deprecatedDir, { recursive: true, force: true });
+    const deprecatedDir = (0, import_path6.join)(baseDir, deprecatedName);
+    if ((0, import_fs6.existsSync)(deprecatedDir)) {
+      (0, import_fs6.rmSync)(deprecatedDir, { recursive: true, force: true });
       result.deprecatedRemoved++;
     }
   }
@@ -6835,9 +7184,9 @@ function uninstallAllSkills(target, global) {
   const result = { removed: 0, notFound: 0 };
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   for (const deprecatedName of DEPRECATED_SKILLS) {
-    const deprecatedDir = (0, import_path5.join)(baseDir, deprecatedName);
-    if ((0, import_fs5.existsSync)(deprecatedDir)) {
-      (0, import_fs5.rmSync)(deprecatedDir, { recursive: true, force: true });
+    const deprecatedDir = (0, import_path6.join)(baseDir, deprecatedName);
+    if ((0, import_fs6.existsSync)(deprecatedDir)) {
+      (0, import_fs6.rmSync)(deprecatedDir, { recursive: true, force: true });
       result.removed++;
     }
   }
@@ -6866,13 +7215,13 @@ function collectAllSkills() {
   return dedupeSkillsByName([packageSkills, cliOnlySkills, projectSkills]);
 }
 function collectPackageSkillsFromRoot(packageRoot) {
-  const mcpToolsRoot = (0, import_path5.join)(
+  const mcpToolsRoot = (0, import_path6.join)(
     packageRoot,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if (!(0, import_fs5.existsSync)(mcpToolsRoot)) {
+  if (!(0, import_fs6.existsSync)(mcpToolsRoot)) {
     return [];
   }
   const skills = [];
@@ -6880,7 +7229,7 @@ function collectPackageSkillsFromRoot(packageRoot) {
   return skills;
 }
 function collectCliOnlySkills() {
-  const cliOnlyRoot = (0, import_path5.resolve)(
+  const cliOnlyRoot = (0, import_path6.resolve)(
     __dirname,
     SkillsPathConstants.DIST_PARENT_DIR,
     SkillsPathConstants.SRC_DIR,
@@ -6888,7 +7237,7 @@ function collectCliOnlySkills() {
     SkillsPathConstants.CLI_ONLY_DIR,
     SkillsPathConstants.CLI_ONLY_SUBDIR
   );
-  if (!(0, import_fs5.existsSync)(cliOnlyRoot)) {
+  if (!(0, import_fs6.existsSync)(cliOnlyRoot)) {
     return [];
   }
   const skills = [];
@@ -6907,12 +7256,12 @@ function isExcludedFile(fileName) {
   return false;
 }
 function collectSkillFolderFilesRecursive(baseDir, currentDir, additionalFiles) {
-  const entries = (0, import_fs5.readdirSync)(currentDir, { withFileTypes: true });
+  const entries = (0, import_fs6.readdirSync)(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (isExcludedFile(entry.name)) {
       continue;
     }
-    const fullPath = (0, import_path5.join)(currentDir, entry.name);
+    const fullPath = (0, import_path6.join)(currentDir, entry.name);
     const relativePath = fullPath.slice(baseDir.length + 1);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS2.has(entry.name)) {
@@ -6923,12 +7272,12 @@ function collectSkillFolderFilesRecursive(baseDir, currentDir, additionalFiles)
       if (entry.name === SkillsPathConstants.SKILL_FILE) {
         continue;
       }
-      additionalFiles[relativePath] = (0, import_fs5.readFileSync)(fullPath);
+      additionalFiles[relativePath] = (0, import_fs6.readFileSync)(fullPath);
     }
   }
 }
 function collectSkillFolderFiles(skillDir) {
-  if (!(0, import_fs5.existsSync)(skillDir)) {
+  if (!(0, import_fs6.existsSync)(skillDir)) {
     return void 0;
   }
   const additionalFiles = {};
@@ -6951,13 +7300,13 @@ function dedupeSkillsByName(skillGroups) {
 }
 function resolvePackageRoot(projectRoot) {
   const candidates = [];
-  candidates.push((0, import_path5.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR));
+  candidates.push((0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR));
   const manifestPaths = resolveManifestPackagePaths(projectRoot);
   for (const manifestPath of manifestPaths) {
     candidates.push(manifestPath);
   }
   for (const packageName of SkillsPathConstants.PACKAGE_NAMES) {
-    candidates.push((0, import_path5.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, packageName));
+    candidates.push((0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, packageName));
   }
   const directRoot = resolveFirstPackageRoot(candidates);
   if (directRoot) {
@@ -6966,15 +7315,15 @@ function resolvePackageRoot(projectRoot) {
   return resolvePackageCacheRoot(projectRoot);
 }
 function resolveManifestPackagePaths(projectRoot) {
-  const manifestPath = (0, import_path5.join)(
+  const manifestPath = (0, import_path6.join)(
     projectRoot,
     SkillsPathConstants.PACKAGES_DIR,
     SkillsPathConstants.MANIFEST_FILE
   );
-  if (!(0, import_fs5.existsSync)(manifestPath)) {
+  if (!(0, import_fs6.existsSync)(manifestPath)) {
     return [];
   }
-  const manifestContent = (0, import_fs5.readFileSync)(manifestPath, "utf-8");
+  const manifestContent = (0, import_fs6.readFileSync)(manifestPath, "utf-8");
   let manifestJson;
   try {
     manifestJson = JSON.parse(manifestContent);
@@ -7018,10 +7367,10 @@ function resolveDependencyPath(rawPath, projectRoot) {
   if (normalizedPath.startsWith("//")) {
     normalizedPath = normalizedPath.slice(2);
   }
-  if ((0, import_path5.isAbsolute)(normalizedPath)) {
+  if ((0, import_path6.isAbsolute)(normalizedPath)) {
     return normalizedPath;
   }
-  return (0, import_path5.resolve)(projectRoot, normalizedPath);
+  return (0, import_path6.resolve)(projectRoot, normalizedPath);
 }
 function resolveFirstPackageRoot(candidates) {
   for (const candidate of candidates) {
@@ -7033,15 +7382,15 @@ function resolveFirstPackageRoot(candidates) {
   return null;
 }
 function resolvePackageCacheRoot(projectRoot) {
-  const packageCacheDir = (0, import_path5.join)(
+  const packageCacheDir = (0, import_path6.join)(
     projectRoot,
     SkillsPathConstants.LIBRARY_DIR,
     SkillsPathConstants.PACKAGE_CACHE_DIR
   );
-  if (!(0, import_fs5.existsSync)(packageCacheDir)) {
+  if (!(0, import_fs6.existsSync)(packageCacheDir)) {
     return null;
   }
-  const entries = (0, import_fs5.readdirSync)(packageCacheDir, { withFileTypes: true });
+  const entries = (0, import_fs6.readdirSync)(packageCacheDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
@@ -7049,7 +7398,7 @@ function resolvePackageCacheRoot(projectRoot) {
     if (!isTargetPackageCacheDir(entry.name)) {
       continue;
     }
-    const candidate = (0, import_path5.join)(packageCacheDir, entry.name);
+    const candidate = (0, import_path6.join)(packageCacheDir, entry.name);
     const resolvedRoot = resolvePackageRootCandidate(candidate);
     if (resolvedRoot) {
       return resolvedRoot;
@@ -7058,26 +7407,26 @@ function resolvePackageCacheRoot(projectRoot) {
   return null;
 }
 function resolvePackageRootCandidate(candidate) {
-  if (!(0, import_fs5.existsSync)(candidate)) {
+  if (!(0, import_fs6.existsSync)(candidate)) {
     return null;
   }
-  const directToolsPath = (0, import_path5.join)(
+  const directToolsPath = (0, import_path6.join)(
     candidate,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if ((0, import_fs5.existsSync)(directToolsPath)) {
+  if ((0, import_fs6.existsSync)(directToolsPath)) {
     return candidate;
   }
-  const nestedRoot = (0, import_path5.join)(candidate, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR);
-  const nestedToolsPath = (0, import_path5.join)(
+  const nestedRoot = (0, import_path6.join)(candidate, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR);
+  const nestedToolsPath = (0, import_path6.join)(
     nestedRoot,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if ((0, import_fs5.existsSync)(nestedToolsPath)) {
+  if ((0, import_fs6.existsSync)(nestedToolsPath)) {
     return nestedRoot;
   }
   return null;
@@ -7103,12 +7452,12 @@ function isUnderExcludedRoots(targetPath, excludedRoots) {
   return false;
 }
 function isPathUnder(childPath, parentPath) {
-  const resolvedChild = (0, import_path5.resolve)(childPath);
-  const resolvedParent = (0, import_path5.resolve)(parentPath);
+  const resolvedChild = (0, import_path6.resolve)(childPath);
+  const resolvedParent = (0, import_path6.resolve)(parentPath);
   if (resolvedChild === resolvedParent) {
     return true;
   }
-  return resolvedChild.startsWith(resolvedParent + import_path5.sep);
+  return resolvedChild.startsWith(resolvedParent + import_path6.sep);
 }
 
 // src/skills/target-config.ts
@@ -7263,7 +7612,7 @@ Uninstalling uloop skills (${location})...`);
 }
 
 // src/commands/launch.ts
-var import_path6 = require("path");
+var import_path7 = require("path");
 
 // node_modules/launch-unity/dist/lib.js
 var import_node_child_process = require("node:child_process");
@@ -7276,7 +7625,7 @@ var import_node_util = require("node:util");
 var import_promises2 = require("node:fs/promises");
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
-var import_node_assert = __toESM(require("node:assert"), 1);
+var import_node_assert2 = __toESM(require("node:assert"), 1);
 var resolveUnityHubProjectFiles = () => {
   if (process.platform === "darwin") {
     const home = process.env.HOME;
@@ -7447,7 +7796,7 @@ var resolveUnityHubProjectsInfoFile = () => {
   return void 0;
 };
 var parseCliArgs = (cliArgsString) => {
-  (0, import_node_assert.default)(cliArgsString !== null && cliArgsString !== void 0, "cliArgsString must not be null");
+  (0, import_node_assert2.default)(cliArgsString !== null && cliArgsString !== void 0, "cliArgsString must not be null");
   const trimmed = cliArgsString.trim();
   if (trimmed.length === 0) {
     return [];
@@ -7503,7 +7852,7 @@ var groupCliArgs = (args) => {
   return groups;
 };
 var getProjectCliArgs = async (projectPath) => {
-  (0, import_node_assert.default)(projectPath !== null && projectPath !== void 0, "projectPath must not be null");
+  (0, import_node_assert2.default)(projectPath !== null && projectPath !== void 0, "projectPath must not be null");
   const infoFilePath = resolveUnityHubProjectsInfoFile();
   if (!infoFilePath) {
     logDebug("projectsInfo.json path could not be resolved.");
@@ -7551,6 +7900,8 @@ var PROCESS_LIST_ARGS_MAC = ["-axo", "pid=,command=", "-ww"];
 var WINDOWS_POWERSHELL = "powershell";
 var UNITY_LOCKFILE_NAME = "UnityLockfile";
 var TEMP_DIRECTORY_NAME = "Temp";
+var ASSETS_DIRECTORY_NAME = "Assets";
+var RECOVERY_DIRECTORY_NAME = "_Recovery";
 function getUnityVersion(projectPath) {
   const versionFile = (0, import_node_path2.join)(projectPath, "ProjectSettings", "ProjectVersion.txt");
   if (!(0, import_node_fs2.existsSync)(versionFile)) {
@@ -7850,6 +8201,20 @@ async function handleStaleLockfile(projectPath) {
   }
   console.log();
 }
+async function deleteRecoveryDirectory(projectPath) {
+  const recoveryPath = (0, import_node_path2.join)(projectPath, ASSETS_DIRECTORY_NAME, RECOVERY_DIRECTORY_NAME);
+  if (!(0, import_node_fs2.existsSync)(recoveryPath)) {
+    return;
+  }
+  console.log(`Deleting recovery directory: ${recoveryPath}`);
+  try {
+    await (0, import_promises3.rm)(recoveryPath, { recursive: true, force: true });
+    console.log("Deleted recovery directory.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to delete recovery directory: ${message}`);
+  }
+}
 var LOCKFILE_POLL_INTERVAL_MS = 100;
 var LOCKFILE_WAIT_TIMEOUT_MS = 5e3;
 var KILL_POLL_INTERVAL_MS = 100;
@@ -7875,7 +8240,7 @@ async function waitForProcessExit(pid, timeoutMs) {
     if (!isProcessAlive(pid)) {
       return true;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, KILL_POLL_INTERVAL_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, KILL_POLL_INTERVAL_MS));
   }
   return false;
 }
@@ -8044,7 +8409,7 @@ async function waitForLockfile(projectPath) {
     if ((0, import_node_fs2.existsSync)(lockfilePath)) {
       return;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, LOCKFILE_POLL_INTERVAL_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, LOCKFILE_POLL_INTERVAL_MS));
   }
   console.warn("Unity launched, but UnityLockfile was not detected within 5s.");
 }
@@ -8075,7 +8440,7 @@ async function launch(opts) {
   if (unityArgs.length > 0) {
     args.push(...unityArgs);
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = (0, import_node_child_process.spawn)(unityPath, args, {
       stdio: "ignore",
       detached: true,
@@ -8092,7 +8457,7 @@ async function launch(opts) {
     const handleSpawn = () => {
       child.removeListener("error", handleError);
       child.unref();
-      resolve5();
+      resolve6();
     };
     child.once("error", handleError);
     child.once("spawn", handleSpawn);
@@ -8140,6 +8505,9 @@ async function orchestrateLaunch(options) {
       return { action: "focused", projectPath: resolvedProjectPath, pid: runningProcess.pid };
     }
   }
+  if (options.deleteRecovery) {
+    await deleteRecoveryDirectory(resolvedProjectPath);
+  }
   await handleStaleLockfile(resolvedProjectPath);
   const resolved = {
     projectPath: resolvedProjectPath,
@@ -8164,7 +8532,7 @@ async function orchestrateLaunch(options) {
 function registerLaunchCommand(program3) {
   program3.command("launch").description(
     "Open a Unity project with the matching Editor version installed by Unity Hub.\nAuto-detects project path and Unity version from ProjectSettings/ProjectVersion.txt.\nRun 'uloop launch -h' for all options. Details: https://github.com/hatayama/LaunchUnityCommand"
-  ).argument("[project-path]", "Path to Unity project").option("-r, --restart", "Kill running Unity and restart").option("-q, --quit", "Gracefully quit running Unity").option("-p, --platform <platform>", "Build target (e.g., Android, iOS)").option("--max-depth <n>", "Search depth when project-path is omitted", "3").option("-a, --add-unity-hub", "Add to Unity Hub (does not launch)").option("-f, --favorite", "Add to Unity Hub as favorite (does not launch)").action(async (projectPath, options) => {
+  ).argument("[project-path]", "Path to Unity project").option("-r, --restart", "Kill running Unity and restart").option("-d, --delete-recovery", "Delete Assets/_Recovery before launch").option("-q, --quit", "Gracefully quit running Unity").option("-p, --platform <platform>", "Build target (e.g., Android, iOS)").option("--max-depth <n>", "Search depth when project-path is omitted", "3").option("-a, --add-unity-hub", "Add to Unity Hub (does not launch)").option("-f, --favorite", "Add to Unity Hub as favorite (does not launch)").action(async (projectPath, options) => {
     await runLaunchCommand(projectPath, options);
   });
 }
@@ -8182,13 +8550,14 @@ function parseMaxDepth(value) {
 async function runLaunchCommand(projectPath, options) {
   const maxDepth = parseMaxDepth(options.maxDepth);
   await orchestrateLaunch({
-    projectPath: projectPath ? (0, import_path6.resolve)(projectPath) : void 0,
+    projectPath: projectPath ? (0, import_path7.resolve)(projectPath) : void 0,
     searchRoot: process.cwd(),
     searchMaxDepth: maxDepth,
     platform: options.platform,
     unityArgs: [],
     restart: options.restart === true,
     quit: options.quit === true,
+    deleteRecovery: options.deleteRecovery === true,
     addUnityHub: options.addUnityHub === true,
     favoriteUnityHub: options.favorite === true
   });
@@ -8196,8 +8565,24 @@ async function runLaunchCommand(projectPath, options) {
 
 // src/commands/focus-window.ts
 function registerFocusWindowCommand(program3) {
-  program3.command("focus-window").description("Bring Unity Editor window to front using OS-level commands").action(async () => {
-    const projectRoot = findUnityProjectRoot();
+  program3.command("focus-window").description("Bring Unity Editor window to front using OS-level commands").option("--project-path <path>", "Unity project path").action(async (options) => {
+    let projectRoot;
+    if (options.projectPath !== void 0) {
+      try {
+        projectRoot = validateProjectPath(options.projectPath);
+      } catch (error) {
+        console.error(
+          JSON.stringify({
+            Success: false,
+            Message: error instanceof Error ? error.message : String(error)
+          })
+        );
+        process.exit(1);
+        return;
+      }
+    } else {
+      projectRoot = findUnityProjectRoot();
+    }
     if (projectRoot === null) {
       console.error(
         JSON.stringify({
@@ -8255,11 +8640,11 @@ var program2 = new Command();
 program2.name("uloop").description("Unity MCP CLI - Direct communication with Unity Editor").version(VERSION, "-v, --version", "Output the version number");
 program2.option("--list-commands", "List all command names (for shell completion)");
 program2.option("--list-options <cmd>", "List options for a command (for shell completion)");
-program2.command("list").description("List all available tools from Unity").option("-p, --port <port>", "Unity TCP port").action(async (options) => {
-  await runWithErrorHandling(() => listAvailableTools(options));
+program2.command("list").description("List all available tools from Unity").option("-p, --port <port>", "Unity TCP port").option("--project-path <path>", "Unity project path").action(async (options) => {
+  await runWithErrorHandling(() => listAvailableTools(extractGlobalOptions(options)));
 });
-program2.command("sync").description("Sync tool definitions from Unity to local cache").option("-p, --port <port>", "Unity TCP port").action(async (options) => {
-  await runWithErrorHandling(() => syncTools(options));
+program2.command("sync").description("Sync tool definitions from Unity to local cache").option("-p, --port <port>", "Unity TCP port").option("--project-path <path>", "Unity project path").action(async (options) => {
+  await runWithErrorHandling(() => syncTools(extractGlobalOptions(options)));
 });
 program2.command("completion").description("Setup shell completion").option("--install", "Install completion to shell config file").option("--shell <type>", "Shell type: bash, zsh, or powershell").action((options) => {
   handleCompletion(options.install ?? false, options.shell);
@@ -8267,8 +8652,11 @@ program2.command("completion").description("Setup shell completion").option("--i
 program2.command("update").description("Update uloop CLI to the latest version").action(() => {
   updateCli();
 });
-program2.command("fix").description("Clean up stale lock files that may prevent CLI from connecting").action(() => {
-  cleanupLockFiles();
+program2.command("fix").description("Clean up stale lock files that may prevent CLI from connecting").option("--project-path <path>", "Unity project path").action(async (options) => {
+  await runWithErrorHandling(() => {
+    cleanupLockFiles(options.projectPath);
+    return Promise.resolve();
+  });
 });
 registerSkillsCommand(program2);
 registerLaunchCommand(program2);
@@ -8291,6 +8679,7 @@ function registerToolCommand(tool) {
     }
   }
   cmd.option("-p, --port <port>", "Unity TCP port");
+  cmd.option("--project-path <path>", "Unity project path");
   cmd.action(async (options) => {
     const params = buildParams(options, properties);
     if (tool.name === "execute-dynamic-code" && params["Code"]) {
@@ -8397,7 +8786,8 @@ function convertValue(value, propInfo) {
 }
 function extractGlobalOptions(options) {
   return {
-    port: options["port"]
+    port: options["port"],
+    projectPath: options["projectPath"]
   };
 }
 function isConnectionError(message) {
@@ -8481,7 +8871,7 @@ async function runWithErrorHandling(fn) {
 }
 function detectShell() {
   const shell = process.env["SHELL"] || "";
-  const shellName = (0, import_path7.basename)(shell).replace(/\.exe$/i, "");
+  const shellName = (0, import_path8.basename)(shell).replace(/\.exe$/i, "");
   if (shellName === "zsh") {
     return "zsh";
   }
@@ -8496,12 +8886,12 @@ function detectShell() {
 function getShellConfigPath(shell) {
   const home = (0, import_os2.homedir)();
   if (shell === "zsh") {
-    return (0, import_path7.join)(home, ".zshrc");
+    return (0, import_path8.join)(home, ".zshrc");
   }
   if (shell === "powershell") {
-    return (0, import_path7.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    return (0, import_path8.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
   }
-  return (0, import_path7.join)(home, ".bashrc");
+  return (0, import_path8.join)(home, ".bashrc");
 }
 function getCompletionScript(shell) {
   if (shell === "bash") {
@@ -8632,18 +9022,18 @@ function updateCli() {
   });
 }
 var LOCK_FILES = ["compiling.lock", "domainreload.lock", "serverstarting.lock"];
-function cleanupLockFiles() {
-  const projectRoot = findUnityProjectRoot();
+function cleanupLockFiles(projectPath) {
+  const projectRoot = projectPath !== void 0 ? validateProjectPath(projectPath) : findUnityProjectRoot();
   if (projectRoot === null) {
     console.error("Could not find Unity project root.");
     process.exit(1);
   }
-  const tempDir = (0, import_path7.join)(projectRoot, "Temp");
+  const tempDir = (0, import_path8.join)(projectRoot, "Temp");
   let cleaned = 0;
   for (const lockFile of LOCK_FILES) {
-    const lockPath = (0, import_path7.join)(tempDir, lockFile);
-    if ((0, import_fs6.existsSync)(lockPath)) {
-      (0, import_fs6.unlinkSync)(lockPath);
+    const lockPath = (0, import_path8.join)(tempDir, lockFile);
+    if ((0, import_fs7.existsSync)(lockPath)) {
+      (0, import_fs7.unlinkSync)(lockPath);
       console.log(`Removed: ${lockFile}`);
       cleaned++;
     }
@@ -8678,13 +9068,13 @@ function handleCompletion(install, shellOverride) {
     return;
   }
   const configPath = getShellConfigPath(shell);
-  const configDir = (0, import_path7.dirname)(configPath);
-  if (!(0, import_fs6.existsSync)(configDir)) {
-    (0, import_fs6.mkdirSync)(configDir, { recursive: true });
+  const configDir = (0, import_path8.dirname)(configPath);
+  if (!(0, import_fs7.existsSync)(configDir)) {
+    (0, import_fs7.mkdirSync)(configDir, { recursive: true });
   }
   let content = "";
-  if ((0, import_fs6.existsSync)(configPath)) {
-    content = (0, import_fs6.readFileSync)(configPath, "utf-8");
+  if ((0, import_fs7.existsSync)(configPath)) {
+    content = (0, import_fs7.readFileSync)(configPath, "utf-8");
     content = content.replace(
       /\n?# >>> uloop completion >>>[\s\S]*?# <<< uloop completion <<<\n?/g,
       ""
@@ -8698,7 +9088,7 @@ ${startMarker}
 ${script}
 ${endMarker}
 `;
-    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs7.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   } else {
     const evalLine = `eval "$(uloop completion --shell ${shell})"`;
     const lineToAdd = `
@@ -8706,7 +9096,7 @@ ${startMarker}
 ${evalLine}
 ${endMarker}
 `;
-    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs7.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   }
   console.log(`Completion installed to ${configPath}`);
   if (shell === "powershell") {
@@ -8760,12 +9150,42 @@ function shouldSkipAutoSync(cmdName, args) {
   }
   return args.some((arg) => NO_SYNC_FLAGS.includes(arg));
 }
+function extractSyncGlobalOptions(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "-p") {
+      const nextArg = args[i + 1];
+      if (nextArg !== void 0 && !nextArg.startsWith("-")) {
+        options.port = nextArg;
+      }
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      options.port = arg.slice("--port=".length);
+      continue;
+    }
+    if (arg === "--project-path") {
+      const nextArg = args[i + 1];
+      if (nextArg !== void 0 && !nextArg.startsWith("-")) {
+        options.projectPath = nextArg;
+      }
+      continue;
+    }
+    if (arg.startsWith("--project-path=")) {
+      options.projectPath = arg.slice("--project-path=".length);
+      continue;
+    }
+  }
+  return options;
+}
 async function main() {
   if (handleCompletionOptions()) {
     return;
   }
   const args = process.argv.slice(2);
   const cmdName = args.find((arg) => !arg.startsWith("-"));
+  const syncGlobalOptions = extractSyncGlobalOptions(args);
   if (!shouldSkipAutoSync(cmdName, args)) {
     const cachedVersion = loadToolsCache().version;
     if (hasCacheFile() && cachedVersion !== VERSION) {
@@ -8773,7 +9193,7 @@ async function main() {
         `\x1B[33mCache outdated (${cachedVersion} \u2192 ${VERSION}). Syncing tools from Unity...\x1B[0m`
       );
       try {
-        await syncTools({});
+        await syncTools(syncGlobalOptions);
         console.log("\x1B[32m\u2713 Tools synced successfully.\x1B[0m\n");
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -8795,7 +9215,7 @@ async function main() {
   if (cmdName && !commandExists(cmdName)) {
     console.log(`\x1B[33mUnknown command '${cmdName}'. Syncing tools from Unity...\x1B[0m`);
     try {
-      await syncTools({});
+      await syncTools(syncGlobalOptions);
       const newCache = loadToolsCache();
       const tool = newCache.tools.find((t) => t.name === cmdName);
       if (tool) {