@@ -84,6 +84,15 @@ public enum ErrorCode
     // identity.reference @references names an FK target object that does not resolve
     // to any object in the loaded tree (a dangling cross-reference between metadata).
     ERR_INVALID_REFERENCE,
+    // ADR-0041 — cross-package reference contract. A BARE reference (no "::") names
+    // an object present in MORE THAN ONE package with NO match in the referrer's own
+    // package → ambiguous; the author must qualify it with the package (FQN). An FQN
+    // ref resolves exactly (never ambiguous); a bare ref unique anywhere, or matching
+    // the referrer's own package, resolves fine. Covers every object-ref-bearing attr
+    // (@objectRef / @references / @from|@of|@via heads / @payloadRef / @responseRef /
+    // @parameterRef). `extends` is EXCLUDED — its super-resolver is same-package/root-
+    // strict, so a bare cross-package extends is ERR_UNRESOLVED_SUPER, not ambiguous.
+    ERR_AMBIGUOUS_REF,
     ERR_BAD_ATTR_FILTER,
     ERR_STORAGE_WITHOUT_OBJECT_REF,
     // ADR-0013: a field.object REQUIRES @objectRef (open/untyped JSON uses the
 
@@ -482,6 +482,11 @@ public LoadResult Load(IReadOnlyList<IMetaDataSource> sources)
             // cardinality, extends/origin agreement)
             errors.AddRange(ValidationPasses.ValidateOriginPaths(root));
 
+            // Pass 5a: ADR-0041 — cross-package OBJECT-reference ambiguity. A bare
+            // ref (@objectRef/@references/@from|@of|@via head/@payloadRef/…) naming
+            // an object in multiple packages, none in the referrer's, → ERR_AMBIGUOUS_REF.
+            errors.AddRange(ValidationPasses.ValidateCrossPackageRefs(root));
+
             // Pass 5b: FR-024 B6 — derived-field providability on entities
             errors.AddRange(ValidationPasses.ValidateDerivedFieldProvidability(root));
 
 
@@ -494,6 +494,121 @@ internal static bool RefMatchesObject(MetaData node, string reference)
         || node.Fqn() == reference
         || node.Name == reference;
 
