unity-agentic-tools 0.6.1 → 0.7.0

package/dist/cli.js

@@ -2129,37 +2129,33 @@ var require_commander = __commonJS((exports2) => {
 var require_package = __commonJS((exports2, module2) => {
   module2.exports = {
     name: "unity-agentic-tools",
-    packageManager: "bun@latest",
-    version: "0.6.1",
+    packageManager: "bun@1.3.14",
+    version: "0.7.0",
     description: "Compact Unity Editor command runner for AI agents",
     exports: {
       ".": {
         import: "./dist/index.js",
         types: "./dist/index.d.ts"
       },
-      "./cli": "./dist/cli.js",
-      "./scanner": "./dist/scanner.js"
+      "./cli": "./dist/cli.js"
     },
     files: [
       "dist",
-      "native",
       "README.md",
       "LICENSE"
     ],
     scripts: {
-      build: "bun run clean && bun run build:types && bun run build:lib && bun run build:cli && cp ../doc-indexer/dist/cli.js dist/doc-indexer-cli.js",
+      build: "bun run clean && bun run build:types && bun run build:lib && bun run build:cli",
       "build:types": "tsc --project tsconfig.json",
-      "build:lib": "bun build src/index.ts --outdir=dist --target=bun --format=cjs --external unity-file-tools",
-      "build:cli": "bun build src/cli.ts --outdir=dist --target=bun --format=cjs --external unity-file-tools",
-      "build:rust": "cd ../rust-core && bun run build",
-      "build:all": "bun run build:rust || echo 'Rust build skipped' && bun run build",
+      "build:lib": "bun build src/index.ts --outdir=dist --target=bun --format=cjs",
+      "build:cli": "bun build src/cli.ts --outdir=dist --target=bun --format=cjs && chmod +x dist/cli.js",
       dev: "bun build src/index.ts --watch",
       clean: "rm -rf dist",
       rebuild: "bun run clean && bun run build",
       test: "bun test",
       "test:watch": "bun test --watch",
-      "test:coverage": "bun test --coverage",
-      "test:unity-headless": "bun test/run-headless-validation.ts"
+      "test:unity-headless": "bun test/run-headless-validation.ts",
+      "test:stress": "bun test/run-bridge-stress.ts"
     },
     dependencies: {
       commander: "^14.0.2"
@@ -2168,7 +2164,6 @@ var require_package = __commonJS((exports2, module2) => {
       "@types/node": "^25.0.0",
       "@vitest/ui": "^4.0.16",
       typescript: "^5.3.0",
-      "unity-file-tools": "workspace:*",
       vitest: "^4.0.16"
     },
     type: "commonjs",
@@ -2212,6 +2207,10 @@ var {
   Help
 } = import__.default;
 
+// src/bridge-install.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
 // src/packages.ts
 var import_fs = require("fs");
 var import_path = require("path");
@@ -2275,15 +2274,21 @@ function remove_package(project_path, name) {
 }
 
 // src/bridge-install.ts
+var __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src";
 var BRIDGE_PACKAGE_NAME = "com.unity-agentic-tools.editor-bridge";
-var BRIDGE_PACKAGE_VERSION = "https://github.com/taconotsandwich/unity-agentic-tools.git?path=unity-package";
-function install_bridge_package(project_path) {
+var REMOTE_BRIDGE_PACKAGE_VERSION = "https://github.com/taconotsandwich/unity-agentic-tools.git?path=unity-package";
+function install_bridge_package(project_path, options = {}) {
+  const target = resolve_bridge_package_target(options);
+  if ("error" in target) {
+    return target;
+  }
   const manifest_result = load_manifest(project_path);
   if ("error" in manifest_result) {
     return manifest_result;
   }
   const existing_version = manifest_result.manifest.dependencies[BRIDGE_PACKAGE_NAME];
-  if (typeof existing_version === "string" && existing_version.startsWith("file:")) {
+  const should_preserve_existing_file = !options.remote && !options.local_package_path && !options.require_local;
+  if (should_preserve_existing_file && typeof existing_version === "string" && existing_version.startsWith("file:")) {
     return {
       success: true,
       action: "preserved",
@@ -2291,12 +2296,75 @@ function install_bridge_package(project_path) {
       version: existing_version
     };
   }
-  return add_package(project_path, BRIDGE_PACKAGE_NAME, BRIDGE_PACKAGE_VERSION);
+  return add_package(project_path, BRIDGE_PACKAGE_NAME, target.version);
+}
+function resolve_bridge_package_target(options) {
+  if (options.remote && (options.local_package_path || options.require_local)) {
+    return { error: "Use either --local or --remote, not both." };
+  }
+  if (options.remote) {
+    return { version: REMOTE_BRIDGE_PACKAGE_VERSION };
+  }
+  if (options.local_package_path) {
+    const local_path = import_path2.resolve(options.local_package_path);
+    return local_package_target(local_path);
+  }
+  if (options.require_local) {
+    const detected_path = detect_local_bridge_package_path();
+    if (detected_path) {
+      return local_package_target(detected_path);
+    }
+    return {
+      error: "Local bridge package could not be auto-detected. Pass --local <path-to-unity-package> or run from a source checkout."
+    };
+  }
+  return { version: REMOTE_BRIDGE_PACKAGE_VERSION };
+}
+function detect_local_bridge_package_path() {
+  const candidate = import_path2.resolve(__dirname, "..", "..", "unity-package");
+  return is_bridge_package(candidate) ? candidate : undefined;
+}
+function local_package_target(package_path) {
+  const normalized_path = normalize_local_bridge_package_path(package_path);
+  if (!normalized_path) {
+    return {
+      error: `Local bridge package not found at ${package_path}. Expected package.json with name "${BRIDGE_PACKAGE_NAME}".`
+    };
+  }
+  return { version: to_file_dependency(normalized_path) };
+}
+function normalize_local_bridge_package_path(package_path) {
+  if (is_bridge_package(package_path)) {
+    return package_path;
+  }
+  const nested_package_path = import_path2.join(package_path, "unity-package");
+  if (is_bridge_package(nested_package_path)) {
+    return nested_package_path;
+  }
+  return;
+}
+function is_bridge_package(package_path) {
+  const package_json_path = import_path2.join(package_path, "package.json");
+  if (!import_fs2.existsSync(package_json_path)) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(import_fs2.readFileSync(package_json_path, "utf-8"));
+    return is_record(parsed) && parsed.name === BRIDGE_PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function to_file_dependency(package_path) {
+  return `file:${package_path.replace(/\\/g, "/")}`;
 }
 
 // src/cleanup.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
 var CONFIG_DIR = ".unity-agentic";
 var GUID_CACHE_FILE = "guid-cache.json";
 var PACKAGE_CACHE_FILE = "package-cache.json";
@@ -2306,10 +2374,10 @@ var DOC_INDEX_FILE = "doc-index.json";
 var EDITOR_LOCK_FILE = "editor.json";
 var LAST_EDITOR_CONFIG_FILE = "editor.last.json";
 function cleanup(options = {}) {
-  const projectPath = import_path2.resolve(options.project || process.cwd());
-  const configPath = import_path2.join(projectPath, CONFIG_DIR);
+  const projectPath = import_path3.resolve(options.project || process.cwd());
+  const configPath = import_path3.join(projectPath, CONFIG_DIR);
   const modes = resolve_cleanup_modes(options);
-  if (!import_fs2.existsSync(configPath)) {
+  if (!import_fs3.existsSync(configPath)) {
     return {
       success: true,
       project_path: projectPath,
@@ -2377,16 +2445,16 @@ function resolve_cleanup_modes(options) {
   return modes;
 }
 function remove_stale_lock_files(configPath, filesRemoved) {
-  const editorLockPath = import_path2.join(configPath, EDITOR_LOCK_FILE);
-  if (import_fs2.existsSync(editorLockPath) && is_stale_editor_lock(editorLockPath)) {
+  const editorLockPath = import_path3.join(configPath, EDITOR_LOCK_FILE);
+  if (import_fs3.existsSync(editorLockPath) && is_stale_editor_lock(editorLockPath)) {
     remove_file(configPath, EDITOR_LOCK_FILE, filesRemoved);
   }
   remove_file(configPath, LAST_EDITOR_CONFIG_FILE, filesRemoved);
 }
 function is_stale_editor_lock(filePath) {
   try {
-    const parsed = JSON.parse(import_fs2.readFileSync(filePath, "utf-8"));
-    if (!is_record(parsed)) {
+    const parsed = JSON.parse(import_fs3.readFileSync(filePath, "utf-8"));
+    if (!is_record2(parsed)) {
       return true;
     }
     const pid = parsed.pid;
@@ -2403,10 +2471,10 @@ function is_process_alive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    return is_record(err) && err.code === "EPERM";
+    return is_record2(err) && err.code === "EPERM";
   }
 }
-function is_record(value) {
+function is_record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function remove_files(configPath, files, filesRemoved) {
@@ -2415,38 +2483,38 @@ function remove_files(configPath, files, filesRemoved) {
   }
 }
 function remove_file(configPath, file, filesRemoved) {
-  const filePath = import_path2.join(configPath, file);
-  if (!import_fs2.existsSync(filePath)) {
+  const filePath = import_path3.join(configPath, file);
+  if (!import_fs3.existsSync(filePath)) {
     return;
   }
   try {
-    import_fs2.unlinkSync(filePath);
+    import_fs3.unlinkSync(filePath);
     filesRemoved.push(file);
   } catch {}
 }
 function removeDirectoryRecursive(dir) {
-  if (!import_fs2.existsSync(dir)) {
+  if (!import_fs3.existsSync(dir)) {
     return;
   }
-  const entries = import_fs2.readdirSync(dir, { withFileTypes: true });
+  const entries = import_fs3.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = import_path2.join(dir, entry.name);
+    const fullPath = import_path3.join(dir, entry.name);
     if (entry.isDirectory()) {
       removeDirectoryRecursive(fullPath);
     } else {
-      import_fs2.unlinkSync(fullPath);
+      import_fs3.unlinkSync(fullPath);
     }
   }
-  import_fs2.rmdirSync(dir);
+  import_fs3.rmdirSync(dir);
 }
 
 // src/editor-discovery.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 
 // src/gitignore.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
 var AGENTIC_DIR = ".unity-agentic";
 var GITIGNORE_ENTRY = `${AGENTIC_DIR}/`;
 var ACCEPTED_AGENTIC_PATTERNS = new Set([
@@ -2456,20 +2524,20 @@ var ACCEPTED_AGENTIC_PATTERNS = new Set([
   `/${GITIGNORE_ENTRY}`
 ]);
 function ensure_gitignore_ignores_agentic_dir(project_path) {
-  const gitignore_path = import_path3.join(project_path, ".gitignore");
-  if (!import_fs3.existsSync(gitignore_path)) {
-    import_fs3.writeFileSync(gitignore_path, `${GITIGNORE_ENTRY}
+  const gitignore_path = import_path4.join(project_path, ".gitignore");
+  if (!import_fs4.existsSync(gitignore_path)) {
+    import_fs4.writeFileSync(gitignore_path, `${GITIGNORE_ENTRY}
 `);
     return;
   }
-  const content = import_fs3.readFileSync(gitignore_path, "utf-8");
+  const content = import_fs4.readFileSync(gitignore_path, "utf-8");
   if (gitignore_ignores_agentic_dir(content)) {
     return;
   }
   const separator = content.length === 0 || content.endsWith(`
 `) ? "" : `
 `;
-  import_fs3.writeFileSync(gitignore_path, `${content}${separator}${GITIGNORE_ENTRY}
+  import_fs4.writeFileSync(gitignore_path, `${content}${separator}${GITIGNORE_ENTRY}
 `);
 }
 function gitignore_ignores_agentic_dir(content) {
@@ -2486,7 +2554,7 @@ function gitignore_ignores_agentic_dir(content) {
 }
 
 // src/util.ts
-function is_record2(value) {
+function is_record3(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -2507,7 +2575,7 @@ async function request_editor_at_port(options) {
     method,
     ...Object.keys(wire_params).length > 0 ? { params: wire_params } : {}
   };
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let resolved = false;
     let ws;
     const timer = setTimeout(() => {
@@ -2516,7 +2584,7 @@ async function request_editor_at_port(options) {
         try {
           ws?.close();
         } catch {}
-        resolve2({
+        resolve3({
           jsonrpc: "2.0",
           id: request_id,
           error: { code: -32001, message: `Timeout after ${timeout}ms waiting for response to ${method}` }
@@ -2535,7 +2603,7 @@ async function request_editor_at_port(options) {
               ws.close();
             } catch {}
           }, 200);
-          resolve2({
+          resolve3({
             jsonrpc: "2.0",
             id: request_id,
             result: { queued: true }
@@ -2550,7 +2618,7 @@ async function request_editor_at_port(options) {
               resolved = true;
               clearTimeout(timer);
               ws.close();
-              resolve2(data);
+              resolve3(data);
             }
           }
         } catch {}
@@ -2559,7 +2627,7 @@ async function request_editor_at_port(options) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve2({
+          resolve3({
             jsonrpc: "2.0",
             id: request_id,
             error: { code: -32002, message: `WebSocket connection failed to ${url}. Is the Unity Editor running?` }
@@ -2570,7 +2638,7 @@ async function request_editor_at_port(options) {
         if (!resolved) {
           resolved = true;
           clearTimeout(timer);
-          resolve2({
+          resolve3({
             jsonrpc: "2.0",
             id: request_id,
             error: { code: -32003, message: "WebSocket connection closed before response received" }
@@ -2581,7 +2649,7 @@ async function request_editor_at_port(options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timer);
-        resolve2({
+        resolve3({
           jsonrpc: "2.0",
           id: request_id,
           error: { code: -32002, message: `Failed to connect: ${err instanceof Error ? err.message : String(err)}` }
@@ -2592,9 +2660,9 @@ async function request_editor_at_port(options) {
 }
 async function ping_editor(port, timeout_ms = 2000) {
   const url = `ws://127.0.0.1:${port}/unity-agentic`;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const timer = setTimeout(() => {
-      resolve2({ reachable: false, error: `Timeout after ${timeout_ms}ms` });
+      resolve3({ reachable: false, error: `Timeout after ${timeout_ms}ms` });
     }, timeout_ms);
     try {
       const ws = new WebSocket(url);
@@ -2603,15 +2671,15 @@ async function ping_editor(port, timeout_ms = 2000) {
         try {
           ws.close();
         } catch {}
-        resolve2({ reachable: true });
+        resolve3({ reachable: true });
       };
       ws.onerror = (err) => {
         clearTimeout(timer);
-        resolve2({ reachable: false, error: describe_websocket_error(err, `WebSocket connection failed to ${url}`) });
+        resolve3({ reachable: false, error: describe_websocket_error(err, `WebSocket connection failed to ${url}`) });
       };
     } catch (err) {
       clearTimeout(timer);
-      resolve2({ reachable: false, error: describe_websocket_error(err, `WebSocket connection failed to ${url}`) });
+      resolve3({ reachable: false, error: describe_websocket_error(err, `WebSocket connection failed to ${url}`) });
     }
   });
 }
@@ -2622,7 +2690,7 @@ function describe_websocket_error(err, fallback) {
   if (err instanceof Error && err.message.trim().length > 0) {
     return err.message;
   }
-  if (is_record2(err)) {
+  if (is_record3(err)) {
     if (typeof err.message === "string" && err.message.trim().length > 0) {
       return err.message;
     }
@@ -2646,13 +2714,13 @@ var BRIDGE_PORT_RANGE_END = 53791;
 var LAST_KNOWN_CONFIG_FILE = "editor.last.json";
 var LAST_KNOWN_EDITOR_CONFIGS = new Map;
 function read_editor_config(project_path) {
-  const config_path = import_path4.join(project_path, ".unity-agentic", "editor.json");
-  if (!import_fs4.existsSync(config_path)) {
+  const config_path = import_path5.join(project_path, ".unity-agentic", "editor.json");
+  if (!import_fs5.existsSync(config_path)) {
     return { error: `Editor bridge not found at ${config_path}. Is the Unity Editor running with the bridge package installed?` };
   }
   let config;
   try {
-    const raw = import_fs4.readFileSync(config_path, "utf-8");
+    const raw = import_fs5.readFileSync(config_path, "utf-8");
     config = JSON.parse(raw);
   } catch (err) {
     return { error: `Failed to parse editor.json: ${err instanceof Error ? err.message : String(err)}` };
@@ -2751,7 +2819,7 @@ async function discover_bridge_infos(timeout_ms, preferred_ports = []) {
   return results.filter((result) => result !== null);
 }
 function parse_bridge_info(result, port) {
-  if (!is_record2(result)) {
+  if (!is_record3(result)) {
     return null;
   }
   const project_path = typeof result.project_path === "string" ? result.project_path : null;
@@ -2780,20 +2848,20 @@ function remember_editor_config(project_path, config) {
 }
 function forget_cached_editor_config(project_path, normalized_project_path) {
   LAST_KNOWN_EDITOR_CONFIGS.delete(normalized_project_path);
-  const config_path = import_path4.join(project_path, ".unity-agentic", LAST_KNOWN_CONFIG_FILE);
+  const config_path = import_path5.join(project_path, ".unity-agentic", LAST_KNOWN_CONFIG_FILE);
   try {
-    if (import_fs4.existsSync(config_path)) {
-      import_fs4.unlinkSync(config_path);
+    if (import_fs5.existsSync(config_path)) {
+      import_fs5.unlinkSync(config_path);
     }
   } catch {}
 }
 function read_cached_editor_config(project_path, normalized_project_path) {
-  const config_path = import_path4.join(project_path, ".unity-agentic", LAST_KNOWN_CONFIG_FILE);
-  if (!import_fs4.existsSync(config_path)) {
+  const config_path = import_path5.join(project_path, ".unity-agentic", LAST_KNOWN_CONFIG_FILE);
+  if (!import_fs5.existsSync(config_path)) {
     return;
   }
   try {
-    const raw = import_fs4.readFileSync(config_path, "utf-8");
+    const raw = import_fs5.readFileSync(config_path, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.port !== "number" || typeof parsed.pid !== "number" || typeof parsed.version !== "string") {
       return;
@@ -2810,12 +2878,12 @@ function read_cached_editor_config(project_path, normalized_project_path) {
   }
 }
 function write_cached_editor_config(project_path, config) {
-  const config_dir = import_path4.join(project_path, ".unity-agentic");
-  const config_path = import_path4.join(config_dir, LAST_KNOWN_CONFIG_FILE);
+  const config_dir = import_path5.join(project_path, ".unity-agentic");
+  const config_path = import_path5.join(config_dir, LAST_KNOWN_CONFIG_FILE);
   try {
-    import_fs4.mkdirSync(config_dir, { recursive: true });
+    import_fs5.mkdirSync(config_dir, { recursive: true });
     ensure_gitignore_ignores_agentic_dir(project_path);
-    import_fs4.writeFileSync(config_path, JSON.stringify({
+    import_fs5.writeFileSync(config_path, JSON.stringify({
       port: config.port,
       pid: config.pid,
       version: config.version,
@@ -2824,10 +2892,10 @@ function write_cached_editor_config(project_path, config) {
   } catch {}
 }
 function normalize_project_path(project_path) {
-  const resolved_path = import_path4.resolve(project_path);
+  const resolved_path = import_path5.resolve(project_path);
   let normalized = resolved_path;
   try {
-    normalized = typeof import_fs4.realpathSync.native === "function" ? import_fs4.realpathSync.native(resolved_path) : import_fs4.realpathSync(resolved_path);
+    normalized = typeof import_fs5.realpathSync.native === "function" ? import_fs5.realpathSync.native(resolved_path) : import_fs5.realpathSync(resolved_path);
   } catch {
     normalized = resolved_path;
   }
@@ -2838,7 +2906,7 @@ function is_pid_alive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (err) {
-    if (is_record2(err) && err.code === "EPERM") {
+    if (is_record3(err) && err.code === "EPERM") {
       return true;
     }
     return false;
@@ -2865,14 +2933,29 @@ var TRANSITION_TOLERANT_COMMAND_SEMANTICS = {
   retry_delays_ms: [250, 500, 1000, 1500, 2000],
   discovery_timeout_ms: 250
 };
-var TRANSITION_TOLERANT_READ_METHODS = new Set([
-  "editor.playMode.getState",
-  "editor.console.getLogs",
-  "editor.hierarchy.snapshot",
-  "editor.hierarchy.query",
-  "editor.ui.snapshot",
-  "editor.ui.query",
-  "editor.input.map"
+var READ_RUN_TARGETS = new Set([
+  "scene.hierarchy",
+  "scene.query",
+  "query.assets",
+  "query.asset",
+  "query.scene",
+  "query.object",
+  "play.state",
+  "ui.snapshot",
+  "ui.query",
+  "input.map",
+  "tests.results",
+  "UnityAgenticTools.Util.Hierarchy.Snapshot",
+  "UnityAgenticTools.Util.Hierarchy.Query",
+  "UnityAgenticTools.Query.Assets.Find",
+  "UnityAgenticTools.Query.Assets.Info",
+  "UnityAgenticTools.Query.Scene.Hierarchy",
+  "UnityAgenticTools.Query.Scene.Object",
+  "UnityAgenticTools.Util.PlayMode.GetState",
+  "UnityAgenticTools.Util.UI.Snapshot",
+  "UnityAgenticTools.Util.UI.Query",
+  "UnityAgenticTools.Util.Input.Map",
+  "UnityAgenticTools.Util.TestRunner.GetResults"
 ]);
 var PLAY_MODE_RUN_TARGETS = new Set([
   "play.enter",
@@ -2890,36 +2973,131 @@ var PLAY_MODE_RUN_TARGETS = new Set([
 var READ_RETRYABLE_CODES = new Set([-32000, -32002, -32003, CLIENT_DISCOVERY_UNAVAILABLE_CODE]);
 var COMMAND_RETRYABLE_CODES = new Set([-32002, CLIENT_DISCOVERY_UNAVAILABLE_CODE]);
 var TRANSITION_TOLERANT_COMMAND_RETRYABLE_CODES = new Set([-32000, -32002, -32003, CLIENT_DISCOVERY_UNAVAILABLE_CODE]);
+var RELOAD_TOLERANCE_MS = 30000;
+var RELOAD_POLL_INTERVAL_MS = 500;
 async function call_editor(options) {
   const semantics = get_action_semantics(options.method, "unary", options.params);
-  const maxRetries = options.retries ?? semantics.default_retries;
-  let lastResponse;
-  for (let attempt = 0;attempt <= maxRetries; attempt++) {
-    lastResponse = await call_editor_once(options, semantics);
-    if (!should_retry_response(lastResponse, semantics)) {
-      return lastResponse;
+  const explicit_retries = options.retries !== undefined;
+  const max_retries = options.retries ?? semantics.default_retries;
+  const delays = semantics.retry_delays_ms;
+  const started = Date.now();
+  let last_response;
+  for (let attempt = 0;; attempt++) {
+    last_response = await call_editor_once(options, semantics);
+    if (!should_retry_response(last_response, semantics)) {
+      return last_response;
+    }
+    if (attempt < max_retries) {
+      await sleep(delays[Math.min(attempt, delays.length - 1)]);
+      continue;
     }
-    if (attempt < maxRetries) {
-      const delay = semantics.retry_delays_ms[Math.min(attempt, semantics.retry_delays_ms.length - 1)];
-      await new Promise((r) => setTimeout(r, delay));
+    if (explicit_retries || !within_reload_tolerance(options, started)) {
+      return last_response;
     }
+    await sleep(RELOAD_POLL_INTERVAL_MS);
   }
-  return lastResponse;
+}
+function within_reload_tolerance(options, started) {
+  if (options.port !== undefined) {
+    return false;
+  }
+  if (Date.now() - started >= RELOAD_TOLERANCE_MS) {
+    return false;
+  }
+  return !("error" in read_editor_config(options.project_path));
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var READINESS_FIELDS = [
+  "is_playing",
+  "is_paused",
+  "is_compiling",
+  "is_updating",
+  "is_playmode_transitioning",
+  "is_reloading",
+  "is_stable"
+];
+async function read_editor_readiness(port, timeout_ms) {
+  const response = await request_editor_at_port({
+    port,
+    method: "editor.bridge.getInfo",
+    timeout: timeout_ms
+  });
+  if (response.error) {
+    return { error: response.error.message };
+  }
+  if (!is_record3(response.result)) {
+    return { error: "Bridge returned no readiness fields" };
+  }
+  const info = response.result;
+  const readiness = {};
+  for (const field of READINESS_FIELDS) {
+    const value = info[field];
+    if (typeof value !== "boolean") {
+      return { error: `Bridge did not report ${field}; the installed package may be older than this CLI` };
+    }
+    readiness[field] = value;
+  }
+  return readiness;
 }
 async function stream_editor(options) {
-  const { method, params, timeout = 30000, on_event } = options;
+  const { method, params, timeout = 30000, on_event, on_error } = options;
   const semantics = get_action_semantics(method, "stream", params);
   const config = await resolve_config(options, semantics.discovery_timeout_ms);
   if ("error" in config) {
     throw new Error(config.error);
   }
-  const MAX_RECONNECTS = 5;
-  let reconnect_count = 0;
   let stopped = false;
-  return new Promise((resolve3, reject) => {
+  let reconnect_count = 0;
+  let reconnect_deadline;
+  let active_socket;
+  return new Promise((resolve4, reject) => {
     let resolved = false;
+    function stop() {
+      stopped = true;
+      try {
+        active_socket?.close();
+      } catch {}
+    }
+    function fail(error) {
+      if (stopped)
+        return;
+      stop();
+      if (!resolved) {
+        resolved = true;
+        reject(error);
+        return;
+      }
+      on_error?.(error);
+    }
+    function schedule_reconnect() {
+      if (stopped)
+        return;
+      reconnect_deadline ??= Date.now() + RELOAD_TOLERANCE_MS;
+      if (Date.now() >= reconnect_deadline) {
+        fail(new Error(`Stream lost: could not reconnect within ${RELOAD_TOLERANCE_MS}ms`));
+        return;
+      }
+      reconnect_count += 1;
+      const delay = Math.min(500 * reconnect_count, 3000);
+      setTimeout(() => {
+        if (stopped)
+          return;
+        resolve_config(options, semantics.discovery_timeout_ms).then((fresh_config) => {
+          if (stopped)
+            return;
+          if ("error" in fresh_config) {
+            schedule_reconnect();
+            return;
+          }
+          connect(`ws://127.0.0.1:${fresh_config.port}/unity-agentic`);
+        });
+      }, delay);
+    }
     function connect(url) {
       const ws = new WebSocket(url);
+      active_socket = ws;
       const request_id = generate_editor_request_id();
       const request = {
         jsonrpc: "2.0",
@@ -2928,57 +3106,77 @@ async function stream_editor(options) {
         ...params ? { params } : {}
       };
       let connected = false;
-      const timer = !resolved ? setTimeout(() => {
-        if (!connected && !resolved) {
+      let attempt_finished = false;
+      function finish_attempt() {
+        if (attempt_finished) {
+          return false;
+        }
+        attempt_finished = true;
+        clearTimeout(timer);
+        return true;
+      }
+      const timer = setTimeout(() => {
+        if (connected || !finish_attempt() || stopped)
+          return;
+        if (!resolved) {
+          stopped = true;
           reject(new Error(`Timeout connecting to ${url}`));
+          return;
         }
-      }, timeout) : null;
+        try {
+          ws.close();
+        } catch {}
+        schedule_reconnect();
+      }, timeout);
       ws.onopen = () => {
         connected = true;
-        if (timer)
-          clearTimeout(timer);
+        clearTimeout(timer);
         reconnect_count = 0;
+        reconnect_deadline = undefined;
         ws.send(JSON.stringify(request));
         if (!resolved) {
           resolved = true;
-          resolve3({ close: () => {
-            stopped = true;
-            ws.close();
-          } });
+          resolve4({ close: stop });
         }
       };
       ws.onmessage = (event) => {
+        let data;
         try {
-          const data = JSON.parse(String(event.data));
-          if ("method" in data && !("id" in data)) {
-            on_event(data);
-          }
-        } catch {}
+          data = JSON.parse(String(event.data));
+        } catch {
+          return;
+        }
+        if (typeof data !== "object" || data === null) {
+          return;
+        }
+        if ("method" in data && !("id" in data)) {
+          on_event(data);
+          return;
+        }
+        const frame = data;
+        if (frame.id === request_id && frame.error) {
+          fail(new Error(`Subscription rejected: ${frame.error.message ?? "unknown error"}`));
+        }
       };
       ws.onerror = () => {
-        if (!connected && !resolved) {
-          if (timer)
-            clearTimeout(timer);
+        if (connected || !finish_attempt() || stopped)
+          return;
+        if (!resolved) {
+          stopped = true;
           reject(new Error(`WebSocket connection failed to ${url}`));
+          return;
         }
+        schedule_reconnect();
       };
       ws.onclose = () => {
-        if (stopped)
-          return;
-        if (!connected && !resolved)
+        if (!finish_attempt() || stopped)
           return;
-        if (reconnect_count >= MAX_RECONNECTS)
+        if (!resolved) {
+          stopped = true;
+          reject(new Error(`WebSocket connection failed to ${url}`));
           return;
-        reconnect_count++;
-        const delay = Math.min(500 * reconnect_count, 3000);
-        setTimeout(async () => {
-          if (stopped)
-            return;
-          const fresh_config = await resolve_config(options, semantics.discovery_timeout_ms);
-          if ("error" in fresh_config)
-            return;
-          connect(`ws://127.0.0.1:${fresh_config.port}/unity-agentic`);
-        }, delay);
+        }
+        schedule_reconnect();
       };
     }
     connect(`ws://127.0.0.1:${config.port}/unity-agentic`);
@@ -3015,7 +3213,7 @@ function get_action_semantics(method, kind = "unary", params) {
       kind: "stream"
     };
   }
-  if (TRANSITION_TOLERANT_READ_METHODS.has(method)) {
+  if (is_read_invoke(method, params)) {
     return TRANSITION_TOLERANT_READ_SEMANTICS;
   }
   if (is_play_mode_transition_invoke(method, params)) {
@@ -3023,6 +3221,16 @@ function get_action_semantics(method, kind = "unary", params) {
   }
   return DEFAULT_ACTION_SEMANTICS;
 }
+function is_read_invoke(method, params) {
+  if (method !== "editor.invoke" || !params) {
+    return false;
+  }
+  if (params.type !== "UnityAgenticTools.Commands.Registry" || params.member !== "Run") {
+    return false;
+  }
+  const target = parse_registry_run_target(params.args);
+  return typeof target === "string" && READ_RUN_TARGETS.has(target);
+}
 function is_play_mode_transition_invoke(method, params) {
   if (method !== "editor.invoke" || !params) {
     return false;
@@ -3087,19 +3295,45 @@ function resolve_bridge_options(options) {
 function build_registry_args(values) {
   return JSON.stringify(values);
 }
-function output_rpc_response(response) {
+function resolve_install_options(options) {
+  if (options.remote && options.local !== undefined) {
+    return { error: "Use either --local or --remote, not both." };
+  }
+  if (options.remote) {
+    return { remote: true };
+  }
+  if (typeof options.local === "string") {
+    return {
+      local_package_path: path.resolve(options.local),
+      require_local: true
+    };
+  }
+  if (options.local === true) {
+    return { require_local: true };
+  }
+  return {};
+}
+function print_json(value, pretty) {
+  console.log(JSON.stringify(value, null, pretty ? 2 : 0));
+}
+function output_rpc_response(response, pretty) {
   if (response.error) {
-    console.log(JSON.stringify({ success: false, error: response.error.message, code: response.error.code }, null, 2));
+    print_json({
+      success: false,
+      error: response.error.message,
+      code: response.error.code,
+      ...response.error.data !== undefined ? { data: response.error.data } : {}
+    }, pretty);
     process.exitCode = 1;
     return;
   }
-  console.log(JSON.stringify(response.result, null, 2));
+  print_json(response.result, pretty);
   if (payload_reports_failure(response.result)) {
     process.exitCode = 1;
   }
 }
 function payload_reports_failure(payload) {
-  if (!is_record3(payload)) {
+  if (!is_record4(payload)) {
     return false;
   }
   if (payload.success === false) {
@@ -3107,9 +3341,30 @@ function payload_reports_failure(payload) {
   }
   return payload_reports_failure(payload.result);
 }
-function is_record3(value) {
+function is_record4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function strip_command_listing_details(payload) {
+  if (!is_record4(payload)) {
+    return payload;
+  }
+  if (Array.isArray(payload.commands)) {
+    return {
+      ...payload,
+      commands: payload.commands.map((entry) => {
+        if (!is_record4(entry)) {
+          return entry;
+        }
+        const { args: _args, source: _source, ...brief } = entry;
+        return brief;
+      })
+    };
+  }
+  if ("result" in payload) {
+    return { ...payload, result: strip_command_listing_details(payload.result) };
+  }
+  return payload;
+}
 function event_matches_topic(event, topic, type_filter) {
   if (topic === "console") {
     if (event.method !== "editor.console.logReceived") {
@@ -3133,13 +3388,12 @@ function event_matches_topic(event, topic, type_filter) {
   return false;
 }
 function print_stream_event(event, pretty = false) {
-  const payload = {
+  print_json({
     method: event.method,
     ...event.params ? event.params : {}
-  };
-  console.log(JSON.stringify(payload, null, pretty ? 2 : 0));
+  }, pretty);
 }
-program.command("list [query]").description("List runnable Unity commands and project script commands").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--timeout <ms>", "WebSocket timeout in ms", "10000").option("--port <n>", "Connect to a specific bridge port").option("--raw", "Include raw public static methods/properties for matching types").action(async (query, options) => {
+program.command("list [query]").description("List runnable Unity commands and project script commands").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--timeout <ms>", "WebSocket timeout in ms", "10000").option("--port <n>", "Connect to a specific bridge port").option("--raw", "Include raw public static methods/properties for matching types").option("--brief", "List names and descriptions only, omit args").option("--pretty", "Pretty-print JSON output").action(async (query, options) => {
   const bridge = resolve_bridge_options(options);
   const response = await call_editor({
     ...bridge,
@@ -3150,9 +3404,12 @@ program.command("list [query]").description("List runnable Unity commands and pr
       args: build_registry_args([query || "", options.raw === true ? "true" : "false"])
     }
   });
-  output_rpc_response(response);
+  if (options.brief === true && !response.error) {
+    response.result = strip_command_listing_details(response.result);
+  }
+  output_rpc_response(response, options.pretty === true);
 });
-program.command("run <target> [args...]").description("Run a named Unity command or raw static method/property").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--timeout <ms>", "WebSocket timeout in ms", "60000").option("--port <n>", "Connect to a specific bridge port").option("--args <json>", "JSON array of command arguments (overrides positional args)").option("--set <value>", "Set a static property value").option("--no-wait", "Fire and forget -- return immediately without waiting for result").action(async (target, args, options) => {
+program.command("run <target> [args...]").description("Run a named Unity command or raw static method/property").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--timeout <ms>", "WebSocket timeout in ms", "60000").option("--port <n>", "Connect to a specific bridge port").option("--args <json>", "JSON array of command arguments (overrides positional args)").option("--set <value>", "Set a static property value").option("--no-wait", "Fire and forget -- return immediately without waiting for result").option("--pretty", "Pretty-print JSON output").action(async (target, args, options) => {
   const bridge = resolve_bridge_options(options);
   const command_args_json = options.args || JSON.stringify(args);
   const registry_args = options.set !== undefined ? [target, command_args_json, options.set] : [target, command_args_json];
@@ -3166,16 +3423,16 @@ program.command("run <target> [args...]").description("Run a named Unity command
       args: build_registry_args(registry_args)
     }
   });
-  output_rpc_response(response);
+  output_rpc_response(response, options.pretty === true);
 });
 program.command("stream [topic]").description("Stream Unity bridge events over WebSocket (default: console)").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--timeout <ms>", "WebSocket timeout in ms", "30000").option("--port <n>", "Connect to a specific bridge port").option("-t, --type <type>", "Console log type filter").option("--duration <ms>", "Stop after duration in ms (0 = indefinite)", "0").option("--pretty", "Pretty-print JSON events").action(async (topic_raw, options) => {
   const topic = (topic_raw || "console").toLowerCase();
   const valid_topics = ["console", "events", "playmode", "tests"];
   if (!valid_topics.includes(topic)) {
-    console.log(JSON.stringify({
+    print_json({
       success: false,
       error: `Invalid stream topic "${topic}". Use: ${valid_topics.join(", ")}`
-    }, null, 2));
+    }, options.pretty === true);
     process.exitCode = 1;
     return;
   }
@@ -3189,6 +3446,10 @@ program.command("stream [topic]").description("Stream Unity bridge events over W
         if (event_matches_topic(event, topic, options.type)) {
           print_stream_event(event, options.pretty === true);
         }
+      },
+      on_error: (err) => {
+        print_json({ success: false, error: err.message }, options.pretty === true);
+        process.exit(1);
       }
     });
     if (duration > 0) {
@@ -3203,43 +3464,53 @@ program.command("stream [topic]").description("Stream Unity bridge events over W
       });
     }
   } catch (err) {
-    console.log(JSON.stringify({
+    print_json({
       success: false,
       error: err instanceof Error ? err.message : String(err)
-    }, null, 2));
+    }, options.pretty === true);
     process.exitCode = 1;
   }
 });
-program.command("install").description("Install the Unity command bridge package into a Unity project").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").action((options) => {
+program.command("install").description("Install the Unity command bridge package into a Unity project").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--local [path]", "Install from a local unity-package path; auto-detects source checkout when omitted").option("--remote", "Force the published GitHub bridge package URL").option("--pretty", "Pretty-print JSON output").action((options) => {
   const bridge = resolve_bridge_options(options);
-  const result = install_bridge_package(bridge.project_path);
+  const pretty = options.pretty === true;
+  const install_options = resolve_install_options(options);
+  if ("error" in install_options) {
+    print_json({ success: false, error: install_options.error }, pretty);
+    process.exitCode = 1;
+    return;
+  }
+  const result = install_bridge_package(bridge.project_path, install_options);
   if ("error" in result) {
-    console.log(JSON.stringify({ success: false, error: result.error }, null, 2));
+    print_json({ success: false, error: result.error }, pretty);
     process.exitCode = 1;
     return;
   }
-  console.log(JSON.stringify(result, null, 2));
+  print_json(result, pretty);
 });
-program.command("uninstall").description("Remove the Unity command bridge package from a Unity project").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").action((options) => {
+program.command("uninstall").description("Remove the Unity command bridge package from a Unity project").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--pretty", "Pretty-print JSON output").action((options) => {
   const bridge = resolve_bridge_options(options);
+  const pretty = options.pretty === true;
   const result = remove_package(bridge.project_path, BRIDGE_PACKAGE_NAME2);
   if ("error" in result) {
-    console.log(JSON.stringify({ success: false, error: result.error }, null, 2));
+    print_json({ success: false, error: result.error }, pretty);
     process.exitCode = 1;
     return;
   }
-  console.log(JSON.stringify(result, null, 2));
+  print_json(result, pretty);
 });
-program.command("cleanup").description("Clean Unity Agentic Tools project state").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--stale", "Remove stale bridge lock state (default)").option("--cache", "Remove rebuildable project caches").option("--all", "Remove the entire .unity-agentic directory").action((options) => {
+program.command("cleanup").description("Clean Unity Agentic Tools project state").option("-p, --project <path>", "Path to Unity project (defaults to cwd)").option("--stale", "Remove stale bridge lock state (default)").option("--cache", "Remove rebuildable project caches").option("--all", "Remove the entire .unity-agentic directory").option("--pretty", "Pretty-print JSON output").action((options) => {
   const result = cleanup(options);
+  print_json(result, options.pretty === true);
   if (!result.success) {
-    console.log(JSON.stringify(result, null, 2));
     process.exitCode = 1;
-    return;
   }
-  console.log(JSON.stringify(result, null, 2));
 });
-program.command("status").description("Show Unity command bridge status").option("-p, --project <path>", "Path to Unity project (defaults to current directory)").option("--timeout <ms>", "WebSocket timeout in ms", "2000").option("--port <n>", "Connect to a specific bridge port").action(async (options) => {
+async function describe_readiness(port, timeout_ms) {
+  const readiness = await read_editor_readiness(port, timeout_ms);
+  return "error" in readiness ? { readiness_error: readiness.error } : { readiness };
+}
+program.command("status").description("Show Unity command bridge status").option("-p, --project <path>", "Path to Unity project (defaults to current directory)").option("--timeout <ms>", "WebSocket timeout in ms", "2000").option("--port <n>", "Connect to a specific bridge port").option("--pretty", "Pretty-print JSON output").action(async (options) => {
   const bridge = resolve_bridge_options(options);
   const projectPath = bridge.project_path;
   const status = {
@@ -3253,7 +3524,7 @@ program.command("status").description("Show Unity command bridge status").option
       port: bridge.port,
       source: "manual",
       reachable: ping.reachable,
-      ...ping.reachable ? {} : { error: ping.error }
+      ...ping.reachable ? await describe_readiness(bridge.port, bridge.timeout) : { error: ping.error }
     };
   } else {
     const editor_config = await discover_editor_config(projectPath, bridge.timeout);
@@ -3271,11 +3542,11 @@ program.command("status").description("Show Unity command bridge status").option
         source: editor_config.source ?? "lockfile",
         project_path: editor_config.project_path,
         reachable: ping.reachable,
-        ...ping.reachable ? {} : { error: ping.error }
+        ...ping.reachable ? await describe_readiness(editor_config.port, bridge.timeout) : { error: ping.error }
       };
     }
   }
-  console.log(JSON.stringify(status, null, 2));
+  print_json(status, options.pretty === true);
 });
 program.parse();
 })