@@ -508,27 +508,20 @@ impl ResolveStage {
     /// (Extends evidence, MRO order for python), None = not on the chain.
     /// Inherited members resolve through the chain; the concrete type's own
     /// override always ranks closer.
-    fn receiver_chain_distance(
+    /// Identity anchor for an inferred receiver type: the specific Class
+    /// symbol the type name denotes in THIS file — file-scope resolution
+    /// (imports included) first, then the exactly-one function-local Class
+    /// inside the caller's span. None when the name does not resolve to a
+    /// Class here (unresolvable import specifier, non-Class kinds such as
+    /// rust Structs): copy selection is then impossible and distance 0
+    /// stays name-keyed.
+    fn receiver_type_anchor(
         &self,
-        candidate: &crate::Symbol,
         type_name: &str,
         caller: Option<&crate::Symbol>,
-        language_id: &LanguageId,
         context: &ResolutionContext,
-    ) -> Option<usize> {
-        let behavior = self.get_behavior(language_id)?;
-        if behavior.is_receiver_compatible(candidate, type_name, caller) {
-            return Some(0);
-        }
-        // Ancestor hops are identity-grade: the receiver type must resolve
-        // to a Class through THIS file's scope, and each hop follows that
-        // class's own Extends edges with scope-resolved parents. Bare-name
-        // chains merge every same-named class in the corpus (the pydantic
-        // test `Model` population) and mis-attribute inherited members.
-        // Chains dead-end after leaving the file (a parent's own Extends
-        // edges live in its file's context): deep cross-file chains
-        // under-report.
-        let start = context
+    ) -> Option<SymbolId> {
+        context
             .resolve(type_name)
             .filter(|&id| {
                 self.symbol_cache
@@ -555,7 +548,58 @@ impl ResolveStage {
                     }
                 }
                 only
-            })?;
+            })
+    }
+
+    fn receiver_chain_distance(
+        &self,
+        candidate: &crate::Symbol,
+        type_name: &str,
+        caller: Option<&crate::Symbol>,
+        language_id: &LanguageId,
+        context: &ResolutionContext,
+    ) -> Option<usize> {
+        let behavior = self.get_behavior(language_id)?;
+        // Distance 0: with an identity anchor, membership is in the ANCHORED
+        // class copy — same file, inside the anchor's span, direct member.
+        // Name-keyed compatibility alone cannot split duplicate class copies
+        // (vendored bundles, twin test files) or same-file same-name locals.
+        // Without an anchor, name-keyed is the only evidence there is.
+        let anchor = self.receiver_type_anchor(type_name, caller, context);
+        match anchor {
+            Some(anchor_id) => {
+                let (anchor_name, anchor_file, anchor_range) = {
+                    let sym = self.symbol_cache.get_ref(anchor_id)?;
+                    (sym.name.clone(), sym.file_id, sym.range)
+                };
+                if candidate.file_id == anchor_file
+                    && range_contains(&anchor_range, &candidate.range)
+                    && self.is_direct_member(
+                        candidate.scope_context.as_ref(),
+                        candidate.range,
+                        anchor_id,
+                        &anchor_name,
+                        anchor_file,
+                    )
+                {
+                    return Some(0);
+                }
+            }
+            None => {
+                if behavior.is_receiver_compatible(candidate, type_name, caller) {
+                    return Some(0);
+                }
+            }
+        }
+        // Ancestor hops are identity-grade: the receiver type must resolve
+        // to a Class through THIS file's scope, and each hop follows that
+        // class's own Extends edges with scope-resolved parents. Bare-name
+        // chains merge every same-named class in the corpus (the pydantic
+        // test `Model` population) and mis-attribute inherited members.
+        // Chains dead-end after leaving the file (a parent's own Extends
+        // edges live in its file's context): deep cross-file chains
+        // under-report.
+        let start = anchor?;
         let mut frontier = vec![start];
         for distance in 1..=8usize {
             let mut next = Vec::new();
 
@@ -1,10 +1,14 @@
-//! Multi-survivor instance-receiver disambiguation fails closed.
+//! Multi-survivor instance-receiver disambiguation fails closed;
+//! an identity anchor recovers the pick.
 //!
 //! Regression for the three.js mis-pick class: when the inferred receiver
 //! type matches multiple same-name members (duplicate class copies in the
 //! corpus), resolution must not fall through to the name-keyed priority
 //! ladder, whose terminal arms are first-pick and proximity — not identity
-//! evidence. Exactly one survivor resolves; zero or many fail closed.
+//! evidence. Exactly one survivor resolves; zero or many fail closed —
+//! unless the receiver type resolves to a specific Class in the caller's
+//! file scope (import binding) or span (function-local class): then the
+//! anchored copy's own member wins and the other copies are rejected.
 
 use codanna::config::Settings;
 use codanna::indexing::pipeline::types::{
@@ -133,6 +137,188 @@ fn duplicate_class_copies_fail_closed() {
     assert_eq!(stats.total_processed, 1);
 }
 
+fn class_sym(id: u32, name: &str, file: u32, range: Range) -> Symbol {
+    let mut sym = Symbol::new(
+        SymbolId::new(id).unwrap(),
+        name,
+        SymbolKind::Class,
+        FileId::new(file).unwrap(),
+        range,
+    );
+    sym.language_id = Some(js());
+    sym.visibility = Visibility::Public;
+    sym
+}
+
+fn method_in_class(id: u32, name: &str, class: &str, file: u32, range: Range) -> Symbol {
+    let mut sym = Symbol::new(
+        SymbolId::new(id).unwrap(),
+        name,
+        SymbolKind::Method,
+        FileId::new(file).unwrap(),
+        range,
+    );
+    sym.language_id = Some(js());
+    sym.visibility = Visibility::Public;
+    sym.scope_context = Some(ScopeContext::ClassMember {
+        class_name: Some(class.into()),
+    });
+    sym
+}
+
+/// Duplicate copies exist, but the caller's file scope binds the type name
+/// to one specific Class (an import binding): that copy's member wins.
+#[test]
+fn import_anchored_duplicate_copies_recover() {
+    use codanna::parsing::ResolutionScope;
+    use codanna::parsing::resolution::ScopeLevel;
+
+    let caller_file = 1;
+    let cache = Arc::new(SymbolLookupCache::new());
+    cache.insert(caller_fn(1, caller_file));
+    cache.insert(method_of_class(2, "set", "Vector2", 2));
+    cache.insert(method_in_class(
+        3,
+        "set",
+        "Vector3",
+        3,
+        Range::new(1, 1, 3, 2),
+    ));
+    cache.insert(method_in_class(
+        4,
+        "set",
+        "Vector3",
+        4,
+        Range::new(1, 1, 3, 2),
+    ));
+    cache.insert(class_sym(5, "Vector3", 3, Range::new(0, 0, 4, 1)));
+    cache.insert(class_sym(6, "Vector3", 4, Range::new(0, 0, 4, 1)));
+
+    let mut scope = GenericResolutionContext::new(FileId::new(caller_file).unwrap());
+    scope.add_symbol(
+        "Vector3".to_string(),
+        SymbolId::new(5).unwrap(),
+        ScopeLevel::Module,
+    );
+
+    let stage = ResolveStage::new(Arc::clone(&cache), build_behaviors());
+    let (call, bindings) = typed_receiver_call(caller_file);
+
+    let context = ResolutionContext {
+        file_id: FileId::new(caller_file).unwrap(),
+        language_id: js(),
+        imports: vec![],
+        local_symbols: vec![],
+        scope: Box::new(scope),
+        unresolved_rels: vec![call],
+        variable_bindings: bindings,
+    };
+    let (batch, stats) = stage.resolve(&context);
+
+    assert_eq!(
+        batch.len(),
+        1,
+        "the anchored copy's member must win over the duplicate in file 4"
+    );
+    let rel = batch
+        .relationships
+        .first()
+        .expect("one resolved relationship");
+    assert_eq!(
+        rel.to_id,
+        SymbolId::new(3).unwrap(),
+        "survivor is the member of the Class the scope binding names"
+    );
+    assert_eq!(stats.calls_resolved, 1);
+}
+
+/// Two same-name function-local classes in ONE file (the pydantic
+/// validate_call twin-test shape): the class inside the caller's own span
+/// anchors, and only its member resolves.
+#[test]
+fn span_local_class_anchors_same_file_duplicates() {
+    let caller_file = 1;
+    let cache = Arc::new(SymbolLookupCache::new());
+    // Caller spans lines 2..20; its local class X spans 3..8 with foo at
+    // 4..6. A sibling test function's X spans 30..38 with foo at 31..33.
+    let mut caller = caller_fn(1, caller_file);
+    caller.range = Range::new(2, 0, 20, 1);
+    cache.insert(caller);
+    cache.insert(method_in_class(
+        2,
+        "foo",
+        "X",
+        caller_file,
+        Range::new(4, 1, 6, 2),
+    ));
+    cache.insert(method_in_class(
+        3,
+        "foo",
+        "X",
+        caller_file,
+        Range::new(31, 1, 33, 2),
+    ));
+    cache.insert(class_sym(5, "X", caller_file, Range::new(3, 0, 8, 1)));
+    cache.insert(class_sym(6, "X", caller_file, Range::new(30, 0, 38, 1)));
+
+    let stage = ResolveStage::new(Arc::clone(&cache), build_behaviors());
+
+    let call = UnresolvedRelationship {
+        from_id: Some(SymbolId::new(1).unwrap()),
+        from_name: "run".into(),
+        to_name: "foo".into(),
+        file_id: FileId::new(caller_file).unwrap(),
+        kind: RelationKind::Calls,
+        metadata: Some(RelationshipMetadata {
+            line: Some(10),
+            column: Some(1),
+            context: None,
+            receiver: Some("x".into()),
+            static_call: false,
+        }),
+        to_range: Some(Range::new(10, 1, 10, 20)),
+    };
+    let bindings = vec![VariableBinding {
+        name: "x".to_string(),
+        type_name: "X".to_string(),
+        range: Range::new(9, 1, 9, 20),
+    }];
+
+    let context = ResolutionContext {
+        file_id: FileId::new(caller_file).unwrap(),
+        language_id: js(),
+        imports: vec![],
+        local_symbols: vec![
+            SymbolId::new(5).unwrap(),
+            SymbolId::new(6).unwrap(),
+            SymbolId::new(2).unwrap(),
+            SymbolId::new(3).unwrap(),
+        ],
+        scope: Box::new(GenericResolutionContext::new(
+            FileId::new(caller_file).unwrap(),
+        )),
+        unresolved_rels: vec![call],
+        variable_bindings: bindings,
+    };
+    let (batch, stats) = stage.resolve(&context);
+
+    assert_eq!(
+        batch.len(),
+        1,
+        "the X inside the caller's span anchors; its foo must resolve"
+    );
+    let rel = batch
+        .relationships
+        .first()
+        .expect("one resolved relationship");
+    assert_eq!(
+        rel.to_id,
+        SymbolId::new(2).unwrap(),
+        "survivor is the caller-span X's foo, not the sibling function's"
+    );
+    assert_eq!(stats.calls_resolved, 1);
+}
+
 #[test]
 fn single_class_copy_resolves_correct_member() {
     let (batch, stats) = resolve_with_candidates(false);