+    // =========================================================================
+    // ADR-0041 — cross-package OBJECT reference resolution + ambiguity pass.
+    //   Ported from typescript/packages/metadata/src/naming-refs.ts
+    //   (resolveObjectRef) + loader/validation-passes.ts (validateCrossPackageRefs).
+    // =========================================================================
+
+    /// <summary>The inline (bare) attribute names whose VALUE names another OBJECT and is
+    /// therefore subject to the ADR-0041 cross-package resolution contract. Mirrors TS
+    /// <c>REF_BEARING_ATTR_NAMES</c>. <c>extends</c> is intentionally absent — its super-
+    /// resolver is same-package/root-strict (a bare cross-package extends is
+    /// ERR_UNRESOLVED_SUPER, not ambiguous). Attrs are keyed bare (no <c>@</c>) on the node.</summary>
+    private static readonly IReadOnlyList<string> RefBearingAttrNames = new[]
+    {
+        RELATIONSHIP_ATTR_OBJECT_REF,          // = FIELD_ATTR_OBJECT_REF ("objectRef")
+        IDENTITY_REFERENCE_ATTR_REFERENCES,    // "references"
+        ORIGIN_PASSTHROUGH_ATTR_FROM,          // "from"
+        ORIGIN_PASSTHROUGH_ATTR_VIA,           // = ORIGIN_AGGREGATE_ATTR_VIA ("via")
+        ORIGIN_AGGREGATE_ATTR_OF,              // "of"
+        SOURCE_ATTR_PARAMETER_REF,             // "parameterRef"
+        TEMPLATE_ATTR_PAYLOAD_REF,             // "payloadRef"
+        TEMPLATE_ATTR_RESPONSE_REF,            // "responseRef"
+    };
+
+    /// <summary>The effective package of a root-level object (its <see cref="MetaData.ResolutionKey"/>
+    /// minus the trailing <c>::&lt;name&gt;</c>; "" for a root-level/empty-package object).
+    /// Mirrors TS <c>objectPackage</c>.</summary>
+    private static string ObjectPackage(MetaData node)
+    {
+        string key = node.ResolutionKey();
+        int i = key.LastIndexOf(PACKAGE_SEPARATOR, StringComparison.Ordinal);
+        return i == -1 ? "" : key[..i];
+    }
+
+    /// <summary>Outcome of <see cref="ResolveObjectRef"/>: the uniquely resolved object
+    /// (<see cref="Node"/>) or a cross-package-ambiguous bare ref (<see cref="Ambiguous"/>).</summary>
+    private readonly record struct ObjectRefResolution(MetaData? Node, bool Ambiguous);
+
+    /// <summary>
+    /// Resolve a metadata OBJECT reference under the ADR-0041 cross-package contract:
+    ///   - <b>FQN</b> (<paramref name="reference"/> contains <c>::</c>) → EXACT match on
+    ///     ResolutionKey()/Fqn(); never a bare-tail fallback, so an FQN pointing at one
+    ///     package never binds a same-named object in another.
+    ///   - <b>bare</b> (no <c>::</c>) → prefer an object of that name in the REFERRER's own
+    ///     package; else a UNIQUE object of that name anywhere; else (&gt;1 across OTHER
+    ///     packages, none in the referrer's) → ambiguous.
+    /// Mirrors TS <c>resolveObjectRef(root, ref, referrerPkg)</c>.
+    /// </summary>
+    private static ObjectRefResolution ResolveObjectRef(MetaData root, string reference, string referrerPkg)
+    {
+        var objects = root.Children().Where(c => c.Type == TYPE_OBJECT).ToList();
+        if (reference.Contains(PACKAGE_SEPARATOR, StringComparison.Ordinal))
+        {
+            return new ObjectRefResolution(
+                objects.FirstOrDefault(c => c.ResolutionKey() == reference || c.Fqn() == reference),
+                false);
+        }
+        var matches = objects.Where(c => c.Name == reference).ToList();
+        if (matches.Count <= 1) return new ObjectRefResolution(matches.Count == 1 ? matches[0] : null, false);
+        var own = matches.FirstOrDefault(c => ObjectPackage(c) == referrerPkg);
+        if (own is not null) return new ObjectRefResolution(own, false);
+        return new ObjectRefResolution(null, true);
+    }
+
+    /// <summary>
+    /// ADR-0041 — a BARE object reference (no <c>::</c>) that names an object present in
+    /// MORE THAN ONE package, with NO match in the referrer's own package, is ambiguous →
+    /// ERR_AMBIGUOUS_REF (the author must qualify it with the package). An FQN ref is exact
+    /// (never ambiguous); a bare ref matching the referrer's own package, or unique anywhere,
+    /// resolves fine. Covers every object-ref-bearing attr in <see cref="RefBearingAttrNames"/>
+    /// — the dotted <c>.child</c> tail of the origin heads is stripped to the entity OWNER.
+    /// <c>extends</c> is intentionally NOT covered (see <see cref="RefBearingAttrNames"/>).
+    /// Mirrors TS <c>validateCrossPackageRefs</c>.
+    /// </summary>
+    public static IReadOnlyList<MetaError> ValidateCrossPackageRefs(MetaData root)
+    {
+        var errors = new List<MetaError>();
+        foreach (var obj in root.Children().Where(c => c.Type == TYPE_OBJECT))
+        {
+            // Referrer package = the object's own package, else its file-default —
+            // ObjectPackage(obj) folds both (ResolutionKey minus ::name), matching
+            // TS `obj.package ?? obj.fileDefaultPackage ?? ""`.
+            string referrerPkg = ObjectPackage(obj);
+            VisitCrossPackageRefs(obj, obj, root, referrerPkg, errors);
+        }
+        return errors.AsReadOnly();
+    }
+
+    private static void VisitCrossPackageRefs(
+        MetaData node, MetaData obj, MetaData root, string referrerPkg, List<MetaError> errors)
+    {
+        foreach (var attrName in RefBearingAttrNames)
+        {
+            if (node.OwnAttr(attrName) is not string raw) continue;
+            // Owner = the object part; strip any FR-024 dotted `.child` tail. An FQN
+            // owner (has `::`) is resolved exactly and can never be ambiguous.
+            int dot = raw.IndexOf(CHILD_REF_SEPARATOR, StringComparison.Ordinal);
+            string owner = dot == -1 ? raw : raw[..dot];
+            if (owner.Contains(PACKAGE_SEPARATOR, StringComparison.Ordinal) || owner == "") continue;
+            if (!ResolveObjectRef(root, owner, referrerPkg).Ambiguous) continue;
+            var pkgs = root.Children()
+                .Where(c => c.Type == TYPE_OBJECT && c.Name == owner)
+                .Select(c => c.ResolutionKey());
+            errors.Add(new MetaError(
+                $"{attrName} \"{raw}\" on {obj.Fqn()}: bare reference \"{owner}\" is ambiguous — it names an object " +
+                $"in multiple packages ({string.Join(", ", pkgs)}) and none is in the referrer's package \"{referrerPkg}\". " +
+                "Qualify it with the package (FQN).",
+                ErrorCode.ERR_AMBIGUOUS_REF,
+                Envelope: ResolvedSource.From(node.Source, obj.Fqn(), owner)));
+        }
+        foreach (var child in node.OwnChildren())
+        {
+            VisitCrossPackageRefs(child, obj, root, referrerPkg, errors);
+        }
+    }
+
     // -------------------------------------------------------------------------
     // Origin helper: _findField
     // -------------------------------------------------------------------------
 
