@@ -914,6 +914,11 @@ jobs:
           # so the exemption must resolve the binding, not just the name.
           echo "$out" | grep -qE "AssociatedObjectSourceSample\.cs:[0-9]+: warning: \[OWN001\].*'ShadowParamBehavior'" \
             || { echo "FAIL: expected OWN001 when a shadowing parameter is named AssociatedObject (#227)"; exit 1; }
+          # (5) a PARTIAL behavior whose field is assigned from AssociatedObject in one
+          # declaration but from an injected value in the sibling partial — the field-
+          # population scan must span every partial of the type.
+          echo "$out" | grep -qE "AssociatedObjectSourceSample\.cs:[0-9]+: warning: \[OWN001\].*'PartialFieldBehavior'" \
+            || { echo "FAIL: expected OWN001 when a sibling partial injects the AssociatedObject field (#227)"; exit 1; }
           echo "OK: real C# -> facts -> OWN001 (subscription + timer + field + Subscribe + pool + local) + OWN014 (static-event region escape) + DI001 (captive dependency) + DI002 (scoped captured weakly) + DI003 (transient IDisposable captured by a singleton) + DI004 (transient IDisposable service-located from the root provider) + DI005 (scoped service cached from a created scope) + [OwnIgnore] suppression (silent-but-counted, SARIF suppressions) + #218 DP old->new subscription rotation (silent; controls flagged) + #225 empty-Dispose local exemption (silent; controls flagged) + #228 curated app-scoped source in App (silent; controls flagged) + #227 self-owned Behavior.AssociatedObject source (silent; controls flagged) at the C# location"
       - name: Flow-sensitive local IDisposables (--flow-locals, P-016 B0b/B2)
         run: |
 
@@ -1118,33 +1118,49 @@ when des.Ancestors().OfType<IsPatternExpressionSyntax>().FirstOrDefault()
         return false;
     }
     if (sym is IFieldSymbol field)
-        return FieldAssignedOnlyFromAssociatedObject(field, model, clsNode, depth);
+        return FieldAssignedOnlyFromAssociatedObject(field, model, depth);
     return false;
 }
 
 // #227: a field is a valid `AssociatedObject` alias only when it is populated ONLY
 // from `AssociatedObject` — at least one such assignment, and no assignment to a
 // value we cannot prove is `AssociatedObject` (an injected/constructed write would
-// make the field's contents ambiguous at the `+=`). Class-level assignment scan, the
-// same mechanism the field-based self-owned search already uses; the field-population
-// evidence may live in the same `OnAttached` or any other member of the class.
+// make the field's contents ambiguous at the `+=`). Scans EVERY partial declaration of
+// the field's containing type (a disqualifying injected write may live in a sibling
+// partial FILE — the merged compilation makes them all reachable through the symbol's
+// DeclaringSyntaxReferences), each with its own tree's semantic model. The field
+// population evidence may thus live in the same `OnAttached` or any other member/partial
+// of the class.
 static bool FieldAssignedOnlyFromAssociatedObject(IFieldSymbol field, SemanticModel model,
-                                                  TypeDeclarationSyntax clsNode, int depth)
+                                                  int depth)
 {
     var any = false;
-    foreach (var asg in clsNode.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+    foreach (var decl in EnumerateTypeDeclarations(field.ContainingType))
     {
-        if (!asg.IsKind(SyntaxKind.SimpleAssignmentExpression))
-            continue;
-        if (!SymbolEqualityComparer.Default.Equals(model.GetSymbolInfo(asg.Left).Symbol, field))
-            continue;
-        any = true;
-        if (!ResolvesToAssociatedObject(asg.Right, model, clsNode, depth + 1))
-            return false;
+        var m = model.Compilation.GetSemanticModel(decl.SyntaxTree);
+        foreach (var asg in decl.DescendantNodes().OfType<AssignmentExpressionSyntax>())
+        {
+            if (!asg.IsKind(SyntaxKind.SimpleAssignmentExpression))
+                continue;
+            if (!SymbolEqualityComparer.Default.Equals(m.GetSymbolInfo(asg.Left).Symbol, field))
+                continue;
+            any = true;
+            if (!ResolvesToAssociatedObject(asg.Right, m, decl, depth + 1))
+                return false;
+        }
     }
     return any;
 }
 
+// The syntax declarations of a type symbol — every `partial` piece (in the merged
+// compilation, across files). Used to scan a member's assignment sites wherever they live.
+static IEnumerable<TypeDeclarationSyntax> EnumerateTypeDeclarations(INamedTypeSymbol type)
+{
+    foreach (var r in type.DeclaringSyntaxReferences)
+        if (r.GetSyntax() is TypeDeclarationSyntax td)
+            yield return td;
+}
+
 // #227: the self-owned-source exemption for a `Behavior` reaching its own
 // `AssociatedObject`. The `+=` receiver must resolve to `this.AssociatedObject` (or an
 // assignment-chain-local/field/pattern-var provably drawn from it). Caller gates on
 
@@ -155,4 +155,27 @@ public void Wire(UiElement AssociatedObject)
 
         void OnLoaded(object? sender, EventArgs e) { }
     }
+
+    // CONTROL 5 (flagged): a PARTIAL behavior whose field is assigned from
+    // `AssociatedObject` in one declaration but ALSO from an injected value in the
+    // sibling partial — the field-population scan must span every partial of the type,
+    // so the ambiguous field keeps the warning.
+    public partial class PartialFieldBehavior : Behavior<UiElement>
+    {
+        UiElement? _el;
+
+        protected void OnAttached()
+        {
+            _el = this.AssociatedObject;
+            if (_el is Panel panel)
+                panel.Loaded += OnLoaded;                    // OWN001: _el also injected in the sibling partial
+        }
+
+        void OnLoaded(object? sender, EventArgs e) { }
+    }
+
+    public partial class PartialFieldBehavior
+    {
+        public void Inject(UiElement injected) => _el = injected;   // sibling-partial injected write
+    }
 }