1. `copy_cache` in `models.py` recursively copies the caches to environment, 
2. which in
```python
def _compute_related(self, records):
        """ Compute the related field ``self`` on ``records``. """
        others = records.sudo() if self.related_sudo else records
        if records.env != others.env:
            copy_cache(records - records.filtered('id'), others.env)
        values = list(others)
        for name in self.related[:-1]:
            values = [first(value[name]) for value in values]
        for record, value in zip(records, values):
            record[self.name] = value[self.related_field.name]
```
3. copies failing cache values that have been produce previously by this line:

`models.py : def _prefetch_field()`
```python

        try:
            # THIS ONE
            result = records.read([f.name for f in fs], load='_classic_write')
        except AccessError:
            # not all records may be accessible, try with only current record
            result = self.read([f.name for f in fs], load='_classic_write')
```
I checked it's exactly the same `FailedValue` object, which is later accessed without intent (not refreshed) by the fact that the buggy environment is copied to sudo (and not refreshed).


""" The decimal precision and currency symbol are taken from the attribute
    :param currency_field: name of the field holding the currency this monetary
                           field is expressed in (default: `currency_id`)
    """
    type = 'monetary'
    column_type = ('numeric', 'numeric')
    _slots = {
        'currency_field': None,
        'group_operator': 'sum',
    }
    def __init__(self, string=Default, currency_field=Default, **kwargs):
        super(Monetary, self).__init__(string=string, currency_field=currency_field, **kwargs)
    _related_currency_field = property(attrgetter('currency_field'))
    _description_currency_field = property(attrgetter('currency_field'))
    _description_group_operator = property(attrgetter('group_operator'))
    def _setup_regular_full(self, model):
        super(Monetary, self)._setup_regular_full(model)
        if not self.currency_field:
            
            if 'currency_id' in model._fields:
                self.currency_field = 'currency_id'
            elif 'x_currency_id' in model._fields:
                self.currency_field = 'x_currency_id'
        assert self.currency_field in model._fields, \
            "Field %s with unknown currency_field %r" % (self, self.currency_field)
    def convert_to_column(self, value, record):