unity-agentic-tools 0.3.1 → 0.3.2

package/dist/cli.js

@@ -2170,6 +2170,7 @@ __export(exports_scanner, {
   getNativeExtractCsharpTypes: () => getNativeExtractCsharpTypes,
   getNativeBuildTypeRegistry: () => getNativeBuildTypeRegistry,
   getNativeBuildPackageGuidCache: () => getNativeBuildPackageGuidCache,
+  getNativeBuildLocalPackageGuidCache: () => getNativeBuildLocalPackageGuidCache,
   getNativeBuildGuidCache: () => getNativeBuildGuidCache,
   UnityScanner: () => UnityScanner
 });
@@ -2250,13 +2251,16 @@ function getNativeExtractDllTypes() {
 function getNativeBuildPackageGuidCache() {
   return nativeBuildPackageGuidCache;
 }
+function getNativeBuildLocalPackageGuidCache() {
+  return nativeBuildLocalPackageGuidCache;
+}
 function getNativeExtractSerializedFields() {
   return nativeExtractSerializedFields;
 }
 function getNativeExtractDllFields() {
   return nativeExtractDllFields;
 }
-var import_module, import_fs, import_path, __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src", RustScanner = null, nativeModuleError = null, nativeWalkProjectFiles = null, nativeGrepProject = null, nativeBuildGuidCache = null, nativeExtractCsharpTypes = null, nativeBuildTypeRegistry = null, nativeExtractDllTypes = null, nativeBuildPackageGuidCache = null, nativeExtractSerializedFields = null, nativeExtractDllFields = null;
+var import_module, import_fs, import_path, __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src", RustScanner = null, nativeModuleError = null, nativeWalkProjectFiles = null, nativeGrepProject = null, nativeBuildGuidCache = null, nativeExtractCsharpTypes = null, nativeBuildTypeRegistry = null, nativeExtractDllTypes = null, nativeBuildPackageGuidCache = null, nativeBuildLocalPackageGuidCache = null, nativeExtractSerializedFields = null, nativeExtractDllFields = null;
 var init_scanner = __esm(() => {
   import_module = require("module");
   import_fs = require("fs");
@@ -2280,6 +2284,7 @@ var init_scanner = __esm(() => {
     nativeBuildTypeRegistry = rustModule.buildTypeRegistry || null;
     nativeExtractDllTypes = rustModule.extractDllTypes || null;
     nativeBuildPackageGuidCache = rustModule.buildPackageGuidCache || null;
+    nativeBuildLocalPackageGuidCache = rustModule.buildLocalPackageGuidCache || null;
     nativeExtractSerializedFields = rustModule.extractSerializedFields || null;
     nativeExtractDllFields = rustModule.extractDllFields || null;
   } catch (err) {
@@ -2294,7 +2299,7 @@ var require_package = __commonJS((exports2, module2) => {
   module2.exports = {
     name: "unity-agentic-tools",
     packageManager: "bun@latest",
-    version: "0.3.1",
+    version: "0.3.2",
     description: "Fast, token-efficient Unity YAML parser for AI agents",
     exports: {
       ".": {
@@ -2386,6 +2391,7 @@ var CONFIG_DIR = ".unity-agentic";
 var CONFIG_FILE = "config.json";
 var GUID_CACHE_FILE = "guid-cache.json";
 var PACKAGE_CACHE_FILE = "package-cache.json";
+var LOCAL_PACKAGE_CACHE_FILE = "local-package-cache.json";
 var TYPE_REGISTRY_FILE = "type-registry.json";
 var DOC_INDEX_FILE = "doc-index.json";
 function setup(options = {}) {
@@ -2429,6 +2435,17 @@ function setup(options = {}) {
       packageGuidCount = Object.keys(packageCache).length;
     } catch {}
   }
+  const nativeLocalPkgBuild = getNativeBuildLocalPackageGuidCache();
+  if (nativeLocalPkgBuild) {
+    try {
+      const localPkgCache = nativeLocalPkgBuild(projectPath);
+      const localPkgCount = Object.keys(localPkgCache).length;
+      if (localPkgCount > 0) {
+        const localPkgCachePath = import_path2.join(configPath, LOCAL_PACKAGE_CACHE_FILE);
+        import_fs2.writeFileSync(localPkgCachePath, JSON.stringify(localPkgCache, null, 2));
+      }
+    } catch {}
+  }
   let typeRegistryCreated = false;
   let typeCount;
   const nativeRegistryBuild = getNativeBuildTypeRegistry();
@@ -2578,7 +2595,7 @@ function removeDirectoryRecursive(dir) {
 }
 
 // src/cmd-create.ts
-var import_fs15 = require("fs");
+var import_fs16 = require("fs");
 var import_path7 = require("path");
 var import_crypto2 = require("crypto");
 
@@ -2622,31 +2639,44 @@ function atomicWrite(filePath, content) {
       };
     }
   }
-  const tmpPath = `${filePath}.tmp`;
+  const suffix = `${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  const tmpPath = `${filePath}.${suffix}.tmp`;
+  const bakPath = `${filePath}.${suffix}.bak`;
+  let bakCreated = false;
   try {
     import_fs4.writeFileSync(tmpPath, content, "utf-8");
-    if (import_fs4.existsSync(filePath)) {
-      import_fs4.renameSync(filePath, `${filePath}.bak`);
-    }
-    import_fs4.renameSync(tmpPath, filePath);
     try {
-      if (import_fs4.existsSync(`${filePath}.bak`)) {
-        import_fs4.unlinkSync(`${filePath}.bak`);
+      import_fs4.renameSync(filePath, bakPath);
+      bakCreated = true;
+    } catch (err) {
+      if (is_enoent(err)) {
+        bakCreated = false;
+      } else {
+        throw err;
       }
-    } catch {}
+    }
+    import_fs4.renameSync(tmpPath, filePath);
+    if (bakCreated) {
+      try {
+        import_fs4.unlinkSync(bakPath);
+      } catch {}
+    }
     return {
       success: true,
       file_path: filePath,
       bytes_written: Buffer.byteLength(content, "utf-8")
     };
   } catch (error) {
-    if (import_fs4.existsSync(`${filePath}.bak`)) {
+    if (bakCreated) {
       try {
-        import_fs4.renameSync(`${filePath}.bak`, filePath);
+        import_fs4.renameSync(bakPath, filePath);
       } catch (restoreError) {
         console.error("Failed to restore backup:", restoreError);
       }
     }
+    try {
+      import_fs4.unlinkSync(tmpPath);
+    } catch {}
     return {
       success: false,
       file_path: filePath,
@@ -2654,6 +2684,12 @@ function atomicWrite(filePath, content) {
     };
   }
 }
+function is_enoent(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+function normalize_property_path(path) {
+  return path.replace(/\.Array\.data\.(\d+)/g, ".Array.data[$1]");
+}
 function is_match_all(pattern) {
   return pattern === "*" || pattern === "." || pattern === "**" || pattern === ".*";
 }
@@ -3032,6 +3068,31 @@ function extractGuidFromMeta(metaPath) {
     return null;
   }
 }
+function resolve_source_prefab(doc, file_path, project_path) {
+  const pi_blocks = doc.find_by_class_id(1001);
+  if (pi_blocks.length === 0)
+    return null;
+  const pi_block = pi_blocks[0];
+  const source_match = pi_block.raw.match(/m_SourcePrefab:[ \t]*\{[^}]*guid:[ \t]*([a-f0-9]{32})/);
+  if (!source_match)
+    return null;
+  const source_guid = source_match[1];
+  const resolved_project = project_path || find_unity_project_root(path.dirname(file_path));
+  if (!resolved_project)
+    return null;
+  const cache = load_guid_cache_for_file(file_path, resolved_project);
+  if (!cache)
+    return null;
+  const source_path = cache.resolve_absolute(source_guid);
+  if (!source_path || !import_fs6.existsSync(source_path))
+    return null;
+  return {
+    source_guid,
+    source_path,
+    prefab_instance_id: pi_block.file_id,
+    prefab_instance_block: pi_block
+  };
+}
 function resolveScriptGuid(script, projectPath) {
   if (/^[a-f0-9]{32}$/i.test(script)) {
     return { guid: script.toLowerCase(), path: null };
@@ -3081,27 +3142,122 @@ function resolveScriptGuid(script, projectPath) {
             return false;
           return true;
         });
-        if (matches.length === 1 && matches[0].guid) {
-          return { guid: matches[0].guid, path: matches[0].filePath };
+        if (matches.length === 1) {
+          if (matches[0].guid) {
+            return { guid: matches[0].guid, path: matches[0].filePath };
+          }
+          if (matches[0].filePath && projectPath) {
+            const fullFilePath = path.isAbsolute(matches[0].filePath) ? matches[0].filePath : path.join(projectPath, matches[0].filePath);
+            const metaPath = fullFilePath + ".meta";
+            if (import_fs6.existsSync(metaPath)) {
+              const guid = extractGuidFromMeta(metaPath);
+              if (guid)
+                return { guid, path: matches[0].filePath };
+            }
+            if (matches[0].filePath.startsWith("Packages/")) {
+              const pkgPath = path.join(projectPath, matches[0].filePath);
+              const pkgMetaPath = pkgPath + ".meta";
+              if (import_fs6.existsSync(pkgMetaPath)) {
+                const guid = extractGuidFromMeta(pkgMetaPath);
+                if (guid)
+                  return { guid, path: matches[0].filePath };
+              }
+            }
+            if (matches[0].filePath?.endsWith(".dll")) {
+              const dllBasename = path.basename(matches[0].filePath).toLowerCase();
+              for (const cacheName of ["package-cache.json", "local-package-cache.json"]) {
+                const cachePath = path.join(projectPath, ".unity-agentic", cacheName);
+                if (!import_fs6.existsSync(cachePath))
+                  continue;
+                try {
+                  const cache = JSON.parse(import_fs6.readFileSync(cachePath, "utf-8"));
+                  for (const [guid, assetPath] of Object.entries(cache)) {
+                    if (assetPath.toLowerCase().endsWith(".dll") && path.basename(assetPath).toLowerCase() === dllBasename) {
+                      return { guid, path: assetPath };
+                    }
+                  }
+                } catch {}
+              }
+            }
+          }
         }
         if (matches.length > 1) {
           const withGuid = matches.filter((m) => m.guid);
           if (withGuid.length === 1) {
             return { guid: withGuid[0].guid, path: withGuid[0].filePath };
           }
+          const resolvedFromMeta = matches.filter((m) => !m.guid && m.filePath).map((m) => {
+            const fullPath = path.isAbsolute(m.filePath) ? m.filePath : path.join(projectPath, m.filePath);
+            let guid = import_fs6.existsSync(fullPath + ".meta") ? extractGuidFromMeta(fullPath + ".meta") : null;
+            if (!guid && m.filePath.startsWith("Packages/")) {
+              const pkgPath = path.join(projectPath, m.filePath);
+              if (import_fs6.existsSync(pkgPath + ".meta")) {
+                guid = extractGuidFromMeta(pkgPath + ".meta");
+              }
+            }
+            if (!guid && m.filePath?.endsWith(".dll")) {
+              const dllBase = path.basename(m.filePath).toLowerCase();
+              for (const cn of ["package-cache.json", "local-package-cache.json"]) {
+                const cp = path.join(projectPath, ".unity-agentic", cn);
+                if (!import_fs6.existsSync(cp))
+                  continue;
+                try {
+                  const c = JSON.parse(import_fs6.readFileSync(cp, "utf-8"));
+                  for (const [g, p] of Object.entries(c)) {
+                    if (p.toLowerCase().endsWith(".dll") && path.basename(p).toLowerCase() === dllBase) {
+                      guid = g;
+                      break;
+                    }
+                  }
+                } catch {}
+                if (guid)
+                  break;
+              }
+            }
+            return guid ? { guid, path: m.filePath } : null;
+          }).filter((r) => r !== null);
+          const allResolved = [...withGuid.map((m) => ({ guid: m.guid, path: m.filePath })), ...resolvedFromMeta];
+          if (allResolved.length === 1) {
+            return allResolved[0];
+          }
+          if (allResolved.length > 1) {
+            const pkgCachePaths = [
+              path.join(projectPath, ".unity-agentic", "package-cache.json"),
+              path.join(projectPath, ".unity-agentic", "local-package-cache.json")
+            ];
+            for (const cachePath of pkgCachePaths) {
+              if (!import_fs6.existsSync(cachePath))
+                continue;
+              try {
+                const cache = JSON.parse(import_fs6.readFileSync(cachePath, "utf-8"));
+                const inCache = allResolved.filter((r) => (r.guid in cache));
+                if (inCache.length === 1)
+                  return inCache[0];
+              } catch {}
+            }
+            const paths = allResolved.map((m) => m.path).join(", ");
+            throw new Error(`Ambiguous type "${script}": found ${allResolved.length} matches (${paths}). ` + `Use a qualified name (e.g., "Namespace.${targetName}") or provide the full path.`);
+          }
         }
       } catch {}
     }
-    const packageCachePath = path.join(projectPath, ".unity-agentic", "package-cache.json");
-    if (import_fs6.existsSync(packageCachePath)) {
+    const scriptNameLower = script.toLowerCase().replace(/\.cs$/, "");
+    const dotIdx = scriptNameLower.lastIndexOf(".");
+    const classNameOnly = dotIdx > 0 ? scriptNameLower.substring(dotIdx + 1) : null;
+    const cachePaths = [
+      path.join(projectPath, ".unity-agentic", "package-cache.json"),
+      path.join(projectPath, ".unity-agentic", "local-package-cache.json")
+    ];
+    for (const cachePath of cachePaths) {
+      if (!import_fs6.existsSync(cachePath))
+        continue;
       try {
-        const packageCache = JSON.parse(import_fs6.readFileSync(packageCachePath, "utf-8"));
-        const scriptNameLower = script.toLowerCase().replace(/\.cs$/, "");
-        for (const [guid, assetPath] of Object.entries(packageCache)) {
+        const cache = JSON.parse(import_fs6.readFileSync(cachePath, "utf-8"));
+        for (const [guid, assetPath] of Object.entries(cache)) {
           if (!assetPath.endsWith(".cs"))
             continue;
           const fileName = path.basename(assetPath, ".cs").toLowerCase();
-          if (fileName === scriptNameLower) {
+          if (fileName === scriptNameLower || classNameOnly && fileName === classNameOnly) {
             return { guid, path: assetPath };
           }
         }
@@ -3152,6 +3308,8 @@ function resolve_script_with_fields(script, project_path) {
             result.fields = chosen.fields;
             result.base_class = chosen.baseClass ?? undefined;
             result.kind = chosen.kind;
+            result.namespace = chosen.namespace ?? undefined;
+            result.class_name = chosen.name;
           }
         } else {
           result.extraction_error = "Native extractDllFields function not available";
@@ -3347,6 +3505,16 @@ function yaml_default_for_type(csharp_type, version) {
 function generate_field_yaml(fields, version, indent = "  ") {
   const lines = [];
   for (const field of fields) {
+    if (field.hasSerializeReference) {
+      const t = field.typeName;
+      if (t.endsWith("[]") || t.startsWith("List<") && t.endsWith(">")) {
+        lines.push(`${indent}${field.name}: []`);
+      } else {
+        lines.push(`${indent}${field.name}:`);
+        lines.push(`${indent}  rid: 0`);
+      }
+      continue;
+    }
     const default_value = yaml_default_for_type(field.typeName, version);
     if (default_value === null) {
       continue;
@@ -3390,6 +3558,17 @@ function parse_header(raw) {
 function escape_regex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function yaml_quote_if_needed(value) {
+  if (value === "")
+    return value;
+  if (value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]")) {
+    return value;
+  }
+  if (value.includes(": ") || value.includes(" #") || /^[#\{\[*&!|>'"]/.test(value) || value !== value.trim()) {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return value;
+}
 
 class UnityBlock {
   _raw;
@@ -3425,6 +3604,7 @@ class UnityBlock {
     return this._dirty;
   }
   get_property(path2) {
+    path2 = normalize_property_path(path2);
     if (path2.includes("Array.data[")) {
       return this._get_array_element(path2);
     }
@@ -3451,13 +3631,17 @@ class UnityBlock {
     return match ? match[1].trim() : null;
   }
   set_property(path2, value, object_reference) {
+    path2 = normalize_property_path(path2);
     const old_raw = this._raw;
     const effective_ref = object_reference && object_reference !== "{fileID: 0}" ? object_reference : undefined;
     if (!path2.includes(".") && !path2.includes("Array")) {
       const prop_pattern = new RegExp(`(^\\s*${escape_regex(path2)}:\\s*)(.*)$`, "m");
       if (prop_pattern.test(this._raw)) {
-        const replacement_value = effective_ref ?? value;
-        this._raw = this._raw.replace(prop_pattern, `$1${replacement_value}`);
+        const replacement_value = effective_ref ?? yaml_quote_if_needed(value);
+        this._raw = this._raw.replace(prop_pattern, (_match, prefix) => prefix + replacement_value);
+      } else {
+        const insert_value = effective_ref ?? yaml_quote_if_needed(value);
+        this._insert_property(path2, insert_value);
       }
       return this._check_dirty(old_raw);
     }
@@ -3472,8 +3656,8 @@ class UnityBlock {
         const fields = inline_match[2];
         const field_pattern = new RegExp(`(${escape_regex(sub_field)}:\\s*)([^,}]+)`);
         if (field_pattern.test(fields)) {
-          const updated_fields = fields.replace(field_pattern, `$1${value}`);
-          this._raw = this._raw.replace(inline_pattern, `$1${updated_fields}$3`);
+          const updated_fields = fields.replace(field_pattern, (_m, prefix) => prefix + value);
+          this._raw = this._raw.replace(inline_pattern, (_m, g1, _g2, g3) => g1 + updated_fields + g3);
           inline_applied = true;
         }
       }
@@ -3482,6 +3666,8 @@ class UnityBlock {
         const block_result = this._resolve_block_style_path(parts, effective_value);
         if (block_result !== null) {
           this._raw = block_result;
+        } else if (parts.length === 2) {
+          this._insert_struct_property(parent_prop, sub_field, effective_value);
         }
       }
       return this._check_dirty(old_raw);
@@ -3499,7 +3685,7 @@ class UnityBlock {
 `).filter((l) => l.trim().startsWith("-"));
           if (index < lines.length) {
             const old_line = lines[index];
-            const new_line = old_line.replace(/-\s*.*/, `- ${ref_value}`);
+            const new_line = old_line.replace(/-\s*.*/, () => `- ${ref_value}`);
             this._raw = this._raw.replace(old_line, new_line);
           }
         }
@@ -3508,6 +3694,44 @@ class UnityBlock {
     }
     return false;
   }
+  _insert_property(path2, value) {
+    const alt = path2.startsWith("m_") ? path2.slice(2) : "m_" + path2;
+    const alt_pattern = new RegExp(`^\\s*${escape_regex(alt)}:`, "m");
+    if (alt_pattern.test(this._raw)) {
+      return;
+    }
+    const indented_line = `  ${path2}: ${value}`;
+    const eci_pattern = /^([ \t]*m_EditorClassIdentifier:[ \t]*[^\n]*)/m;
+    const eci_match = this._raw.match(eci_pattern);
+    if (eci_match && eci_match.index !== undefined) {
+      const insert_after = eci_match.index + eci_match[0].length;
+      this._raw = this._raw.slice(0, insert_after) + `
+` + indented_line + this._raw.slice(insert_after);
+      return;
+    }
+    this._raw = this._raw.trimEnd() + `
+` + indented_line + `
+`;
+  }
+  _insert_struct_property(parent, child, value) {
+    const parent_pattern = new RegExp(`^[ 	]*${escape_regex(parent)}:`, "m");
+    if (parent_pattern.test(this._raw)) {
+      return;
+    }
+    const struct_block = `  ${parent}:
+    ${child}: ${value}`;
+    const eci_pattern = /^([ \t]*m_EditorClassIdentifier:[ \t]*[^\n]*)/m;
+    const eci_match = this._raw.match(eci_pattern);
+    if (eci_match && eci_match.index !== undefined) {
+      const insert_after = eci_match.index + eci_match[0].length;
+      this._raw = this._raw.slice(0, insert_after) + `
+` + struct_block + this._raw.slice(insert_after);
+      return;
+    }
+    this._raw = this._raw.trimEnd() + `
+` + struct_block + `
+`;
+  }
   has_property(path2) {
     return this.get_property(path2) !== null;
   }
@@ -3563,7 +3787,7 @@ class UnityBlock {
     if (empty_match) {
       const base_indent = empty_match[2];
       const element_indent2 = base_indent + "  ";
-      this._raw = this._raw.replace(empty_pattern, `$1
+      this._raw = this._raw.replace(empty_pattern, (_m, g1) => `${g1}
 ${element_indent2}- ${value}`);
       return this._check_dirty(old_raw);
     }
@@ -4508,6 +4732,20 @@ function get_project_info(projectPath) {
 }
 
 // src/editor/create.ts
+function compute_dll_script_file_id(namespace, class_name) {
+  const { createHash } = require("crypto");
+  const full_name = namespace ? `${namespace}.${class_name}` : class_name;
+  const name_bytes = Buffer.from(full_name, "utf-8");
+  const input = Buffer.alloc(4 + name_bytes.length);
+  input.writeInt32LE(114, 0);
+  name_bytes.copy(input, 4);
+  const hash = createHash("md4").update(input).digest();
+  const a = hash.readInt32LE(0);
+  const b = hash.readInt32LE(4);
+  const c = hash.readInt32LE(8);
+  const d = hash.readInt32LE(12);
+  return a ^ b ^ c ^ d;
+}
 function get_layer_from_parent(doc, parentTransformId) {
   if (parentTransformId === "0")
     return 0;
@@ -4523,7 +4761,7 @@ function get_layer_from_parent(doc, parentTransformId) {
   const layerMatch = parentGo.raw.match(/m_Layer:\s*(\d+)/);
   return layerMatch ? parseInt(layerMatch[1], 10) : 0;
 }
-function createGameObjectYAML(gameObjectId, transformId, name, parentTransformId = 0, rootOrder = 0, layer = 0) {
+function createGameObjectYAML(gameObjectId, transformId, name, parentTransformId = "0", rootOrder = 0, layer = 0) {
   return `--- !u!1 &${gameObjectId}
 GameObject:
   m_ObjectHideFlags: 0
@@ -4584,9 +4822,9 @@ function findStrippedRootTransform(doc, prefabInstanceId) {
   for (const block of doc.blocks) {
     if (block.class_id !== 4 || !block.is_stripped)
       continue;
-    const piMatch = block.raw.match(/m_PrefabInstance:\s*\{fileID:\s*(\d+)\}/);
+    const piMatch = block.raw.match(/m_PrefabInstance:[ \t]*\{fileID:[ \t]*(-?\d+)\}/);
     if (piMatch && piMatch[1] === prefabInstanceId) {
-      const sourceMatch = block.raw.match(/m_CorrespondingSourceObject:\s*(\{[^}]+\})/);
+      const sourceMatch = block.raw.match(/m_CorrespondingSourceObject:[ \t]*(\{[^}]+\})/);
       if (sourceMatch) {
         return {
           transformId: block.file_id,
@@ -4597,6 +4835,66 @@ function findStrippedRootTransform(doc, prefabInstanceId) {
   }
   return null;
 }
+function find_game_object_in_variant(doc, name, file_path, project_path) {
+  const pi_blocks = doc.find_by_class_id(1001);
+  for (const pi_block of pi_blocks) {
+    const mod_pattern = /- target:[ \t]*(\{[^}]+\})\s*propertyPath:[ \t]*m_Name\s*value:[ \t]*([^\n]*)/g;
+    let mod_match;
+    while ((mod_match = mod_pattern.exec(pi_block.raw)) !== null) {
+      const target_ref = mod_match[1];
+      const mod_value = mod_match[2].trim();
+      if (mod_value !== name)
+        continue;
+      for (const block of doc.blocks) {
+        if (block.class_id !== 1 || !block.is_stripped)
+          continue;
+        const source_match = block.raw.match(/m_CorrespondingSourceObject:[ \t]*(\{[^}]+\})/);
+        if (!source_match)
+          continue;
+        const normalized_source = source_match[1].replace(/\s+/g, " ");
+        const normalized_target = target_ref.replace(/\s+/g, " ");
+        if (normalized_source === normalized_target) {
+          return {
+            stripped_go_id: block.file_id,
+            source_ref: target_ref,
+            prefab_instance_id: pi_block.file_id
+          };
+        }
+      }
+    }
+  }
+  const source_info = resolve_source_prefab(doc, file_path, project_path);
+  if (!source_info)
+    return null;
+  let source_doc;
+  try {
+    source_doc = UnityDocument.from_file(source_info.source_path);
+  } catch {
+    return null;
+  }
+  const source_gos = source_doc.find_game_objects_by_name(name);
+  if (source_gos.length !== 1)
+    return null;
+  const source_go = source_gos[0];
+  const source_go_file_id = source_go.file_id;
+  const source_guid = source_info.source_guid;
+  for (const block of doc.blocks) {
+    if (block.class_id !== 1 || !block.is_stripped)
+      continue;
+    const source_match = block.raw.match(/m_CorrespondingSourceObject:[ \t]*\{[^}]*fileID:[ \t]*(-?\d+)[^}]*guid:[ \t]*([a-f0-9]{32})/);
+    if (!source_match)
+      continue;
+    if (source_match[1] === source_go_file_id && source_match[2] === source_guid) {
+      const source_ref = `{fileID: ${source_go_file_id}, guid: ${source_guid}, type: 3}`;
+      return {
+        stripped_go_id: block.file_id,
+        source_ref,
+        prefab_instance_id: source_info.prefab_instance_id
+      };
+    }
+  }
+  return null;
+}
 function appendToAddedGameObjects(doc, piId, targetSourceRef, newGoId) {
   const piBlock = doc.find_by_file_id(piId);
   if (!piBlock)
@@ -4606,13 +4904,34 @@ function appendToAddedGameObjects(doc, piId, targetSourceRef, newGoId) {
       insertIndex: -1
       addedObject: {fileID: ${newGoId}}`;
   let raw = piBlock.raw;
-  const emptyPattern = /m_AddedGameObjects:\s*\[\]/;
+  const emptyPattern = /m_AddedGameObjects:[ \t]*\[\]/;
   if (emptyPattern.test(raw)) {
     raw = raw.replace(emptyPattern, `m_AddedGameObjects:${entry}`);
     piBlock.replace_raw(raw);
     return;
   }
-  const existingPattern = /(m_AddedGameObjects:\s*\n(?:\s+-[\s\S]*?(?=\n\s+m_|$))*)/;
+  const existingPattern = /(m_AddedGameObjects:[ \t]*\n(?:[ \t]+-[\s\S]*?(?=\n[ \t]+m_|$))*)/;
+  if (existingPattern.test(raw)) {
+    raw = raw.replace(existingPattern, `$1${entry}`);
+    piBlock.replace_raw(raw);
+  }
+}
+function appendToAddedComponents(doc, piId, targetSourceRef, newComponentId) {
+  const piBlock = doc.find_by_file_id(piId);
+  if (!piBlock)
+    return;
+  const entry = `
+    - targetCorrespondingSourceObject: ${targetSourceRef}
+      insertIndex: -1
+      addedObject: {fileID: ${newComponentId}}`;
+  let raw = piBlock.raw;
+  const emptyPattern = /m_AddedComponents:[ \t]*\[\]/;
+  if (emptyPattern.test(raw)) {
+    raw = raw.replace(emptyPattern, `m_AddedComponents:${entry}`);
+    piBlock.replace_raw(raw);
+    return;
+  }
+  const existingPattern = /(m_AddedComponents:[ \t]*\n(?:[ \t]+-[\s\S]*?(?=\n[ \t]+m_|$))*)/;
   if (existingPattern.test(raw)) {
     raw = raw.replace(existingPattern, `$1${entry}`);
     piBlock.replace_raw(raw);
@@ -4635,11 +4954,31 @@ var COMPONENT_DEFAULTS = {
   m_Materials:
   - {fileID: 0}`,
   33: `  m_Mesh: {fileID: 0}`,
+  50: `  m_BodyType: 0
+  m_Mass: 1
+  m_LinearDrag: 0
+  m_AngularDrag: 0.05
+  m_GravityScale: 1
+  m_Interpolate: 0
+  m_SleepingMode: 1
+  m_CollisionDetection: 0`,
   54: `  m_Mass: 1
   m_Drag: 0
   m_AngularDrag: 0.05
   m_UseGravity: 1
   m_IsKinematic: 0`,
+  58: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Radius: 0.5`,
+  60: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Points: []`,
+  61: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Size: {x: 1, y: 1}`,
   64: `  m_IsTrigger: 0
   m_Convex: 0
   m_CookingOptions: 30
@@ -4648,6 +4987,19 @@ var COMPONENT_DEFAULTS = {
   m_Material: {fileID: 0}
   m_Center: {x: 0, y: 0, z: 0}
   m_Size: {x: 1, y: 1, z: 1}`,
+  66: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_GeometryType: 0`,
+  68: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Points: []`,
+  70: `  m_IsTrigger: 0
+  m_Material: {fileID: 0}
+  m_Offset: {x: 0, y: 0}
+  m_Size: {x: 1, y: 1}
+  m_Direction: 0`,
   82: `  m_PlayOnAwake: 1
   m_Volume: 1
   m_Pitch: 1
@@ -4733,9 +5085,14 @@ function addComponentToGameObject(doc, gameObjectId, componentId) {
 `);
   goBlock.replace_raw(raw);
 }
-function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version) {
+function createMonoBehaviourYAML(componentId, gameObjectId, scriptGuid, fields, version, scriptFileId = 11500000) {
   const field_yaml = fields && fields.length > 0 ? generate_field_yaml(fields, version) : `
 `;
+  const has_serialize_ref = fields?.some((f) => f.hasSerializeReference) ?? false;
+  const references_section = has_serialize_ref ? `  references:
+    version: 2
+    RefIds: []
+` : "";
   return `--- !u!114 &${componentId}
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -4745,9 +5102,9 @@ MonoBehaviour:
   m_GameObject: {fileID: ${gameObjectId}}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: ${scriptGuid}, type: 3}
+  m_Script: {fileID: ${scriptFileId}, guid: ${scriptGuid}, type: 3}
   m_Name:
-  m_EditorClassIdentifier:${field_yaml}`;
+  m_EditorClassIdentifier:${field_yaml}${references_section}`;
 }
 function createGameObject(options) {
   const { file_path, name, parent } = options;
@@ -4846,9 +5203,9 @@ function createGameObject(options) {
   const layer = get_layer_from_parent(doc, parentTransformIdStr);
   const gameObjectIdStr = doc.generate_file_id();
   const transformIdStr = doc.generate_file_id();
-  const gameObjectId = parseInt(gameObjectIdStr, 10);
-  const transformId = parseInt(transformIdStr, 10);
-  const parentTransformId = parseInt(parentTransformIdStr, 10);
+  const gameObjectId = gameObjectIdStr;
+  const transformId = transformIdStr;
+  const parentTransformId = parentTransformIdStr;
   const newBlocks = createGameObjectYAML(gameObjectId, transformId, name.trim(), parentTransformId, rootOrder, layer);
   doc.append_raw(newBlocks);
   if (parentTransformIdStr !== "0" && !variantPiId) {
@@ -4870,7 +5227,7 @@ function createGameObject(options) {
     file_path,
     game_object_id: gameObjectId,
     transform_id: transformId,
-    prefab_instance_id: variantPiId ? parseInt(variantPiId, 10) : undefined
+    prefab_instance_id: variantPiId || undefined
   };
 }
 function createScene(options) {
@@ -5316,9 +5673,9 @@ function createPrefabVariant(options) {
   const tempDoc = UnityDocument.from_string(`%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
 `);
-  const prefabInstanceId = parseInt(tempDoc.generate_file_id(), 10);
-  const strippedGoId = parseInt(tempDoc.generate_file_id(), 10);
-  const strippedTransformId = parseInt(tempDoc.generate_file_id(), 10);
+  const prefabInstanceId = tempDoc.generate_file_id();
+  const strippedGoId = tempDoc.generate_file_id();
+  const strippedTransformId = tempDoc.generate_file_id();
   const finalName = variant_name || `${rootInfo.name} Variant`;
   const variantYaml = `%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
@@ -5434,7 +5791,7 @@ function createScriptableObject(options) {
   const baseName = path3.basename(output_path, ".asset");
   const field_yaml = resolved.fields && resolved.fields.length > 0 ? generate_field_yaml(resolved.fields, version) : `
 `;
-  const assetYaml = `%YAML 1.1
+  let assetYaml = `%YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
 --- !u!114 &11400000
 MonoBehaviour:
@@ -5448,6 +5805,16 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: ${resolved.guid}, type: 3}
   m_Name: ${baseName}
   m_EditorClassIdentifier:${field_yaml}`;
+  if (options.initial_values && Object.keys(options.initial_values).length > 0) {
+    const doc = UnityDocument.from_string(assetYaml);
+    const block = doc.blocks[0];
+    if (block) {
+      for (const [key, val] of Object.entries(options.initial_values)) {
+        block.set_property(key, val);
+      }
+      assetYaml = doc.serialize();
+    }
+  }
   try {
     import_fs8.writeFileSync(output_path, assetYaml, "utf-8");
   } catch (err) {
@@ -5528,6 +5895,80 @@ MonoImporter:
     guid
   };
 }
+var COMPONENT_BASE_CLASSES = new Set([
+  "MonoBehaviour",
+  "NetworkBehaviour",
+  "StateMachineBehaviour"
+]);
+function is_valid_component_base(base_class, project_path, depth = 0) {
+  if (depth > 5)
+    return false;
+  if (COMPONENT_BASE_CLASSES.has(base_class))
+    return true;
+  if (!project_path)
+    return false;
+  const registryPath = path3.join(project_path, ".unity-agentic", "type-registry.json");
+  if (import_fs8.existsSync(registryPath)) {
+    try {
+      const registry = JSON.parse(import_fs8.readFileSync(registryPath, "utf-8"));
+      const match = registry.find((t) => t.name === base_class && t.kind === "class");
+      if (match?.filePath) {
+        const fullPath = path3.isAbsolute(match.filePath) ? match.filePath : path3.join(project_path, match.filePath);
+        if (fullPath.endsWith(".cs") && import_fs8.existsSync(fullPath)) {
+          const { getNativeExtractSerializedFields: getNativeExtractSerializedFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+          const extract = getNativeExtractSerializedFields2();
+          if (extract) {
+            const typeInfos = extract(fullPath);
+            const info = typeInfos?.find((t) => t.name === base_class);
+            if (info?.baseClass) {
+              return is_valid_component_base(info.baseClass, project_path, depth + 1);
+            }
+          }
+        }
+        if (!fullPath.endsWith(".cs") || !import_fs8.existsSync(fullPath)) {
+          if (match.kind === "class") {
+            return is_likely_component_base_name(base_class);
+          }
+        }
+      }
+    } catch {}
+  }
+  const cachePaths = [
+    path3.join(project_path, ".unity-agentic", "package-cache.json"),
+    path3.join(project_path, ".unity-agentic", "local-package-cache.json")
+  ];
+  for (const cachePath of cachePaths) {
+    if (!import_fs8.existsSync(cachePath))
+      continue;
+    try {
+      const cache = JSON.parse(import_fs8.readFileSync(cachePath, "utf-8"));
+      const baseClassLower = base_class.toLowerCase();
+      for (const [, assetPath] of Object.entries(cache)) {
+        if (!assetPath.endsWith(".cs"))
+          continue;
+        if (path3.basename(assetPath, ".cs").toLowerCase() !== baseClassLower)
+          continue;
+        const fullPath = path3.join(project_path, assetPath);
+        if (!import_fs8.existsSync(fullPath))
+          continue;
+        const { getNativeExtractSerializedFields: getNativeExtractSerializedFields2 } = (init_scanner(), __toCommonJS(exports_scanner));
+        const extract = getNativeExtractSerializedFields2();
+        if (!extract)
+          continue;
+        const typeInfos = extract(fullPath);
+        const info = typeInfos?.find((t) => t.name === base_class);
+        if (info?.baseClass) {
+          return is_valid_component_base(info.baseClass, project_path, depth + 1);
+        }
+      }
+    } catch {}
+  }
+  return false;
+}
+function is_likely_component_base_name(name) {
+  const lower = name.toLowerCase();
+  return lower.endsWith("behaviour") || lower.endsWith("behavior") || lower.includes("monobehaviour") || lower.includes("networkbehaviour");
+}
 function addComponent(options) {
   const { file_path, game_object_name, component_type } = options;
   const project_path = options.project_path || find_unity_project_root(path3.dirname(file_path)) || undefined;
@@ -5553,11 +5994,19 @@ function addComponent(options) {
     };
   }
   const goResult = doc.require_unique_game_object(game_object_name);
+  let gameObjectIdStr;
+  let variantInfo = null;
   if ("error" in goResult) {
-    return { success: false, file_path, error: goResult.error };
+    const vResult = find_game_object_in_variant(doc, game_object_name, file_path, project_path);
+    if (!vResult) {
+      return { success: false, file_path, error: goResult.error };
+    }
+    gameObjectIdStr = vResult.stripped_go_id;
+    variantInfo = { source_ref: vResult.source_ref, prefab_instance_id: vResult.prefab_instance_id };
+  } else {
+    gameObjectIdStr = goResult.file_id;
   }
-  const gameObjectIdStr = goResult.file_id;
-  const gameObjectId = parseInt(gameObjectIdStr, 10);
+  const gameObjectId = gameObjectIdStr;
   const classId = get_class_id(component_type);
   let duplicateWarning;
   const goBlock = doc.find_by_file_id(gameObjectIdStr);
@@ -5572,7 +6021,7 @@ function addComponent(options) {
     }
   }
   const componentIdStr = doc.generate_file_id();
-  const componentId = parseInt(componentIdStr, 10);
+  const componentId = componentIdStr;
   let componentYAML;
   let scriptGuid;
   let scriptPath;
@@ -5581,7 +6030,16 @@ function addComponent(options) {
     const componentName = UNITY_CLASS_IDS[classId] || component_type;
     componentYAML = createGenericComponentYAML(componentName, classId, componentId, gameObjectId);
   } else {
-    const resolved = resolve_script_with_fields(component_type, project_path);
+    let resolved;
+    try {
+      resolved = resolve_script_with_fields(component_type, project_path);
+    } catch (e) {
+      return {
+        success: false,
+        file_path,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
     if (!resolved) {
       const hints = [];
       if (project_path) {
@@ -5608,11 +6066,11 @@ function addComponent(options) {
         error: `"${component_type}" is ${resolved.kind === "enum" ? "an enum" : "an interface"}, not a MonoBehaviour. Cannot add as a component.`
       };
     }
-    if (resolved.base_class && !["MonoBehaviour", "NetworkBehaviour", "StateMachineBehaviour"].includes(resolved.base_class)) {
+    if (resolved.base_class && !COMPONENT_BASE_CLASSES.has(resolved.base_class) && !is_valid_component_base(resolved.base_class, project_path)) {
       return {
         success: false,
         file_path,
-        error: `"${component_type}" extends ${resolved.base_class}, not MonoBehaviour. Cannot add as a component.`
+        error: `"${component_type}" extends ${resolved.base_class}, which does not inherit from MonoBehaviour. Cannot add as a component. If this is incorrect, ensure the type registry is up to date ("setup" command).`
       };
     }
     let version;
@@ -5621,12 +6079,20 @@ function addComponent(options) {
         version = read_project_version(project_path);
       } catch {}
     }
-    componentYAML = createMonoBehaviourYAML(componentId, gameObjectId, resolved.guid, resolved.fields, version);
+    let scriptFileId = 11500000;
+    if (resolved.path?.endsWith(".dll") && resolved.class_name) {
+      scriptFileId = compute_dll_script_file_id(resolved.namespace ?? "", resolved.class_name);
+    }
+    componentYAML = createMonoBehaviourYAML(componentId, gameObjectId, resolved.guid, resolved.fields, version, scriptFileId);
     scriptGuid = resolved.guid;
     scriptPath = resolved.path || undefined;
     extractionError = resolved.extraction_error;
   }
-  addComponentToGameObject(doc, gameObjectIdStr, componentIdStr);
+  if (variantInfo) {
+    appendToAddedComponents(doc, variantInfo.prefab_instance_id, variantInfo.source_ref, componentIdStr);
+  } else {
+    addComponentToGameObject(doc, gameObjectIdStr, componentIdStr);
+  }
   doc.append_raw(componentYAML);
   const saveResult = doc.save();
   if (!saveResult.success) {
@@ -5703,6 +6169,7 @@ function copyComponent(options) {
 }
 // src/editor/update.ts
 var import_fs10 = require("fs");
+var import_fs11 = require("fs");
 
 // src/settings.ts
 var import_fs9 = require("fs");
@@ -6309,6 +6776,14 @@ function edit_sorting_layer(options) {
 }
 
 // src/editor/update.ts
+function enrich_target_ref(targetRef, blockRaw) {
+  if (/guid:/.test(targetRef))
+    return targetRef;
+  const sourceMatch = blockRaw.match(/m_SourcePrefab:[ \t]*\{[^}]*guid:[ \t]*([a-f0-9]{32})/);
+  if (!sourceMatch)
+    return null;
+  return targetRef.replace(/\}$/, `, guid: ${sourceMatch[1]}, type: 3}`);
+}
 function eulerToQuaternion(euler) {
   const deg2rad = Math.PI / 180;
   const x = euler.x * deg2rad;
@@ -6331,6 +6806,9 @@ function validate_value_type(current_value, new_value) {
   const current = current_value.trim();
   const incoming = new_value.trim();
   if (/^\{fileID:/.test(current)) {
+    if (/^\{fileID:[ \t]*0[ \t]*\}$/.test(current)) {
+      return null;
+    }
     if (!/^\{fileID:/.test(incoming)) {
       return `Expected a reference value ({fileID: ...}), got "${incoming}"`;
     }
@@ -6515,10 +6993,10 @@ function safeUnityYAMLEdit(filePath, objectName, propertyName, newValue, project
   const propertyPattern = new RegExp(`(^\\s*m_${normalizedProperty}:\\s*)([^\\n]*)`, "m");
   let updatedRaw = targetBlock.raw;
   if (propertyPattern.test(updatedRaw)) {
-    updatedRaw = updatedRaw.replace(propertyPattern, `$1${newValue}`);
+    updatedRaw = updatedRaw.replace(propertyPattern, (_m, prefix) => prefix + newValue);
   } else {
-    updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, `
-  m_${normalizedProperty}: ${newValue}$1$2`);
+    updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, (_m, g1, g2) => `
+  m_${normalizedProperty}: ${newValue}${g1}${g2}`);
   }
   targetBlock.replace_raw(updatedRaw);
   const saveResult = doc.save();
@@ -6604,7 +7082,9 @@ function editComponentByFileId(options) {
       };
     }
   }
-  const currentValue = targetBlock.get_property(exactProperty) ?? (exactProperty !== prefixedProperty ? targetBlock.get_property(prefixedProperty) : null);
+  const exactValue = targetBlock.get_property(exactProperty);
+  const resolvedProperty = exactValue !== null ? exactProperty : exactProperty !== prefixedProperty && targetBlock.get_property(prefixedProperty) !== null ? prefixedProperty : null;
+  const currentValue = exactValue ?? (resolvedProperty === prefixedProperty ? targetBlock.get_property(prefixedProperty) : null);
   if (currentValue !== null) {
     const typeError = validate_value_type(currentValue, new_value);
     if (typeError) {
@@ -6615,9 +7095,14 @@ function editComponentByFileId(options) {
       };
     }
   }
-  let modified = targetBlock.set_property(exactProperty, new_value, "{fileID: 0}");
-  if (!modified && exactProperty !== prefixedProperty) {
-    modified = targetBlock.set_property(prefixedProperty, new_value, "{fileID: 0}");
+  let modified;
+  if (resolvedProperty) {
+    modified = targetBlock.set_property(resolvedProperty, new_value, "{fileID: 0}");
+  } else {
+    modified = targetBlock.set_property(exactProperty, new_value, "{fileID: 0}");
+    if (!modified && exactProperty !== prefixedProperty) {
+      modified = targetBlock.set_property(prefixedProperty, new_value, "{fileID: 0}");
+    }
   }
   if (!modified) {
     if (currentValue !== null) {
@@ -6654,8 +7139,10 @@ function editComponentByFileId(options) {
   };
 }
 function editPrefabOverride(options) {
-  const { file_path, prefab_instance, property_path, new_value, object_reference, target } = options;
-  const objRef = object_reference ?? "{fileID: 0}";
+  const { file_path, prefab_instance, new_value, object_reference, target, managed_reference } = options;
+  const property_path = /[\[\]]/.test(options.property_path) && !options.property_path.startsWith("'") ? `'${options.property_path}'` : options.property_path;
+  const effectiveValue = managed_reference ?? new_value;
+  const objRef = managed_reference ? "{fileID: 0}" : object_reference ?? "{fileID: 0}";
   if (!import_fs10.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
@@ -6669,11 +7156,16 @@ function editPrefabOverride(options) {
   if (!targetBlock) {
     return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
   }
-  const escapedPath = property_path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const entryPattern = new RegExp(`(- target:\\s*\\{[^}]+\\}\\s*\\n\\s*propertyPath:\\s*)${escapedPath}(\\s*\\n\\s*value:\\s*)(.*)(\\s*\\n\\s*objectReference:\\s*)(.*)`, "m");
+  const unquotedPath = property_path.replace(/^'|'$/g, "");
+  const quotedPath = `'${unquotedPath}'`;
+  const escapedUnquoted = unquotedPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const escapedQuoted = quotedPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pathAlternation = escapedUnquoted === escapedQuoted ? escapedUnquoted : `(?:${escapedQuoted}|${escapedUnquoted})`;
+  const entryPattern = new RegExp(`(- target:\\s*\\{[^}]+\\}\\s*\\n\\s*propertyPath:\\s*)${pathAlternation}(\\s*\\n\\s*value:\\s*)(.*)(\\s*\\n\\s*objectReference:\\s*)(.*)`, "m");
   const entryMatch = targetBlock.raw.match(entryPattern);
   if (entryMatch) {
-    const updatedText2 = targetBlock.raw.replace(entryPattern, `$1${property_path}$2${new_value}$4${objRef}`);
+    const quotedValue = yaml_quote_if_needed(effectiveValue);
+    const updatedText2 = targetBlock.raw.replace(entryPattern, (_m, g1, g2, _g3, g4) => g1 + property_path + g2 + quotedValue + g4 + objRef);
     targetBlock.replace_raw(updatedText2);
     const saveResult2 = doc.save();
     if (!saveResult2.success) {
@@ -6710,9 +7202,13 @@ function editPrefabOverride(options) {
       error: `Invalid target reference "${targetRef}". Expected format: {fileID: N, guid: ..., type: T}`
     };
   }
+  const enriched = enrich_target_ref(targetRef, targetBlock.raw);
+  if (enriched)
+    targetRef = enriched;
+  const quotedNewValue = yaml_quote_if_needed(effectiveValue);
   const newEntry = `    - target: ${targetRef}
       propertyPath: ${property_path}
-      value: ${new_value}
+      value: ${quotedNewValue}
       objectReference: ${objRef}`;
   const removedPattern = /(\n\s*m_RemovedComponents:)/m;
   const removedMatch = targetBlock.raw.match(removedPattern);
@@ -6759,6 +7255,118 @@ ${newEntry}$1`);
     action: "added"
   };
 }
+function batchEditPrefabOverrides(file_path, prefab_instance, edits) {
+  if (!import_fs10.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const actions = [];
+  for (const edit of edits) {
+    const { value, object_reference, target, managed_reference } = edit;
+    const property_path = /[\[\]]/.test(edit.property_path) && !edit.property_path.startsWith("'") ? `'${edit.property_path}'` : edit.property_path;
+    const effectiveValue = managed_reference ?? value;
+    const objRef = managed_reference ? "{fileID: 0}" : object_reference ?? "{fileID: 0}";
+    const unquotedPath = property_path.replace(/^'|'$/g, "");
+    const quotedPathStr = `'${unquotedPath}'`;
+    const batchEscapedUnquoted = unquotedPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const batchEscapedQuoted = quotedPathStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const batchPathAlt = batchEscapedUnquoted === batchEscapedQuoted ? batchEscapedUnquoted : `(?:${batchEscapedQuoted}|${batchEscapedUnquoted})`;
+    const entryPattern = new RegExp(`(- target:\\s*\\{[^}]+\\}\\s*\\n\\s*propertyPath:\\s*)${batchPathAlt}(\\s*\\n\\s*value:\\s*)(.*)(\\s*\\n\\s*objectReference:\\s*)(.*)`, "m");
+    const entryMatch = targetBlock.raw.match(entryPattern);
+    if (entryMatch) {
+      const quotedValue = yaml_quote_if_needed(effectiveValue);
+      const updatedText = targetBlock.raw.replace(entryPattern, (_m, g1, g2, _g3, g4) => g1 + property_path + g2 + quotedValue + g4 + objRef);
+      targetBlock.replace_raw(updatedText);
+      actions.push({ property_path, action: "updated" });
+    } else {
+      let targetRef = target;
+      if (!targetRef) {
+        const rootProp = property_path.split(".")[0];
+        const siblingPattern = new RegExp(`- target:\\s*(\\{[^}]+\\})\\s*\\n\\s*propertyPath:\\s*${rootProp.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "m");
+        const siblingMatch = targetBlock.raw.match(siblingPattern);
+        if (siblingMatch) {
+          targetRef = siblingMatch[1];
+        }
+      }
+      if (!targetRef) {
+        return {
+          success: false,
+          file_path,
+          error: `Cannot infer target for new override "${property_path}". Provide "target" in the edit entry (e.g., "{fileID: 400000, guid: ..., type: 3}").`
+        };
+      }
+      if (!/^\{fileID:\s*-?\d+/.test(targetRef)) {
+        return {
+          success: false,
+          file_path,
+          error: `Invalid target reference "${targetRef}" for "${property_path}". Expected format: {fileID: N, guid: ..., type: T}`
+        };
+      }
+      const enriched = enrich_target_ref(targetRef, targetBlock.raw);
+      if (enriched)
+        targetRef = enriched;
+      const quotedNewValue = yaml_quote_if_needed(effectiveValue);
+      const newEntry = `    - target: ${targetRef}
+      propertyPath: ${property_path}
+      value: ${quotedNewValue}
+      objectReference: ${objRef}`;
+      const removedPattern = /(\n\s*m_RemovedComponents:)/m;
+      const removedMatch = targetBlock.raw.match(removedPattern);
+      let updatedText;
+      if (removedMatch) {
+        updatedText = targetBlock.raw.replace(removedPattern, `
+${newEntry}$1`);
+      } else {
+        const lines = targetBlock.raw.split(`
+`);
+        let lastObjRefIdx = -1;
+        let inModifications = false;
+        for (let i = 0;i < lines.length; i++) {
+          if (/m_Modifications:/.test(lines[i])) {
+            inModifications = true;
+            continue;
+          }
+          if (inModifications && /^\s*objectReference:/.test(lines[i])) {
+            lastObjRefIdx = i;
+          }
+          if (inModifications && /^\s*m_\w+:/.test(lines[i]) && !/objectReference/.test(lines[i]) && !/propertyPath/.test(lines[i])) {
+            if (lastObjRefIdx !== -1)
+              break;
+          }
+        }
+        if (lastObjRefIdx !== -1) {
+          lines.splice(lastObjRefIdx + 1, 0, newEntry);
+          updatedText = lines.join(`
+`);
+        } else {
+          return { success: false, file_path, error: `Could not find insertion point in m_Modifications for "${property_path}"` };
+        }
+      }
+      targetBlock.replace_raw(updatedText);
+      actions.push({ property_path, action: "added" });
+    }
+  }
+  const saveResult = doc.save();
+  if (!saveResult.success) {
+    return { success: false, file_path, error: saveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: prefab_instance,
+    applied: actions.length,
+    actions
+  };
+}
 function editTransform(options) {
   const { file_path, transform_id, position, rotation, scale } = options;
   const pathError = validate_file_path(file_path, "write");
@@ -6855,10 +7463,10 @@ function batchEditProperties(filePath, edits) {
       const propertyPattern = new RegExp(`(^\\s*m_${normalizedProperty}:\\s*)([^\\n]*)`, "m");
       let updatedRaw = targetBlock.raw;
       if (propertyPattern.test(updatedRaw)) {
-        updatedRaw = updatedRaw.replace(propertyPattern, `$1${edit.new_value}`);
+        updatedRaw = updatedRaw.replace(propertyPattern, (_m, prefix) => prefix + edit.new_value);
       } else {
-        updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, `
-  m_${normalizedProperty}: ${edit.new_value}$1$2`);
+        updatedRaw = updatedRaw.replace(/(\n)(--- !u!|$)/, (_m, g1, g2) => `
+  m_${normalizedProperty}: ${edit.new_value}${g1}${g2}`);
       }
       targetBlock.replace_raw(updatedRaw);
     }
@@ -6963,9 +7571,9 @@ function reparentGameObject(options) {
   return {
     success: true,
     file_path,
-    child_transform_id: parseInt(childTransformId, 10),
-    old_parent_transform_id: parseInt(oldParentTransformId, 10),
-    new_parent_transform_id: parseInt(newParentTransformId, 10)
+    child_transform_id: childTransformId,
+    old_parent_transform_id: oldParentTransformId,
+    new_parent_transform_id: newParentTransformId
   };
 }
 function findPrefabInstanceBlock(doc, identifier) {
@@ -7320,39 +7928,267 @@ function removeRemovedGameObject(options) {
   } catch (err) {
     return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
   }
-  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
-  if (!targetBlock) {
-    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  const targetBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!targetBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const escapedRef = component_ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const refPattern = new RegExp(`\\s*- ${escapedRef}\\n?`, "m");
+  if (!refPattern.test(targetBlock.raw)) {
+    return { success: false, file_path, error: `GameObject reference "${component_ref}" not found in m_RemovedGameObjects` };
+  }
+  const updatedRaw = targetBlock.raw.replace(refPattern, "");
+  targetBlock.replace_raw(updatedRaw);
+  if (!doc.validate()) {
+    return { success: false, file_path, error: "Validation failed after removing GameObject" };
+  }
+  const restoreGoSaveResult = doc.save();
+  if (!restoreGoSaveResult.success) {
+    return { success: false, file_path, error: restoreGoSaveResult.error };
+  }
+  return {
+    success: true,
+    file_path,
+    prefab_instance_id: targetBlock.file_id
+  };
+}
+function generate_managed_reference_id(existing_raw, count = 1) {
+  const { randomBytes } = require("crypto");
+  const existingIds = new Set;
+  const idPattern = /\b(\d{1,19})\b/g;
+  for (const line of existing_raw.split(`
+`)) {
+    if (line.includes("managedReferences[") || line.includes("rid:") || line.includes("objectReference:") && /\d{10,}/.test(line) || line.includes("value:") && /\d{16,}/.test(line)) {
+      let m;
+      while ((m = idPattern.exec(line)) !== null) {
+        const val = BigInt(m[1]);
+        if (val > 0n)
+          existingIds.add(val);
+      }
+    }
+  }
+  const buf = randomBytes(8);
+  const raw64 = buf.readBigUInt64BE();
+  const mask46 = (1n << 46n) - 1n;
+  let base = (raw64 & mask46 | 1n) << 18n;
+  const INT64_MAX = 9223372036854775807n;
+  if (base > INT64_MAX)
+    base = base & INT64_MAX >> 18n << 18n;
+  if (base <= 0n)
+    base = 1n << 18n;
+  const results = [];
+  for (let i = 0;i < count; i++) {
+    let id = base + BigInt(i);
+    while (id <= 0n || id > INT64_MAX || existingIds.has(id)) {
+      id += 1n;
+    }
+    existingIds.add(id);
+    results.push(id.toString());
+  }
+  return results;
+}
+function addPrefabManagedReference(options) {
+  const { file_path, prefab_instance, field_path, type_name, target, project_path } = options;
+  const index = options.index ?? 0;
+  if (!import_fs10.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  const typeInfo = resolve_managed_type(type_name, project_path);
+  let finalTypeInfo;
+  if (typeInfo) {
+    finalTypeInfo = typeInfo;
+  } else {
+    const spaceIdx = type_name.indexOf(" ");
+    if (spaceIdx > 0) {
+      const asm = type_name.substring(0, spaceIdx);
+      const fullType = type_name.substring(spaceIdx + 1);
+      const lastDot = fullType.lastIndexOf(".");
+      finalTypeInfo = {
+        assembly: asm,
+        namespace: lastDot >= 0 ? fullType.substring(0, lastDot) : "",
+        class_name: lastDot >= 0 ? fullType.substring(lastDot + 1) : fullType
+      };
+    } else {
+      return {
+        success: false,
+        file_path,
+        error: `Type "${type_name}" not found in type registry. Use "Assembly Namespace.ClassName" format or run "setup" to rebuild.`
+      };
+    }
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const piBlock = findPrefabInstanceBlock(doc, prefab_instance);
+  if (!piBlock) {
+    return { success: false, file_path, error: `PrefabInstance "${prefab_instance}" not found` };
+  }
+  const [rid] = generate_managed_reference_id(piBlock.raw);
+  const typeValue = finalTypeInfo.namespace ? `${finalTypeInfo.assembly} ${finalTypeInfo.namespace}.${finalTypeInfo.class_name}` : `${finalTypeInfo.assembly} ${finalTypeInfo.class_name}`;
+  const basePath = field_path.replace(/\.Array$/, "");
+  const overrides = [
+    {
+      property_path: `${basePath}.Array.data[${index}].managedReferenceType`,
+      value: typeValue,
+      target
+    },
+    {
+      property_path: `${basePath}.Array.data[${index}].managedReferenceValue`,
+      value: rid,
+      target
+    },
+    {
+      property_path: `managedReferences[-2]`,
+      value: "2",
+      target
+    }
+  ];
+  const result = batchEditPrefabOverrides(file_path, prefab_instance, overrides);
+  if (!result.success) {
+    return { success: false, file_path, error: result.error };
+  }
+  return {
+    success: true,
+    file_path,
+    rid,
+    type_info: finalTypeInfo,
+    overrides_created: overrides.map((o) => o.property_path)
+  };
+}
+function resolve_managed_type(type_name, project_path) {
+  if (!project_path)
+    return null;
+  const { join: join10 } = require("path");
+  const registryPath = join10(project_path, ".unity-agentic", "type-registry.json");
+  if (!import_fs10.existsSync(registryPath))
+    return null;
+  try {
+    const registry = JSON.parse(import_fs11.readFileSync(registryPath, "utf-8"));
+    let targetName = type_name;
+    let targetNs = null;
+    const dotIndex = type_name.lastIndexOf(".");
+    if (dotIndex > 0) {
+      targetNs = type_name.substring(0, dotIndex);
+      targetName = type_name.substring(dotIndex + 1);
+    }
+    const matches = registry.filter((t) => {
+      if (t.name.toLowerCase() !== targetName.toLowerCase())
+        return false;
+      if (targetNs && t.namespace?.toLowerCase() !== targetNs.toLowerCase())
+        return false;
+      return true;
+    });
+    if (matches.length === 0)
+      return null;
+    const match = matches[0];
+    let assembly = "Assembly-CSharp";
+    if (match.filePath && (match.filePath.includes("Packages/") || match.filePath.includes("PackageCache/"))) {
+      const pkgMatch = match.filePath.match(/(?:Packages|PackageCache)\/([^/]+)/);
+      if (pkgMatch)
+        assembly = pkgMatch[1].replace(/@.*$/, "");
+    }
+    return { class_name: match.name, namespace: match.namespace || "", assembly };
+  } catch {
+    return null;
+  }
+}
+function editManagedReference(options) {
+  const { file_path, file_id, field_path, type_name, project_path, append, initial_values } = options;
+  if (!import_fs10.existsSync(file_path)) {
+    return { success: false, file_path, error: `File not found: ${file_path}` };
+  }
+  let doc;
+  try {
+    doc = UnityDocument.from_file(file_path);
+  } catch (err) {
+    return { success: false, file_path, error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const block = doc.find_by_file_id(file_id);
+  if (!block) {
+    return { success: false, file_path, error: `Component with fileID ${file_id} not found` };
+  }
+  if (block.class_id !== 114) {
+    return { success: false, file_path, error: `fileID ${file_id} is not a MonoBehaviour (class ${block.class_id}). Managed references only apply to MonoBehaviours.` };
+  }
+  const typeInfo = resolve_managed_type(type_name, project_path);
+  if (!typeInfo) {
+    const spaceIdx = type_name.indexOf(" ");
+    if (spaceIdx > 0) {
+      const asm = type_name.substring(0, spaceIdx);
+      const fullType = type_name.substring(spaceIdx + 1);
+      const lastDot = fullType.lastIndexOf(".");
+      const manual = {
+        assembly: asm,
+        namespace: lastDot >= 0 ? fullType.substring(0, lastDot) : "",
+        class_name: lastDot >= 0 ? fullType.substring(lastDot + 1) : fullType
+      };
+      return applyManagedReference(doc, block, file_path, field_path, manual, append, initial_values);
+    }
+    return {
+      success: false,
+      file_path,
+      error: `Type "${type_name}" not found in type registry. Use "Assembly Namespace.ClassName" format or run "setup" to rebuild.`
+    };
   }
-  const escapedRef = component_ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const refPattern = new RegExp(`\\s*- ${escapedRef}\\n?`, "m");
-  if (!refPattern.test(targetBlock.raw)) {
-    return { success: false, file_path, error: `GameObject reference "${component_ref}" not found in m_RemovedGameObjects` };
+  return applyManagedReference(doc, block, file_path, field_path, typeInfo, append, initial_values);
+}
+function applyManagedReference(doc, block, file_path, field_path, typeInfo, append, initial_values) {
+  let raw = block.raw;
+  const ridMatches = [...raw.matchAll(/rid:[ \t]*(\d+)/g)];
+  const existingRids = ridMatches.map((m) => parseInt(m[1], 10)).filter((n) => !isNaN(n));
+  const nextRid = existingRids.length > 0 ? Math.max(...existingRids) + 1 : 1;
+  let dataBlock = "{}";
+  if (initial_values && Object.keys(initial_values).length > 0) {
+    const lines = Object.entries(initial_values).map(([k, v]) => `        ${k}: ${v}`);
+    dataBlock = `
+` + lines.join(`
+`);
   }
-  const updatedRaw = targetBlock.raw.replace(refPattern, "");
-  targetBlock.replace_raw(updatedRaw);
-  if (!doc.validate()) {
-    return { success: false, file_path, error: "Validation failed after removing GameObject" };
+  const refEntry = `    - rid: ${nextRid}
+      type: {class: ${typeInfo.class_name}, ns: ${typeInfo.namespace}, asm: ${typeInfo.assembly}}
+      data: ${dataBlock}`;
+  const refIdsPattern = /(\s*RefIds:\s*\n)/;
+  const referencesPattern = /(\s*references:\s*\n\s*version:\s*\d+\s*\n)/;
+  if (refIdsPattern.test(raw)) {
+    raw = raw.replace(refIdsPattern, `$1${refEntry}
+`);
+  } else if (referencesPattern.test(raw)) {
+    raw = raw.replace(referencesPattern, `$1    RefIds:
+${refEntry}
+`);
+  } else {
+    raw = raw.trimEnd() + `
+  references:
+    version: 2
+    RefIds:
+${refEntry}
+`;
   }
-  const saveResult = doc.save();
-  if (!saveResult.success) {
-    return { success: false, file_path, error: saveResult.error };
+  if (!append) {
+    const fieldRidPattern = new RegExp(`(${field_path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:\\s*\\n\\s*rid:[ \\t]*)\\d+`, "m");
+    if (fieldRidPattern.test(raw)) {
+      raw = raw.replace(fieldRidPattern, `$1${nextRid}`);
+    }
   }
-  return {
-    success: true,
-    file_path,
-    prefab_instance_id: targetBlock.file_id
-  };
+  block.replace_raw(raw);
+  const mrSave = doc.save();
+  if (!mrSave.success) {
+    return { success: false, file_path, error: mrSave.error };
+  }
+  return { success: true, file_path, rid: nextRid, type_info: typeInfo };
 }
 // src/editor/delete.ts
-var import_fs11 = require("fs");
+var import_fs12 = require("fs");
 function removeComponent(options) {
   const { file_path, file_id } = options;
   const pathError = validate_file_path(file_path, "write");
   if (pathError) {
     return { success: false, file_path, error: pathError };
   }
-  if (!import_fs11.existsSync(file_path)) {
+  if (!import_fs12.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
   let doc;
@@ -7376,7 +8212,8 @@ function removeComponent(options) {
     const parentGoId = goMatch[1];
     const goBlock = doc.find_by_file_id(parentGoId);
     if (goBlock) {
-      const compLinePattern = new RegExp(`\\s*- component: \\{fileID: ${file_id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\}\\n?`);
+      const escaped = file_id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const compLinePattern = new RegExp(`^[ \\t]*- component: \\{fileID: ${escaped}\\}[ \\t]*\\n`, "m");
       const modifiedRaw = goBlock.raw.replace(compLinePattern, "");
       goBlock.replace_raw(modifiedRaw);
     }
@@ -7402,7 +8239,7 @@ function deleteGameObject(options) {
   if (pathError) {
     return { success: false, file_path, error: pathError };
   }
-  if (!import_fs11.existsSync(file_path)) {
+  if (!import_fs12.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
   let doc;
@@ -7481,7 +8318,7 @@ function deletePrefabInstance(options) {
   if (pathError) {
     return { success: false, file_path, error: pathError };
   }
-  if (!import_fs11.existsSync(file_path)) {
+  if (!import_fs12.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
   let doc;
@@ -7561,7 +8398,7 @@ function deletePrefabInstance(options) {
   };
 }
 // src/editor/duplicate.ts
-var import_fs12 = require("fs");
+var import_fs13 = require("fs");
 var path5 = __toESM(require("path"));
 init_scanner();
 function findPrefabInstanceByName(doc, name) {
@@ -7577,7 +8414,7 @@ function findPrefabInstanceByName(doc, name) {
 }
 function duplicateGameObject(options) {
   const { file_path, object_name, new_name } = options;
-  if (!import_fs12.existsSync(file_path)) {
+  if (!import_fs13.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
   let doc;
@@ -7710,7 +8547,7 @@ function duplicateGameObject(options) {
 }
 function unpackPrefab(options) {
   const { file_path, prefab_instance, project_path } = options;
-  if (!import_fs12.existsSync(file_path)) {
+  if (!import_fs13.existsSync(file_path)) {
     return { success: false, file_path, error: `File not found: ${file_path}` };
   }
   let sceneDoc;
@@ -7756,7 +8593,7 @@ function unpackPrefab(options) {
         sourcePrefabPath = resolvedPath;
     }
   }
-  if (!sourcePrefabPath || !import_fs12.existsSync(sourcePrefabPath)) {
+  if (!sourcePrefabPath || !import_fs13.existsSync(sourcePrefabPath)) {
     const inferredProject = project_path || find_unity_project_root(path5.dirname(file_path));
     if (inferredProject) {
       const nativeBuild = getNativeBuildGuidCache();
@@ -7770,7 +8607,7 @@ function unpackPrefab(options) {
       }
     }
   }
-  if (!sourcePrefabPath || !import_fs12.existsSync(sourcePrefabPath)) {
+  if (!sourcePrefabPath || !import_fs13.existsSync(sourcePrefabPath)) {
     const searchedPaths = [];
     if (project_path)
       searchedPaths.push(`GUID cache: ${path5.join(project_path, ".unity-agentic", "guid-cache.json")}`);
@@ -8203,15 +9040,15 @@ function move_scene(projectPath, scenePath, newPosition) {
 }
 
 // src/packages.ts
-var import_fs13 = require("fs");
+var import_fs14 = require("fs");
 var import_path6 = require("path");
 function load_manifest(project_path) {
   const manifest_path = import_path6.join(project_path, "Packages", "manifest.json");
-  if (!import_fs13.existsSync(manifest_path)) {
+  if (!import_fs14.existsSync(manifest_path)) {
     return { error: `manifest.json not found at ${manifest_path}` };
   }
   try {
-    const raw = import_fs13.readFileSync(manifest_path, "utf-8");
+    const raw = import_fs14.readFileSync(manifest_path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.dependencies || typeof parsed.dependencies !== "object") {
       return { error: `Invalid manifest.json: missing "dependencies" object` };
@@ -8227,7 +9064,7 @@ function save_manifest(manifest_path, manifest) {
     sorted_deps[key] = manifest.dependencies[key];
   }
   const output = { ...manifest, dependencies: sorted_deps };
-  import_fs13.writeFileSync(manifest_path, JSON.stringify(output, null, 2) + `
+  import_fs14.writeFileSync(manifest_path, JSON.stringify(output, null, 2) + `
 `, "utf-8");
 }
 function list_packages(project_path, search) {
@@ -8281,7 +9118,7 @@ function remove_package(project_path, name) {
 }
 
 // src/input-actions.ts
-var import_fs14 = require("fs");
+var import_fs15 = require("fs");
 var import_crypto = require("crypto");
 function generate_action_id() {
   const bytes = import_crypto.randomBytes(16);
@@ -8295,18 +9132,18 @@ function generate_action_id() {
   ].join("-");
 }
 function load_input_actions(file) {
-  if (!import_fs14.existsSync(file)) {
+  if (!import_fs15.existsSync(file)) {
     return { error: `File not found: ${file}` };
   }
   try {
-    const raw = import_fs14.readFileSync(file, "utf-8");
+    const raw = import_fs15.readFileSync(file, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     return { error: `Failed to parse input actions: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
 function save_input_actions(file, data) {
-  import_fs14.writeFileSync(file, JSON.stringify(data, null, 4) + `
+  import_fs15.writeFileSync(file, JSON.stringify(data, null, 4) + `
 `, "utf-8");
 }
 function add_map(data, name) {
@@ -8460,11 +9297,22 @@ function build_create_command() {
     if (!result.success)
       process.exitCode = 1;
   });
-  cmd.command("scriptable-object <output_path> <script>").description("Create a new ScriptableObject .asset file").option("-p, --project <path>", "Unity project path (for script GUID lookup)").option("-j, --json", "Output as JSON").action((output_path, script, options) => {
+  cmd.command("scriptable-object <output_path> <script>").description("Create a new ScriptableObject .asset file").option("-p, --project <path>", "Unity project path (for script GUID lookup)").option("--set <json>", `Initial field values as JSON object (e.g. '{"damage": "10", "targetScope": "1"}')`).option("-j, --json", "Output as JSON").action((output_path, script, options) => {
+    let initial_values;
+    if (options.set) {
+      try {
+        initial_values = JSON.parse(options.set);
+      } catch {
+        console.log(JSON.stringify({ success: false, error: `Invalid JSON for --set: ${options.set}` }, null, 2));
+        process.exitCode = 1;
+        return;
+      }
+    }
     const result = createScriptableObject({
       output_path,
       script,
-      project_path: options.project
+      project_path: options.project,
+      initial_values
     });
     console.log(JSON.stringify(result, null, 2));
     if (!result.success)
@@ -8521,7 +9369,7 @@ function build_create_command() {
       console.log(JSON.stringify({ success: false, error: "--shader <guid> is required" }, null, 2));
       process.exit(1);
     }
-    if (import_fs15.existsSync(output_path)) {
+    if (import_fs16.existsSync(output_path)) {
       console.log(JSON.stringify({ success: false, error: `File already exists: ${output_path}` }, null, 2));
       process.exit(1);
     }
@@ -8593,7 +9441,7 @@ Material:
     m_Colors: ${color_section}
   m_BuildTextureStacks: []
 `;
-    import_fs15.writeFileSync(output_path, mat_content, "utf-8");
+    import_fs16.writeFileSync(output_path, mat_content, "utf-8");
     const guid = import_crypto2.randomBytes(16).toString("hex");
     const meta_content = `fileFormatVersion: 2
 guid: ${guid}
@@ -8604,7 +9452,7 @@ NativeFormatImporter:
   assetBundleName:
   assetBundleVariant:
 `;
-    import_fs15.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
+    import_fs16.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
     console.log(JSON.stringify({
       success: true,
       file: output_path,
@@ -8634,7 +9482,7 @@ NativeFormatImporter:
       process.exitCode = 1;
       return;
     }
-    if (import_fs15.existsSync(output_path)) {
+    if (import_fs16.existsSync(output_path)) {
       console.log(JSON.stringify({ success: false, error: `File already exists: ${output_path}` }, null, 2));
       process.exitCode = 1;
       return;
@@ -8661,7 +9509,7 @@ ScriptedImporter:
   wrapperClassName:
   wrapperCodeNamespace:
 `;
-    import_fs15.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
+    import_fs16.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
     console.log(JSON.stringify({
       success: true,
       file: output_path,
@@ -8677,7 +9525,7 @@ ScriptedImporter:
       return;
     }
     const name = name_arg || import_path7.basename(output_path).replace(/\.anim$/i, "");
-    if (import_fs15.existsSync(output_path)) {
+    if (import_fs16.existsSync(output_path)) {
       console.log(JSON.stringify({ success: false, error: `File already exists: ${output_path}` }, null, 2));
       process.exitCode = 1;
       return;
@@ -8744,7 +9592,7 @@ AnimationClip:
   m_HasMotionFloatCurves: 0
   m_Events: []
 `;
-    import_fs15.writeFileSync(output_path, anim_content, "utf-8");
+    import_fs16.writeFileSync(output_path, anim_content, "utf-8");
     const guid = import_crypto2.randomBytes(16).toString("hex");
     const meta_content = `fileFormatVersion: 2
 guid: ${guid}
@@ -8755,7 +9603,7 @@ NativeFormatImporter:
   assetBundleName:
   assetBundleVariant:
 `;
-    import_fs15.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
+    import_fs16.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
     console.log(JSON.stringify({
       success: true,
       file: output_path,
@@ -8773,7 +9621,7 @@ NativeFormatImporter:
       process.exitCode = 1;
       return;
     }
-    if (import_fs15.existsSync(output_path)) {
+    if (import_fs16.existsSync(output_path)) {
       console.log(JSON.stringify({ success: false, error: `File already exists: ${output_path}` }, null, 2));
       process.exitCode = 1;
       return;
@@ -8823,7 +9671,7 @@ AnimatorStateMachine:
   m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
   m_DefaultState: {fileID: 0}
 `;
-    import_fs15.writeFileSync(output_path, ctrl_content, "utf-8");
+    import_fs16.writeFileSync(output_path, ctrl_content, "utf-8");
     const guid = import_crypto2.randomBytes(16).toString("hex");
     const meta_content = `fileFormatVersion: 2
 guid: ${guid}
@@ -8834,7 +9682,7 @@ NativeFormatImporter:
   assetBundleName:
   assetBundleVariant:
 `;
-    import_fs15.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
+    import_fs16.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
     console.log(JSON.stringify({
       success: true,
       file: output_path,
@@ -8851,7 +9699,7 @@ NativeFormatImporter:
       process.exitCode = 1;
       return;
     }
-    if (import_fs15.existsSync(output_path)) {
+    if (import_fs16.existsSync(output_path)) {
       console.log(JSON.stringify({ success: false, error: `File already exists: ${output_path}` }, null, 2));
       process.exitCode = 1;
       return;
@@ -8890,7 +9738,7 @@ Transform:
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 `;
-    import_fs15.writeFileSync(output_path, prefab_content, "utf-8");
+    import_fs16.writeFileSync(output_path, prefab_content, "utf-8");
     const guid = import_crypto2.randomBytes(16).toString("hex");
     const meta_content = `fileFormatVersion: 2
 guid: ${guid}
@@ -8900,7 +9748,7 @@ PrefabImporter:
   assetBundleName:
   assetBundleVariant:
 `;
-    import_fs15.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
+    import_fs16.writeFileSync(`${output_path}.meta`, meta_content, "utf-8");
     console.log(JSON.stringify({
       success: true,
       file: output_path,
@@ -8914,7 +9762,7 @@ PrefabImporter:
 
 // src/cmd-read.ts
 init_scanner();
-var import_fs16 = require("fs");
+var import_fs17 = require("fs");
 var import_path8 = require("path");
 var import_os = require("os");
 function parse_material_yaml(content) {
@@ -9161,7 +10009,7 @@ function categorize_asset(filePath) {
 function find_project_root_from_file(filePath) {
   let dir = import_path8.dirname(import_path8.resolve(filePath));
   for (let i = 0;i < 20; i++) {
-    if (import_fs16.existsSync(import_path8.join(dir, "Assets")) && import_fs16.existsSync(import_path8.join(dir, "ProjectSettings"))) {
+    if (import_fs17.existsSync(import_path8.join(dir, "Assets")) && import_fs17.existsSync(import_path8.join(dir, "ProjectSettings"))) {
       return dir;
     }
     const parent = import_path8.dirname(dir);
@@ -9507,7 +10355,7 @@ function walk_files(dir, extensions) {
     const current = stack.pop();
     let entries;
     try {
-      entries = import_fs16.readdirSync(current);
+      entries = import_fs17.readdirSync(current);
     } catch {
       continue;
     }
@@ -9516,7 +10364,7 @@ function walk_files(dir, extensions) {
         continue;
       const full = import_path8.join(current, entry);
       try {
-        const stat = import_fs16.statSync(full);
+        const stat = import_fs17.statSync(full);
         if (stat.isDirectory()) {
           stack.push(full);
         } else if (extensions.has(import_path8.extname(full).toLowerCase())) {
@@ -9530,7 +10378,7 @@ function walk_files(dir, extensions) {
   return results;
 }
 function validate_unity_yaml(file) {
-  if (!import_fs16.existsSync(file)) {
+  if (!import_fs17.existsSync(file)) {
     return `File not found: ${file}`;
   }
   try {
@@ -9615,13 +10463,59 @@ function build_read_command(getScanner) {
       result.warning = result.warning ? `${result.warning}; ${maxDepthWarning}` : maxDepthWarning;
     }
     if (result.total === 0 && !result.error) {
-      try {
-        const fileSize = import_fs16.statSync(file).size;
-        if (fileSize > 100) {
-          const corruptWarning = "File has valid Unity YAML header but contains no parseable GameObjects -- file may be corrupt or malformed";
-          result.warning = result.warning ? `${result.warning}; ${corruptWarning}` : corruptWarning;
-        }
-      } catch {}
+      const prefabInstances = result.prefabInstances;
+      if (prefabInstances && prefabInstances.length > 0) {
+        try {
+          const doc = UnityDocument.from_file(file);
+          const projectPath = find_unity_project_root(import_path8.dirname(file));
+          const resolved = resolve_source_prefab(doc, file, projectPath ?? undefined);
+          if (resolved) {
+            const sourceResult = getScanner().inspect_all_paginated({
+              file: resolved.source_path,
+              include_properties: options.properties === true,
+              verbose: options.verbose === true,
+              page_size: pageSize,
+              cursor: 0,
+              max_depth: maxDepth,
+              filter_component: options.filterComponent
+            });
+            if (sourceResult.total > 0 && sourceResult.gameobjects) {
+              const piBlock = resolved.prefab_instance_block;
+              const nameOverrides = new Map;
+              const namePattern = /- target:[ \t]*\{fileID:[ \t]*(-?\d+)[^}]*\}\s*\n\s*propertyPath:[ \t]*m_Name\s*\n\s*value:[ \t]*(.*)/g;
+              let nameMatch;
+              while ((nameMatch = namePattern.exec(piBlock.raw)) !== null) {
+                nameOverrides.set(nameMatch[1], nameMatch[2].trim());
+              }
+              for (const go of sourceResult.gameobjects) {
+                const goRecord = go;
+                const override = nameOverrides.get(goRecord.fileId);
+                if (override) {
+                  goRecord.name = override;
+                }
+              }
+              const resultRecord = result;
+              resultRecord.gameobjects = sourceResult.gameobjects;
+              resultRecord.total = sourceResult.total;
+              resultRecord.totalInScene = sourceResult.totalInScene;
+              resultRecord.resolvedFromSource = true;
+              resultRecord.sourcePrefab = resolved.source_path;
+              resultRecord.sourceGuid = resolved.source_guid;
+              const variantNote = `PrefabVariant resolved from source prefab: ${resolved.source_path}`;
+              result.warning = result.warning ? `${result.warning}; ${variantNote}` : variantNote;
+            }
+          }
+        } catch {}
+      }
+      if (result.total === 0) {
+        try {
+          const fileSize = import_fs17.statSync(file).size;
+          if (fileSize > 100) {
+            const corruptWarning = "File has valid Unity YAML header but contains no parseable GameObjects -- file may be corrupt or malformed";
+            result.warning = result.warning ? `${result.warning}; ${corruptWarning}` : corruptWarning;
+          }
+        } catch {}
+      }
     }
     if (options.summary) {
       const component_counts = {};
@@ -9718,12 +10612,6 @@ function build_read_command(getScanner) {
     };
     console.log(JSON.stringify(output, null, 2));
   });
-  cmd.command("scriptable-object").description('(Deprecated: renamed to "read asset")').argument("[file]").allowUnknownOption().action(() => {
-    console.log(JSON.stringify({
-      error: 'Command "read scriptable-object" has been renamed to "read asset". Use: unity-agentic-tools read asset <file>'
-    }, null, 2));
-    process.exit(1);
-  });
   cmd.command("material <file>").description("Read a Unity Material file (.mat) with structured property output").option("--project <path>", "Unity project root (for GUID resolution)").option("--summary", "Show shader name, property count, texture count only").option("-j, --json", "Output as JSON").action((file, options) => {
     if (!file.toLowerCase().endsWith(".mat")) {
       console.log(JSON.stringify({ error: `File must be a .mat file: ${file}` }, null, 2));
@@ -9734,7 +10622,7 @@ function build_read_command(getScanner) {
       console.log(JSON.stringify({ error: matValidationError }, null, 2));
       process.exit(1);
     }
-    const content = import_fs16.readFileSync(file, "utf-8");
+    const content = import_fs17.readFileSync(file, "utf-8");
     if (!content.includes("Material:")) {
       console.log(JSON.stringify({ error: `File "${file}" does not contain a Material block. Use 'read asset' for generic Unity YAML files.` }, null, 2));
       process.exit(1);
@@ -9776,13 +10664,13 @@ function build_read_command(getScanner) {
     }, null, 2));
   });
   cmd.command("dependencies <file>").description("List asset dependencies (GUIDs referenced by this file)").option("--project <path>", "Unity project root (for GUID resolution)").option("--unresolved", "Show only GUIDs that could not be resolved").option("--recursive [depth]", "Follow dependency chain N levels deep (default: 3)").option("-j, --json", "Output as JSON").action((file, options) => {
-    if (!import_fs16.existsSync(file)) {
+    if (!import_fs17.existsSync(file)) {
       console.log(JSON.stringify({ error: `File not found: ${file}` }, null, 2));
       process.exit(1);
     }
     let content;
     try {
-      content = import_fs16.readFileSync(file, "utf-8");
+      content = import_fs17.readFileSync(file, "utf-8");
     } catch {
       console.log(JSON.stringify({ error: `Cannot read file: ${file}` }, null, 2));
       process.exit(1);
@@ -9823,7 +10711,7 @@ function build_read_command(getScanner) {
         const result = [];
         let fileContent;
         try {
-          fileContent = import_fs16.readFileSync(filePath, "utf-8");
+          fileContent = import_fs17.readFileSync(filePath, "utf-8");
         } catch {
           return [];
         }
@@ -9840,7 +10728,7 @@ function build_read_command(getScanner) {
           const rAbsPath = cache.resolve_absolute(g);
           const rType = rPath ? categorize_asset(rPath) : "unknown";
           const dep = { guid: g, path: rPath, type: rType, depth };
-          if (rAbsPath && depth < max_depth && import_fs16.existsSync(rAbsPath)) {
+          if (rAbsPath && depth < max_depth && import_fs17.existsSync(rAbsPath)) {
             const subs = traverse_file(rAbsPath, depth + 1);
             if (subs.length > 0)
               dep.sub_dependencies = subs;
@@ -9869,7 +10757,7 @@ function build_read_command(getScanner) {
         const rDep = { guid: dep.guid, path: dep.path, type: dep.type, depth: 0 };
         if (dep.path) {
           const absPath = cache.resolve_absolute(dep.guid);
-          if (absPath && import_fs16.existsSync(absPath)) {
+          if (absPath && import_fs17.existsSync(absPath)) {
             const subs = traverse_file(absPath, 1);
             if (subs.length > 0)
               rDep.sub_dependencies = subs;
@@ -9960,14 +10848,31 @@ function build_read_command(getScanner) {
           const target_match = lines[i].match(/\{fileID:\s*(-?\d+)/);
           const property_match = i + 1 < lines.length ? lines[i + 1].match(/propertyPath:\s*(.+)/) : null;
           const value_match = i + 2 < lines.length ? lines[i + 2].match(/value:\s*(.*)/) : null;
-          const obj_ref_match = i + 3 < lines.length ? lines[i + 3].match(/objectReference:\s*\{fileID:\s*(-?\d+)/) : null;
+          const obj_ref_match = i + 3 < lines.length ? lines[i + 3].match(/objectReference:[ \t]*(.+)/) : null;
           if (target_match && property_match) {
-            modifications.push({
+            const mod = {
               target_file_id: target_match[1],
               property_path: property_match[1].trim(),
               value: value_match ? value_match[1].trim() : "",
-              object_reference: obj_ref_match ? obj_ref_match[1] : null
-            });
+              object_reference: obj_ref_match ? obj_ref_match[1].trim() : null
+            };
+            const propPath = mod.property_path;
+            const modValue = mod.value;
+            if (propPath.endsWith(".managedReferenceType") && modValue) {
+              const spaceIdx = modValue.indexOf(" ");
+              if (spaceIdx > 0) {
+                const assembly = modValue.substring(0, spaceIdx);
+                const full_type = modValue.substring(spaceIdx + 1);
+                const lastDot = full_type.lastIndexOf(".");
+                mod.managed_reference_type = {
+                  assembly,
+                  full_type,
+                  namespace: lastDot >= 0 ? full_type.substring(0, lastDot) : "",
+                  class_name: lastDot >= 0 ? full_type.substring(lastDot + 1) : full_type
+                };
+              }
+            }
+            modifications.push(mod);
           }
           i += 4;
         } else {
@@ -10035,8 +10940,129 @@ function build_read_command(getScanner) {
       process.exit(1);
     }
   });
+  cmd.command("target <file> <gameobject_name> [component_type]").description("Build a --target reference string for prefab override commands").option("-p, --project <path>", "Unity project path").option("-j, --json", "Output as JSON").action((file, gameobject_name, component_type, options) => {
+    try {
+      if (!import_fs17.existsSync(file)) {
+        console.log(JSON.stringify({ error: `File not found: ${file}` }, null, 2));
+        process.exit(1);
+      }
+      const doc = UnityDocument.from_file(file);
+      let guid;
+      const piBlocks = doc.find_by_class_id(1001);
+      if (piBlocks.length > 0) {
+        const sourceMatch = piBlocks[0].raw.match(/m_SourcePrefab:[ \t]*\{[^}]*guid:[ \t]*([a-f0-9]{32})/);
+        guid = sourceMatch ? sourceMatch[1] : null;
+        if (!guid) {
+          console.log(JSON.stringify({ error: "Cannot extract source GUID from PrefabInstance m_SourcePrefab." }, null, 2));
+          process.exit(1);
+        }
+      } else {
+        const metaPath = file + ".meta";
+        guid = extractGuidFromMeta(metaPath);
+        if (!guid) {
+          console.log(JSON.stringify({ error: `Cannot read GUID from ${metaPath}. Ensure the .meta file exists.` }, null, 2));
+          process.exit(1);
+        }
+      }
+      const goResult = doc.require_unique_game_object(gameobject_name);
+      let targetFileId;
+      if ("error" in goResult) {
+        let found = false;
+        for (const block of doc.blocks) {
+          if (block.class_id !== 1001)
+            continue;
+          const nameMatch = block.raw.match(new RegExp(`- target:[ \\t]*\\{fileID:[ \\t]*(-?\\d+)[^}]*\\}\\s*\\n\\s*propertyPath:[ \\t]*m_Name\\s*\\n\\s*value:[ \\t]*${gameobject_name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "m"));
+          if (nameMatch) {
+            targetFileId = nameMatch[1];
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          console.log(JSON.stringify({ error: goResult.error }, null, 2));
+          process.exit(1);
+        }
+      } else {
+        targetFileId = goResult.file_id;
+      }
+      if (component_type) {
+        const classId = get_class_id(component_type);
+        const goBlock = doc.find_by_file_id(targetFileId);
+        if (goBlock && !goBlock.is_stripped) {
+          const compRefs = [...goBlock.raw.matchAll(/component:[ \t]*\{fileID:[ \t]*(-?\d+)\}/g)].map((m) => m[1]);
+          let compFound = false;
+          for (const refId of compRefs) {
+            const compBlock = doc.find_by_file_id(refId);
+            if (!compBlock)
+              continue;
+            if (classId !== null && compBlock.class_id === classId) {
+              targetFileId = refId;
+              compFound = true;
+              break;
+            }
+            if (classId === null && compBlock.class_id === 114) {
+              const scriptMatch = compBlock.raw.match(/m_Script:[ \t]*\{[^}]*guid:[ \t]*([a-f0-9]{32})/);
+              if (scriptMatch) {
+                const project = options.project || find_unity_project_root(import_path8.dirname(file));
+                if (project) {
+                  const cache = load_guid_cache(project);
+                  if (cache) {
+                    const scriptPath = cache.resolve(scriptMatch[1]);
+                    if (scriptPath && import_path8.basename(scriptPath, ".cs").toLowerCase() === component_type.toLowerCase().replace(/\.cs$/, "")) {
+                      targetFileId = refId;
+                      compFound = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (!compFound) {
+            console.log(JSON.stringify({ error: `Component "${component_type}" not found on GameObject "${gameobject_name}"` }, null, 2));
+            process.exit(1);
+          }
+        } else {
+          const project = options.project || find_unity_project_root(import_path8.dirname(file));
+          const resolved = resolve_source_prefab(doc, file, project ?? undefined);
+          if (resolved) {
+            const sourceDoc = UnityDocument.from_file(resolved.source_path);
+            const sourceGo = sourceDoc.require_unique_game_object(gameobject_name);
+            if (!("error" in sourceGo)) {
+              const compRefs = [...sourceGo.raw.matchAll(/component:[ \t]*\{fileID:[ \t]*(-?\d+)\}/g)].map((m) => m[1]);
+              let compFound = false;
+              for (const refId of compRefs) {
+                const compBlock = sourceDoc.find_by_file_id(refId);
+                if (!compBlock)
+                  continue;
+                if (classId !== null && compBlock.class_id === classId) {
+                  targetFileId = refId;
+                  compFound = true;
+                  break;
+                }
+              }
+              if (!compFound) {
+                console.log(JSON.stringify({ error: `Component "${component_type}" not found on "${gameobject_name}" in source prefab` }, null, 2));
+                process.exit(1);
+              }
+            }
+          }
+        }
+      }
+      const target = `{fileID: ${targetFileId}, guid: ${guid}, type: 3}`;
+      console.log(JSON.stringify({
+        target,
+        file_id: targetFileId,
+        guid,
+        type: 3
+      }, null, 2));
+    } catch (err) {
+      console.log(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }, null, 2));
+      process.exit(1);
+    }
+  });
   cmd.command("script <file>").description("Extract C# type declarations from a .cs file or .NET DLL").option("-j, --json", "Output as JSON").action((file, _options) => {
-    if (!import_fs16.existsSync(file)) {
+    if (!import_fs17.existsSync(file)) {
       console.log(JSON.stringify({ error: `File not found: ${file}` }, null, 2));
       process.exit(1);
     }
@@ -10121,18 +11147,20 @@ function build_read_command(getScanner) {
       types: displayed
     }, null, 2));
   });
-  cmd.command("log").description("Read and filter the Unity Editor.log").option("--path <file>", "Path to Editor.log (auto-detected if omitted)").option("--project <path>", "Filter to log entries from a specific Unity project session").option("--tail <n>", "Show last N lines (default 50)", "50").option("--errors", "Show only error entries").option("--warnings", "Show only warning entries").option("--compile-errors", "Show only C# compilation errors").option("--import-errors", "Show only asset import errors").option("--since <timestamp>", "Filter entries after this timestamp (YYYY-MM-DD or HH:MM:SS)").option("--search <pattern>", "Regex filter on log content").option("-j, --json", "Output as JSON").action((options) => {
+  cmd.command("log [project-path]").description("Read and filter the Unity Editor.log").option("--path <file>", "Path to Editor.log (auto-detected if omitted)").option("--project <path>", "Filter to log entries from a specific Unity project session").option("--tail <n>", "Show last N lines (default 50)", "50").option("--errors", "Show only error entries").option("--warnings", "Show only warning entries").option("--compile-errors", "Show only C# compilation errors").option("--import-errors", "Show only asset import errors").option("--since <timestamp>", "Filter entries after this timestamp (YYYY-MM-DD or HH:MM:SS)").option("--search <pattern>", "Regex filter on log content").option("-j, --json", "Output as JSON").action((projectPath, options) => {
+    if (projectPath && !options.project)
+      options.project = projectPath;
     const logPath = options.path || get_editor_log_path();
-    if (!logPath || !import_fs16.existsSync(logPath)) {
+    if (!logPath || !import_fs17.existsSync(logPath)) {
       console.log(JSON.stringify({ error: `Editor.log not found${logPath ? `: ${logPath}` : ". Could not detect platform log path."}` }, null, 2));
       process.exit(1);
     }
-    const content = import_fs16.readFileSync(logPath, "utf-8");
+    const content = import_fs17.readFileSync(logPath, "utf-8");
     let lines = content.split(/\r?\n/);
     if (options.project) {
-      const projectPath = import_path8.resolve(options.project);
-      const projectName = import_path8.basename(projectPath);
-      const escapedPath = projectPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const projectPath2 = import_path8.resolve(options.project);
+      const projectName = import_path8.basename(projectPath2);
+      const escapedPath = projectPath2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       const escapedName = projectName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       const session_markers = [
         new RegExp(`Loading project at '${escapedPath}'`),
@@ -10248,11 +11276,11 @@ function build_read_command(getScanner) {
   });
   cmd.command("meta <file>").description("Read a Unity .meta file and show importer settings").option("--summary", "Show importer type and key settings only").option("-j, --json", "Output as JSON").action((file, options) => {
     const metaPath = file.endsWith(".meta") ? file : `${file}.meta`;
-    if (!import_fs16.existsSync(metaPath)) {
+    if (!import_fs17.existsSync(metaPath)) {
       console.log(JSON.stringify({ error: `Meta file not found: ${metaPath}` }, null, 2));
       process.exit(1);
     }
-    const content = import_fs16.readFileSync(metaPath, "utf-8");
+    const content = import_fs17.readFileSync(metaPath, "utf-8");
     const lines = content.split(/\r?\n/);
     let guid = "";
     let importer_type = "Unknown";
@@ -10340,7 +11368,7 @@ function build_read_command(getScanner) {
       console.log(JSON.stringify({ error: animValidationError }, null, 2));
       process.exit(1);
     }
-    const content = import_fs16.readFileSync(file, "utf-8");
+    const content = import_fs17.readFileSync(file, "utf-8");
     const clip = parse_animation_yaml(content, options.curves === true);
     if (!clip) {
       console.log(JSON.stringify({ error: `No AnimationClip found in "${file}". Is this an .anim file?` }, null, 2));
@@ -10401,7 +11429,7 @@ function build_read_command(getScanner) {
       console.log(JSON.stringify({ error: ctrlValidationError }, null, 2));
       process.exit(1);
     }
-    const content = import_fs16.readFileSync(file, "utf-8");
+    const content = import_fs17.readFileSync(file, "utf-8");
     const blocks = split_yaml_blocks(content);
     const controller_block = blocks.find((b) => b.class_id === 91);
     if (!controller_block) {
@@ -10631,7 +11659,7 @@ function build_read_command(getScanner) {
       process.exit(1);
     }
     const assetsDir = import_path8.join(import_path8.resolve(project_path), "Assets");
-    if (!import_fs16.existsSync(assetsDir)) {
+    if (!import_fs17.existsSync(assetsDir)) {
       console.log(JSON.stringify({ error: `Assets directory not found in "${project_path}"` }, null, 2));
       process.exit(1);
     }
@@ -10660,7 +11688,7 @@ function build_read_command(getScanner) {
     const guid_pattern = `guid: ${guid}`;
     for (const f of files) {
       try {
-        const fc = import_fs16.readFileSync(f, "utf-8");
+        const fc = import_fs17.readFileSync(f, "utf-8");
         if (fc.includes(guid_pattern)) {
           const rel = import_path8.relative(import_path8.resolve(project_path), f);
           const ftype = categorize_asset(f);
@@ -10690,7 +11718,7 @@ function build_read_command(getScanner) {
   cmd.command("unused <project_path>").description("Find potentially unused assets (zero inbound GUID references)").option("--type <type>", "Filter to specific asset types").option("--ignore <glob>", "Exclude paths matching this pattern").option("--max <n>", "Maximum results to return (default 200)", "200").option("-j, --json", "Output as JSON").action((project_path, options) => {
     const resolvedProject = import_path8.resolve(project_path);
     const assetsDir = import_path8.join(resolvedProject, "Assets");
-    if (!import_fs16.existsSync(assetsDir)) {
+    if (!import_fs17.existsSync(assetsDir)) {
       console.log(JSON.stringify({ error: `Assets directory not found in "${project_path}"` }, null, 2));
       process.exit(1);
     }
@@ -10718,7 +11746,7 @@ function build_read_command(getScanner) {
     const guid_re = /guid:\s*([a-f0-9]{32})/g;
     for (const f of files) {
       try {
-        const fc = import_fs16.readFileSync(f, "utf-8");
+        const fc = import_fs17.readFileSync(f, "utf-8");
         let gm;
         while ((gm = guid_re.exec(fc)) !== null) {
           referenced_guids.add(gm[1]);
@@ -10729,8 +11757,8 @@ function build_read_command(getScanner) {
     }
     const buildSettingsPath = import_path8.join(resolvedProject, "ProjectSettings", "EditorBuildSettings.asset");
     const build_scene_guids = new Set;
-    if (import_fs16.existsSync(buildSettingsPath)) {
-      const bsc = import_fs16.readFileSync(buildSettingsPath, "utf-8");
+    if (import_fs17.existsSync(buildSettingsPath)) {
+      const bsc = import_fs17.readFileSync(buildSettingsPath, "utf-8");
       let bm;
       while ((bm = guid_re.exec(bsc)) !== null) {
         build_scene_guids.add(bm[1]);
@@ -10848,19 +11876,11 @@ function build_read_command(getScanner) {
     }
     console.log(JSON.stringify({ file, ...ia }, null, 2));
   });
-  cmd.command("prefab").argument("[file]").allowUnknownOption().action(() => {
-    console.log(JSON.stringify({
-      success: false,
-      error: '"read prefab" does not exist. Use "read scene" -- it handles both .unity and .prefab files.',
-      correct_usage: "unity-agentic-tools read scene <file.prefab>"
-    }, null, 2));
-    process.exitCode = 1;
-  });
   return cmd;
 }
 
 // src/cmd-update.ts
-var import_fs17 = require("fs");
+var import_fs18 = require("fs");
 var import_path9 = require("path");
 
 // src/animator-utils.ts
@@ -11006,10 +12026,10 @@ function resolve_transform_id(scanner, file, identifier) {
   if (result && !result.is_error) {
     const transform = result.components?.find((c) => c.class_id === 4 || c.class_id === 224);
     if (transform)
-      return { transform_id: parseInt(transform.file_id, 10) };
+      return { transform_id: transform.file_id };
   }
   if (/^-?\d+$/.test(identifier)) {
-    return { transform_id: parseInt(identifier, 10) };
+    return { transform_id: identifier };
   }
   return { error: `Could not resolve "${identifier}" to a Transform component. Use a GameObject name or transform fileID.` };
 }
@@ -11027,7 +12047,7 @@ function build_update_command(getScanner) {
     if (!result.success)
       process.exitCode = 1;
   });
-  cmd.command("component <file> <file_id> <property> <value>").description("Edit any component property by file ID. Supports dotted paths (m_LocalPosition.x) and array paths (m_Materials.Array.data[0])").option("-j, --json", "Output as JSON").action((file, file_id, property, value, _options) => {
+  cmd.command("component <file> <file_id> <property> <value>").description("Edit any component property by file ID. Supports dotted paths (m_LocalPosition.x) and array paths (m_Materials.Array.data[0]). Quote paths with brackets or use dot notation (data.0) to avoid shell glob expansion").option("-j, --json", "Output as JSON").action((file, file_id, property, value, _options) => {
     if (property === "m_RootOrder") {
       const num = Number(value);
       if (!Number.isInteger(num) || num < 0) {
@@ -11183,14 +12203,71 @@ function build_update_command(getScanner) {
     if (!result.success)
       process.exitCode = 1;
   });
-  prefab_cmd.command("override <file> <prefab_instance> <property_path> <value>").description("Edit or add a property override in a PrefabInstance m_Modifications list").option("--object-reference <ref>", "Object reference value (default: {fileID: 0})").option("--target <target>", 'Target reference for new entries (e.g., "{fileID: 400000, guid: abc, type: 3}")').option("-j, --json", "Output as JSON").action((file, prefab_instance, property_path, value, options) => {
+  prefab_cmd.command("override <file> <prefab_instance> <property_path> <value>").description("Edit or add a property override in a PrefabInstance m_Modifications list. Quote paths with brackets or use dot notation (data.0) to avoid shell glob expansion").option("--object-reference <ref>", "Object reference value (default: {fileID: 0})").option("--managed-reference <id>", "Managed reference ID -- placed in value: field, forces objectReference: {fileID: 0}").option("--target <target>", 'Target reference for new entries (e.g., "{fileID: 400000, guid: abc, type: 3}")').option("-j, --json", "Output as JSON").action((file, prefab_instance, property_path, value, options) => {
+    if (options.objectReference && !/^\{fileID:/.test(options.objectReference)) {
+      console.error(`Warning: --object-reference "${options.objectReference}" does not look like a Unity object reference ({fileID: ...}). For managed reference IDs, use --managed-reference instead or pass the ID as the <value> argument.`);
+    }
     const result = editPrefabOverride({
       file_path: file,
       prefab_instance,
       property_path,
       new_value: value,
       object_reference: options.objectReference,
-      target: options.target
+      target: options.target,
+      managed_reference: options.managedReference
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.success)
+      process.exitCode = 1;
+  });
+  prefab_cmd.command("batch-overrides <file> <prefab_instance> <edits_json>").description('Batch edit multiple property overrides in a PrefabInstance. JSON format: [{"property_path":"...","value":"...","target":"...","object_reference":"..."}]').option("-j, --json", "Output as JSON").action((file, prefab_instance, edits_json, _options) => {
+    let raw_edits;
+    try {
+      const parsed = JSON.parse(edits_json);
+      if (!Array.isArray(parsed)) {
+        console.log(JSON.stringify({ success: false, error: 'Edits must be a JSON array. Format: [{"property_path":"...","value":"..."}]' }, null, 2));
+        process.exit(1);
+      }
+      raw_edits = parsed;
+    } catch {
+      console.log(JSON.stringify({ success: false, error: "Invalid JSON for edits" }, null, 2));
+      process.exit(1);
+    }
+    const edits = raw_edits.map((e) => ({
+      property_path: String(e.property_path ?? ""),
+      value: String(e.new_value ?? e.value ?? ""),
+      object_reference: e.object_reference != null ? String(e.object_reference) : undefined,
+      target: e.target != null ? String(e.target) : undefined,
+      managed_reference: e.managed_reference != null ? String(e.managed_reference) : undefined
+    }));
+    if (edits.length === 0) {
+      console.log(JSON.stringify({ success: false, error: 'Empty edits array. Provide at least one edit: [{"property_path":"...","value":"..."}]' }, null, 2));
+      process.exit(1);
+    }
+    for (const edit of edits) {
+      if (!edit.property_path) {
+        console.log(JSON.stringify({ success: false, error: 'Missing "property_path" in edit entry. JSON format: [{"property_path":"...","value":"..."}]' }, null, 2));
+        process.exit(1);
+      }
+      if (!edit.value && !edit.object_reference && !edit.managed_reference) {
+        console.log(JSON.stringify({ success: false, error: `Missing "value" for override "${edit.property_path}". Provide "value", "object_reference", or "managed_reference".` }, null, 2));
+        process.exit(1);
+      }
+    }
+    const result = batchEditPrefabOverrides(file, prefab_instance, edits);
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.success)
+      process.exitCode = 1;
+  });
+  prefab_cmd.command("managed-reference <file> <prefab_instance> <field_path> <type_name>").description("Add a [SerializeReference] managed reference to a prefab override. Auto-generates rid and creates type/data/version override entries.").requiredOption("--target <ref>", 'Target reference (e.g., "{fileID: 400000, guid: ..., type: 3}")').option("--index <n>", "Array index (default: 0)", "0").option("-p, --project <path>", "Unity project path (for type registry)").option("-j, --json", "Output as JSON").action((file, prefab_instance, field_path, type_name, options) => {
+    const result = addPrefabManagedReference({
+      file_path: file,
+      prefab_instance,
+      field_path,
+      type_name,
+      target: options.target,
+      index: parseInt(options.index, 10),
+      project_path: options.project
     });
     console.log(JSON.stringify(result, null, 2));
     if (!result.success)
@@ -11222,7 +12299,7 @@ function build_update_command(getScanner) {
       process.exitCode = 1;
     }
   });
-  cmd.command("array <file> <file_id> <array_property> <action> [args...]").description("Insert, append, or remove array elements in a component. Insert: <index> <value> or <value> --index <n>. Append: <value>. Remove: <index> or --index <n>.").option("--index <n>", "Index for insert/remove").option("-j, --json", "Output as JSON").action((file, file_id, array_property, action, args, options) => {
+  cmd.command("array <file> <file_id> <array_property> <action> [args...]").description("Insert, append, or remove array elements in a component. Insert: <index> <value> or <value> --index <n>. Append: <value>. Remove: <index> or --index <n>. Quote paths with brackets or use dot notation (data.0) to avoid shell glob expansion").option("--index <n>", "Index for insert/remove").option("-j, --json", "Output as JSON").action((file, file_id, array_property, action, args, options) => {
     if (action !== "insert" && action !== "append" && action !== "remove") {
       console.log(JSON.stringify({ success: false, error: 'Action must be "insert", "append", or "remove"' }, null, 2));
       process.exit(1);
@@ -11357,7 +12434,7 @@ function build_update_command(getScanner) {
     if (!result.success)
       process.exitCode = 1;
   });
-  prefab_cmd.command("remove-override <file> <prefab_instance> <property_path>").description("Remove a property override from a PrefabInstance").option("--target <ref>", "Target reference to match (for disambiguation)").option("-j, --json", "Output as JSON").action((file, prefab_instance, property_path, options) => {
+  prefab_cmd.command("remove-override <file> <prefab_instance> <property_path>").description("Remove a property override from a PrefabInstance. Quote paths with brackets or use dot notation (data.0) to avoid shell glob expansion").option("--target <ref>", "Target reference to match (for disambiguation)").option("-j, --json", "Output as JSON").action((file, prefab_instance, property_path, options) => {
     const result = removePrefabOverride({
       file_path: file,
       prefab_instance,
@@ -11418,11 +12495,11 @@ function build_update_command(getScanner) {
       }
     }
   }).action((file, options) => {
-    if (!import_fs17.existsSync(file)) {
+    if (!import_fs18.existsSync(file)) {
       console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }, null, 2));
       process.exit(1);
     }
-    let content = import_fs17.readFileSync(file, "utf-8");
+    let content = import_fs18.readFileSync(file, "utf-8");
     const changes = [];
     if (options.shader) {
       const guid = options.shader;
@@ -11571,7 +12648,7 @@ ${lm[1]}  - ${kw}
       process.exitCode = 1;
       return;
     }
-    import_fs17.writeFileSync(file, content, "utf-8");
+    import_fs18.writeFileSync(file, content, "utf-8");
     console.log(JSON.stringify({ success: true, file, changes }, null, 2));
   });
   cmd.command("meta [file]").description("Edit Unity .meta file importer settings").option("--set <key=value>", "Set an importer setting (e.g., isReadable=1)", (v, p) => [...p, v], []).option("--max-size <n>", "Set TextureImporter maxTextureSize").option("--compression <type>", "Set textureCompression (0=None, 1=LowQuality, 2=Normal, 3=HighQuality)").option("--filter-mode <mode>", "Set filterMode (0=Point, 1=Bilinear, 2=Trilinear)").option("--read-write", "Enable isReadable").option("--no-read-write", "Disable isReadable").option("--batch <glob>", "Apply to all matching files").option("--dry-run", "Preview changes without writing").option("-j, --json", "Output as JSON").action((file, options) => {
@@ -11632,9 +12709,9 @@ ${lm[1]}  - ${kw}
       const suffix = import_path9.basename(pattern).replace(/^\*+/, "");
       const meta_files = [];
       const scan = (d) => {
-        for (const entry of import_fs17.readdirSync(d)) {
+        for (const entry of import_fs18.readdirSync(d)) {
           const full = import_path9.join(d, entry);
-          if (import_fs17.statSync(full).isDirectory()) {
+          if (import_fs18.statSync(full).isDirectory()) {
             if (pattern.includes("**"))
               scan(full);
           } else if (entry.endsWith(suffix)) {
@@ -11642,7 +12719,7 @@ ${lm[1]}  - ${kw}
           }
         }
       };
-      if (import_fs17.existsSync(dir))
+      if (import_fs18.existsSync(dir))
         scan(dir);
       if (meta_files.length === 0) {
         console.log(JSON.stringify({ success: false, error: `No files matched pattern: ${glob_pattern}` }, null, 2));
@@ -11650,7 +12727,7 @@ ${lm[1]}  - ${kw}
       }
       const results = [];
       for (const mf of meta_files) {
-        let mc = import_fs17.readFileSync(mf, "utf-8");
+        let mc = import_fs18.readFileSync(mf, "utf-8");
         const file_changes = [];
         for (const edit of edits) {
           const re = new RegExp(`^(\\s*${edit.key}:)[ \\t]*.*$`, "m");
@@ -11661,7 +12738,7 @@ ${lm[1]}  - ${kw}
         }
         if (file_changes.length > 0) {
           if (!options.dryRun)
-            import_fs17.writeFileSync(mf, mc, "utf-8");
+            import_fs18.writeFileSync(mf, mc, "utf-8");
           results.push({ file: mf, changes: file_changes });
         }
       }
@@ -11674,11 +12751,11 @@ ${lm[1]}  - ${kw}
       }, null, 2));
       return;
     }
-    if (!import_fs17.existsSync(metaPath)) {
+    if (!import_fs18.existsSync(metaPath)) {
       console.log(JSON.stringify({ success: false, error: `Meta file not found: ${metaPath}` }, null, 2));
       process.exit(1);
     }
-    let content = import_fs17.readFileSync(metaPath, "utf-8");
+    let content = import_fs18.readFileSync(metaPath, "utf-8");
     const changes = [];
     for (const edit of edits) {
       const re = new RegExp(`^(\\s*${edit.key}:)[ \\t]*.*$`, "m");
@@ -11693,11 +12770,11 @@ ${lm[1]}  - ${kw}
       console.log(JSON.stringify({ success: true, dry_run: true, file: metaPath, changes }, null, 2));
       return;
     }
-    import_fs17.writeFileSync(metaPath, content, "utf-8");
+    import_fs18.writeFileSync(metaPath, content, "utf-8");
     console.log(JSON.stringify({ success: true, file: metaPath, changes }, null, 2));
   });
   cmd.command("animation <file>").description("Edit AnimationClip settings and events").option("--set <property=value>", "Set a clip property (e.g., wrap-mode=2 for Loop)", (v, p) => [...p, v], []).option("--add-event <time,function[,data]>", "Add an animation event (e.g., 0.5,OnFootstep,left)", (v, p) => [...p, v], []).option("--remove-event <index>", "Remove an animation event by index (0-based)").option("-j, --json", "Output as JSON").action((file, options) => {
-    if (!import_fs17.existsSync(file)) {
+    if (!import_fs18.existsSync(file)) {
       console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }, null, 2));
       process.exit(1);
     }
@@ -11705,7 +12782,7 @@ ${lm[1]}  - ${kw}
       console.log(JSON.stringify({ success: false, error: `File is not an AnimationClip (.anim): ${file}` }, null, 2));
       process.exit(1);
     }
-    let content = import_fs17.readFileSync(file, "utf-8");
+    let content = import_fs18.readFileSync(file, "utf-8");
     const changes = [];
     const property_map = {
       "wrap-mode": "m_WrapMode",
@@ -11866,16 +12943,16 @@ ${event_yaml}
       process.exitCode = 1;
       return;
     }
-    import_fs17.writeFileSync(file, content, "utf-8");
+    import_fs18.writeFileSync(file, content, "utf-8");
     console.log(JSON.stringify({ success: true, file, changes }, null, 2));
   });
   const PARAM_TYPE_MAP = { float: 1, int: 3, bool: 4, trigger: 9 };
   cmd.command("animator <file>").description("Edit AnimatorController parameters").option("--add-parameter <name>", "Add a new parameter").option("--type <float|int|bool|trigger>", "Parameter type (required with --add-parameter)").option("--remove-parameter <name>", "Remove a parameter by name").option("--set-default <param=value>", "Set parameter default value (e.g., Speed=1.5)", (v, p) => [...p, v], []).option("-j, --json", "Output as JSON").action((file, options) => {
-    if (!import_fs17.existsSync(file)) {
+    if (!import_fs18.existsSync(file)) {
       console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }, null, 2));
       process.exit(1);
     }
-    let content = import_fs17.readFileSync(file, "utf-8");
+    let content = import_fs18.readFileSync(file, "utf-8");
     const had_crlf = content.includes(`\r
 `);
     if (had_crlf)
@@ -11977,7 +13054,7 @@ $1`);
     if (had_crlf)
       content = content.replace(/\n/g, `\r
 `);
-    import_fs17.writeFileSync(file, content, "utf-8");
+    import_fs18.writeFileSync(file, content, "utf-8");
     console.log(JSON.stringify({ success: true, file, changes }, null, 2));
   });
   cmd.command("sibling-index <file> <object_name> <index>").description("Set the sibling index of a GameObject, renumbering all siblings").option("-j, --json", "Output as JSON").action((file, object_name, index_str, _options) => {
@@ -11987,7 +13064,7 @@ $1`);
       process.exitCode = 1;
       return;
     }
-    if (!import_fs17.existsSync(file)) {
+    if (!import_fs18.existsSync(file)) {
       console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }, null, 2));
       process.exitCode = 1;
       return;
@@ -12182,7 +13259,7 @@ $1`);
     console.log(JSON.stringify({ success: true, file, changes }, null, 2));
   });
   cmd.command("animation-curves <file>").description("Add, remove, or modify animation curves in an .anim file").option("--add-curve <json>", 'Add a curve (JSON: {"type":"float","path":"Body","attribute":"m_Alpha","classID":23,"keyframes":[{"time":0,"value":1}]})').option("--remove-curve <spec>", "Remove a curve by path:attribute (e.g., Body/Mesh:m_Alpha)").option("--set-keyframes <json>", 'Replace keyframes (JSON: {"curve":"path:attribute","keyframes":[{"time":0,"value":10}]})').option("-j, --json", "Output as JSON").action((file, options) => {
-    if (!import_fs17.existsSync(file)) {
+    if (!import_fs18.existsSync(file)) {
       console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }, null, 2));
       process.exitCode = 1;
       return;
@@ -12192,7 +13269,7 @@ $1`);
       process.exitCode = 1;
       return;
     }
-    let content = import_fs17.readFileSync(file, "utf-8");
+    let content = import_fs18.readFileSync(file, "utf-8");
     const had_crlf = content.includes(`\r
 `);
     if (had_crlf)
@@ -12490,16 +13567,16 @@ ${curve_yaml}`);
     if (had_crlf)
       content = content.replace(/\n/g, `\r
 `);
-    import_fs17.writeFileSync(file, content, "utf-8");
+    import_fs18.writeFileSync(file, content, "utf-8");
     console.log(JSON.stringify({ success: true, file, changes }, null, 2));
   });
   cmd.command("animator-state <file>").description("Add/remove states and transitions in an AnimatorController").option("--add-state <name>", "Add a new AnimatorState").option("--motion <guid-or-path>", "Motion clip GUID or file path (companion to --add-state)").option("--layer <name>", "Target layer name (default: first layer)").option("--speed <n>", "State speed (companion to --add-state, default: 1)").option("--remove-state <name>", "Remove a state and all its transitions").option("--add-transition <src:dst>", 'Add a transition (use "any" for AnyState source)').option("--condition <param,mode,threshold>", "Transition condition (repeatable)", (v, p) => [...p, v], []).option("--has-exit-time", "Enable exit time on transition").option("--exit-time <n>", "Exit time value (default: 0.75)").option("--duration <n>", "Transition duration (default: 0.25)").option("--remove-transition <src:dst>", "Remove a transition by source:destination state names").option("--set-default-state <name>", "Set the default state in the state machine").option("-j, --json", "Output as JSON").action((file, options) => {
-    if (!import_fs17.existsSync(file)) {
+    if (!import_fs18.existsSync(file)) {
       console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }, null, 2));
       process.exitCode = 1;
       return;
     }
-    let content = import_fs17.readFileSync(file, "utf-8");
+    let content = import_fs18.readFileSync(file, "utf-8");
     const had_crlf = content.includes(`\r
 `);
     if (had_crlf)
@@ -12838,10 +13915,34 @@ $1`);
     if (had_crlf)
       content = content.replace(/\n/g, `\r
 `);
-    import_fs17.writeFileSync(file, content, "utf-8");
+    import_fs18.writeFileSync(file, content, "utf-8");
     console.log(JSON.stringify({ success: true, file, changes }, null, 2));
   });
   cmd.addCommand(prefab_cmd);
+  cmd.command("managed-reference <file> <component_id> <field_path> <type_name>").description('Add a managed reference (SerializeReference) to a component field. Type can be "Namespace.ClassName" (registry lookup) or "Assembly Namespace.ClassName" (manual).').option("-p, --project <path>", "Unity project path (for type registry)").option("--append", "Append to array (do not update field rid)").option("--properties <json>", `JSON object of initial field values for the data block (e.g. '{"damage": "10"}')`).option("-j, --json", "Output as JSON").action((file, component_id, field_path, type_name, options) => {
+    let initial_values;
+    if (options.properties) {
+      try {
+        initial_values = JSON.parse(options.properties);
+      } catch {
+        console.log(JSON.stringify({ success: false, error: `Invalid JSON for --properties: ${options.properties}` }, null, 2));
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const result = editManagedReference({
+      file_path: file,
+      file_id: component_id,
+      field_path,
+      type_name,
+      project_path: options.project,
+      append: options.append === true,
+      initial_values
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.success)
+      process.exitCode = 1;
+  });
   return cmd;
 }
 
@@ -12907,16 +14008,16 @@ function build_delete_command() {
 var import_path11 = require("path");
 
 // src/editor-client.ts
-var import_fs18 = require("fs");
+var import_fs19 = require("fs");
 var import_path10 = require("path");
 function read_editor_config(project_path) {
   const config_path = import_path10.join(project_path, ".unity-agentic", "editor.json");
-  if (!import_fs18.existsSync(config_path)) {
+  if (!import_fs19.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_fs18.readFileSync(config_path, "utf-8");
+    const raw = import_fs19.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)}` };
@@ -12929,23 +14030,45 @@ function read_editor_config(project_path) {
   }
   return config;
 }
+var RETRYABLE_CODES = new Set([-32000, -32002, -32003]);
+var RETRY_DELAYS = [500, 1000, 2000];
 async function call_editor(options) {
-  const { method, params, timeout = 1e4 } = options;
+  const maxRetries = options.retries ?? 2;
+  let lastResponse;
+  for (let attempt = 0;attempt <= maxRetries; attempt++) {
+    lastResponse = await call_editor_once(options);
+    if (!lastResponse.error || !RETRYABLE_CODES.has(lastResponse.error.code)) {
+      return lastResponse;
+    }
+    if (attempt < maxRetries) {
+      const delay = RETRY_DELAYS[Math.min(attempt, RETRY_DELAYS.length - 1)];
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  return lastResponse;
+}
+function call_editor_once(options) {
+  const { method, params, timeout = 1e4, no_wait } = options;
   const config = resolve_config(options);
   if ("error" in config) {
-    return {
+    return Promise.resolve({
       jsonrpc: "2.0",
       id: "0",
       error: { code: -32000, message: config.error }
-    };
+    });
   }
   const url = `ws://127.0.0.1:${config.port}/unity-agentic`;
   const request_id = generate_id();
+  const wire_params = { ...params };
+  if (timeout !== 1e4)
+    wire_params._timeout = timeout;
+  if (no_wait)
+    wire_params.no_wait = true;
   const request = {
     jsonrpc: "2.0",
     id: request_id,
     method,
-    ...params ? { params } : {}
+    ...Object.keys(wire_params).length > 0 ? { params: wire_params } : {}
   };
   return new Promise((resolve7) => {
     let resolved = false;
@@ -12967,6 +14090,20 @@ async function call_editor(options) {
       ws = new WebSocket(url);
       ws.onopen = () => {
         ws.send(JSON.stringify(request));
+        if (no_wait && !resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          setTimeout(() => {
+            try {
+              ws.close();
+            } catch {}
+          }, 200);
+          resolve7({
+            jsonrpc: "2.0",
+            id: request_id,
+            result: { queued: true }
+          });
+        }
       };
       ws.onmessage = (event) => {
         try {
@@ -13022,42 +14159,75 @@ async function stream_editor(options) {
   if ("error" in config) {
     throw new Error(config.error);
   }
-  const url = `ws://127.0.0.1:${config.port}/unity-agentic`;
-  const request_id = generate_id();
-  const request = {
-    jsonrpc: "2.0",
-    id: request_id,
-    method,
-    ...params ? { params } : {}
-  };
+  const MAX_RECONNECTS = 5;
+  let reconnect_count = 0;
+  let stopped = false;
   return new Promise((resolve7, reject) => {
-    let connected = false;
-    const timer = setTimeout(() => {
-      if (!connected) {
-        reject(new Error(`Timeout connecting to ${url}`));
-      }
-    }, timeout);
-    const ws = new WebSocket(url);
-    ws.onopen = () => {
-      connected = true;
-      clearTimeout(timer);
-      ws.send(JSON.stringify(request));
-      resolve7({ close: () => ws.close() });
-    };
-    ws.onmessage = (event) => {
-      try {
-        const data = JSON.parse(String(event.data));
-        if ("method" in data && !("id" in data)) {
-          on_event(data);
+    let resolved = false;
+    function connect(url) {
+      const ws = new WebSocket(url);
+      const request_id = generate_id();
+      const request = {
+        jsonrpc: "2.0",
+        id: request_id,
+        method,
+        ...params ? { params } : {}
+      };
+      let connected = false;
+      const timer = !resolved ? setTimeout(() => {
+        if (!connected && !resolved) {
+          reject(new Error(`Timeout connecting to ${url}`));
         }
-      } catch {}
-    };
-    ws.onerror = () => {
-      if (!connected) {
-        clearTimeout(timer);
-        reject(new Error(`WebSocket connection failed to ${url}`));
-      }
-    };
+      }, timeout) : null;
+      ws.onopen = () => {
+        connected = true;
+        if (timer)
+          clearTimeout(timer);
+        reconnect_count = 0;
+        ws.send(JSON.stringify(request));
+        if (!resolved) {
+          resolved = true;
+          resolve7({ close: () => {
+            stopped = true;
+            ws.close();
+          } });
+        }
+      };
+      ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(String(event.data));
+          if ("method" in data && !("id" in data)) {
+            on_event(data);
+          }
+        } catch {}
+      };
+      ws.onerror = () => {
+        if (!connected && !resolved) {
+          if (timer)
+            clearTimeout(timer);
+          reject(new Error(`WebSocket connection failed to ${url}`));
+        }
+      };
+      ws.onclose = () => {
+        if (stopped)
+          return;
+        if (!connected && !resolved)
+          return;
+        if (reconnect_count >= MAX_RECONNECTS)
+          return;
+        reconnect_count++;
+        const delay = Math.min(500 * reconnect_count, 3000);
+        setTimeout(() => {
+          if (stopped)
+            return;
+          const fresh_config = resolve_config(options);
+          if ("error" in fresh_config)
+            return;
+          connect(`ws://127.0.0.1:${fresh_config.port}/unity-agentic`);
+        }, delay);
+      };
+    }
+    connect(`ws://127.0.0.1:${config.port}/unity-agentic`);
   });
 }
 function resolve_config(options) {
@@ -13101,12 +14271,12 @@ function get_common_options(cmd) {
   const port = port_str ? parseInt(port_str, 10) : undefined;
   return { project_path, timeout, port };
 }
-function build_call_options(cmd, method, params) {
+function build_call_options(cmd, method, params, extra) {
   const { project_path, timeout, port } = get_common_options(cmd);
-  return { project_path, method, params, timeout, port };
+  return { project_path, method, params, timeout, port, ...extra?.no_wait ? { no_wait: true } : {} };
 }
-async function handle_rpc(cmd, method, params) {
-  const options = build_call_options(cmd, method, params);
+async function handle_rpc(cmd, method, params, extra) {
+  const options = build_call_options(cmd, method, params, extra);
   const response = await call_editor(options);
   output_response(response);
 }
@@ -13183,24 +14353,27 @@ function build_editor_command() {
       console.log(JSON.stringify(response.result, null, 2));
     }
   });
-  cmd.command("invoke <type> <member> [args...]").description("Call a static Unity Editor API method or read/set a static property").option("--set <value>", "Set a static property value").option("--args <json>", "JSON array of method arguments (overrides positional args)").action(async function(type, member, args, options) {
+  cmd.command("invoke <type> <member> [args...]").description("Call a static Unity Editor API method or read/set a static property").option("--set <value>", "Set a static property value").option("--args <json>", "JSON array of method arguments (overrides positional args)").option("--no-wait", "Fire and forget -- return immediately without waiting for result").action(async function(type, member, args, options) {
     const params = { type, member };
     if (options.set !== undefined) {
       params.set = options.set;
     } else if (options.args) {
       params.args = options.args;
+    } else if (args.length === 1 && args[0].startsWith("[")) {
+      params.args = args[0];
     } else if (args.length > 0) {
       params.args = JSON.stringify(args);
     }
-    await handle_rpc(this, "editor.invoke", params);
+    await handle_rpc(this, "editor.invoke", params, { no_wait: options.noWait });
   });
-  cmd.command("console-logs").description("Get recent console log entries").option("-c, --count <n>", "Number of log entries to retrieve", "50").option("--limit <n>", "Alias for --count").option("-t, --type <type>", "Filter by log type (Log, Warning, Error, Assert, Exception)").action(async function(options) {
+  cmd.command("console-logs").description("Get recent console log entries").option("-c, --count <n>", "Number of log entries to retrieve", "50").option("--limit <n>", "Alias for --count").option("-t, --type <type>", "Filter by log type (Log, Warning, Error, Assert, Exception)").option("-s, --severity <type>", "Alias for --type").action(async function(options) {
     const params = {};
     const count = options.limit || options.count;
     if (count)
       params.count = parseInt(count, 10);
-    if (options.type)
-      params.type = options.type;
+    const typeFilter = options.severity || options.type;
+    if (typeFilter)
+      params.type = typeFilter;
     await handle_rpc(this, "editor.console.getLogs", params);
   });
   cmd.command("console-clear").description("Clear the console log buffer").action(async function() {
@@ -13217,7 +14390,7 @@ function build_editor_command() {
         port,
         method: "editor.console.subscribe",
         on_event: (event) => {
-          if (event.method === "editor.console.logReceived" || event.method === "editor.event.logMessage") {
+          if (event.method === "editor.console.logReceived") {
             const params = event.params ?? {};
             if (type_filter && typeof params.type === "string" && params.type.toLowerCase() !== type_filter) {
               return;
@@ -13475,23 +14648,12 @@ function build_editor_command() {
       process.exitCode = 1;
     }
   });
-  cmd.command("log").allowUnknownOption().argument("[args...]").action(() => {
-    console.log(JSON.stringify({
-      success: false,
-      error: '"editor log" does not exist. Use one of:',
-      alternatives: [
-        { command: "editor console-logs", description: "Get recent console entries from the running Editor (live bridge)" },
-        { command: "read log", description: "Read and filter the Unity Editor.log file on disk (no bridge needed)" }
-      ]
-    }, null, 2));
-    process.exitCode = 1;
-  });
   return cmd;
 }
 
 // src/project-search.ts
 init_scanner();
-var import_fs19 = require("fs");
+var import_fs20 = require("fs");
 var path8 = __toESM(require("path"));
 var BINARY_EXTENSIONS = new Set([
   ".png",
@@ -13554,7 +14716,7 @@ function walk_project_files_js(project_path, extensions, exclude_dirs) {
   function walk(dir) {
     let entries;
     try {
-      entries = import_fs19.readdirSync(dir);
+      entries = import_fs20.readdirSync(dir);
     } catch {
       return;
     }
@@ -13562,7 +14724,7 @@ function walk_project_files_js(project_path, extensions, exclude_dirs) {
       const full = path8.join(dir, entry);
       let stat;
       try {
-        stat = import_fs19.statSync(full);
+        stat = import_fs20.statSync(full);
       } catch {
         continue;
       }
@@ -13579,14 +14741,14 @@ function walk_project_files_js(project_path, extensions, exclude_dirs) {
     }
   }
   const assetsDir = path8.join(project_path, "Assets");
-  if (import_fs19.existsSync(assetsDir)) {
+  if (import_fs20.existsSync(assetsDir)) {
     walk(assetsDir);
   } else {
     walk(project_path);
   }
   if (extSet.has(".asset")) {
     const settingsDir = path8.join(project_path, "ProjectSettings");
-    if (import_fs19.existsSync(settingsDir)) {
+    if (import_fs20.existsSync(settingsDir)) {
       walk(settingsDir);
     }
   }
@@ -13627,7 +14789,7 @@ function search_project(options) {
       error: "Name pattern must not be empty"
     };
   }
-  if (!import_fs19.existsSync(project_path)) {
+  if (!import_fs20.existsSync(project_path)) {
     return {
       success: false,
       project_path,
@@ -13669,7 +14831,7 @@ function search_project(options) {
       }
       let display_name = fileName;
       try {
-        const content = import_fs19.readFileSync(file, "utf-8");
+        const content = import_fs20.readFileSync(file, "utf-8");
         const nameMatch = /^\s*m_Name:\s*(.+)$/m.exec(content.slice(0, 2000));
         if (nameMatch)
           display_name = nameMatch[1].trim();
@@ -13850,7 +15012,7 @@ function grep_project_js(options) {
     max_results = 100,
     context_lines = 0
   } = options;
-  if (!import_fs19.existsSync(project_path)) {
+  if (!import_fs20.existsSync(project_path)) {
     return {
       success: false,
       project_path,
@@ -13940,7 +15102,7 @@ function grep_project_js(options) {
     totalFilesScanned++;
     let content;
     try {
-      content = import_fs19.readFileSync(file, "utf-8");
+      content = import_fs20.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -14219,9 +15381,9 @@ program.command("status").description("Show current configuration and status").o
   let config = null;
   let guidCacheCount = 0;
   try {
-    const { existsSync: existsSync22, readFileSync: readFileSync15 } = require("fs");
+    const { existsSync: existsSync22, readFileSync: readFileSync17 } = require("fs");
     if (existsSync22(configFile)) {
-      config = JSON.parse(readFileSync15(configFile, "utf-8"));
+      config = JSON.parse(readFileSync17(configFile, "utf-8"));
     }
     const guidCacheObj = load_guid_cache(projectPath);
     guidCacheCount = guidCacheObj?.count ?? 0;