@@ -260,10 +260,15 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
         if (!field.hasMetaAttr(MetaObject.ATTR_OBJECT_REF, true)) return null
         val ref = field.getMetaAttr(MetaObject.ATTR_OBJECT_REF, true).valueAsString
         if (ref.isNullOrEmpty()) return null
-        val refShort = ref.substringAfterLast("::")
+        // ADR-0041: a FULLY-QUALIFIED @objectRef (contains "::") resolves EXACTLY on the
+        // value-object's package-qualified name — never a bare-tail fallback (the closed
+        // bug: an FQN ref binding a same-named object.value in the WRONG package). A bare
+        // ref matches the object.value's short name (the cross-port render-helper consensus).
+        val fqn = ref.contains("::")
         for (obj in loader.metaObjects) {
             if (MetaObject.SUBTYPE_VALUE != obj.subType) continue
-            if (obj.name.substringAfterLast("::") == refShort) return obj
+            val matches = if (fqn) obj.name == ref else obj.name.substringAfterLast("::") == ref
+            if (matches) return obj
         }
         return null
     }
 
@@ -108,17 +108,18 @@ public static List<M2mNav> resolve(MetaObject entity, MetaDataLoader loader) {
 
     private static MetaObject findEntity(MetaRoot root, String name) {
         if (name == null) return null;
-        String bare = stripPackage(name);
+        // ADR-0041: a FULLY-QUALIFIED ref (contains "::") resolves EXACTLY on the
+        // object's package-qualified name — it never falls back to a bare-tail match
+        // (the closed bug: an FQN @objectRef / @through binding a same-named object
+        // in the WRONG package). A bare ref matches the object's short name (first
+        // match wins; cross-package same-package-preference is the deferred codegen
+        // follow-up, mirroring the TS residual note).
+        boolean fqn = name.indexOf("::") >= 0;
         // ADR-0039: root-level entity scan — root is never extended, so own children
         // is correct (entities are declared directly under root, not inherited into it).
         for (MetaObject mo : root.getChildren(MetaObject.class, false)) {
-            if (bare.equals(mo.getShortName())) return mo;
+            if (fqn ? name.equals(mo.getName()) : name.equals(mo.getShortName())) return mo;
         }
         return null;
     }
-
-    private static String stripPackage(String name) {
-        int idx = name.lastIndexOf("::");
-        return idx >= 0 ? name.substring(idx + 2) : name;
-    }
 }
@@ -165,6 +165,19 @@ public enum ErrorCode {
      */
     ERR_AMBIGUOUS_PATH,
 
+    /**
+     * ADR-0041 (cross-package reference resolution): a BARE object reference (no
+     * {@code ::}) names an object that exists in MORE THAN ONE package, and NONE of
+     * those candidates is in the referrer's own package. The reference is ambiguous;
+     * the author must qualify it with the package (FQN). Applies to every
+     * object-ref-bearing attribute ({@code @objectRef}, {@code @references}, the
+     * {@code @from}/{@code @of}/{@code @via} heads, {@code @payloadRef}/{@code @responseRef},
+     * {@code @parameterRef}). {@code extends} is excluded — its same-package/root-strict
+     * super-resolver never matches a packaged object by bare name, so a bare
+     * cross-package {@code extends} is {@code ERR_UNRESOLVED_SUPER}, not ambiguous.
+     */
+    ERR_AMBIGUOUS_REF,
+
     /**
      * FR-024 (ADR-0029): origin cardinality contract broken — a passthrough
      * {@code @via} path crosses a to-many hop (row-multiplying passthrough — you meant