Current policy after applying all updates:
- duplicate_policy: first
- fold_case: true
- tombstone_wins: true
- trim_ids: true
- list_merge: replace (Update 5)
- nested_merge: true (Update 4)
- null_mode: ignore (Update 4)
- version_floor: 2 (Update 5)
- audit_all: true
- empty_id: skip
- order: id (Update 6)
- unknown_fields: keep (Update 6)

Design decisions:
- The payload is assumed to be either a list of events or a dict with an "events" key. I accept both.
- Deduplication keeps the first-seen position of each (id, version) key, and the selected event is the first or the last occurrence per the policy. Processing order is sorted by (version, selected original index).
- The tombstone-blocked outcome is "blocked". A deletion on an existing record is applied, and it also adds a tombstone when tombstone_wins is on. A deletion with no record is applied only if it installs a new tombstone, otherwise it is blocked. A non-deletion for a tombstoned id is blocked.
- With the policy values above, the list_merge=unique branch is not used, but I implement it anyway.
- Case folding is ASCII only.
- Unknown-field filtering is implemented in the code and only applies when unknown_fields=drop.
- Nothing in the input is mutated, since I deep-copy.

```json
{"files": {"main.py": "from core import run\nfrom policy import POLICY\ndef evaluate(payload):\n    return run(payload, POLICY)\n", "policy.py": "POLICY = {\n    'duplicate_policy': 'first',\n    'fold_case': True,\n    'tombstone_wins': True,\n    'trim_ids': True,\n    'list_merge': 'replace',\n    'nested_merge': True,\n    'null_mode': 'ignore',\n    'version_floor': 2,\n    'audit_all': True,\n    'empty_id': 'skip',\n    'order': 'id',\n    'unknown_fields': 'keep',\n}\n", "helpers.py": "import copy\n\ndef fold(s):\n    return ''.join(chr(ord(c) + 32) if 'A' <= c <= 'Z' else c for c in s)\n\ndef merge(old, new, policy):\n    res = copy.deepcopy(old)\n    for k, v in new.items():\n        if v is None:\n            if policy['null_mode'] == 'delete':\n                res.pop(k, None)\n            continue\n        if k in res:\n            o = res[k]\n            if isinstance(o, dict) and isinstance(v, dict) and policy['nested_merge']:\n                res[k] = merge(o, v, policy)\n                continue\n            if isinstance(o, list) and isinstance(v, list) and policy['list_merge'] == 'unique':\n                add = [copy.deepcopy(x) for x in v if not any(x == y for y in o)]\n                res[k] = copy.deepcopy(o) + add\n                continue\n        res[k] = copy.deepcopy(v)\n    return res\n", "core.py": "import copy\nfrom helpers import fold, merge\n\ndef run(payload, policy):\n    events = payload.get('events', []) if isinstance(payload, dict) else payload\n    cands = []\n    for i, e in enumerate(events):\n        nid = e['id']\n        if policy['trim_ids']:\n            nid = nid.strip()\n        if policy['fold_case']:\n            nid = fold(nid)\n        if nid == '':\n            if policy['empty_id'] == 'raise':\n                raise ValueError('empty id')\n            continue\n        if e['version'] < policy['version_floor']:\n            continue\n        cands.append((nid, e['version'], i, e))\n    groups = {}\n    order = []\n    for nid, ver, i, e in cands:\n        k = (nid, ver)\n        if k not in groups:\n            groups[k] = [i, e]\n            order.append(k)\n        elif policy['duplicate_policy'] == 'last':\n            groups[k] = [i, e]\n    sel = [(k[1], groups[k][0], k[0], groups[k][1]) for k in order]\n    sel.sort(key=lambda t: (t[0], t[1]))\n    records = {}\n    tomb = set()\n    first = {}\n    audit = []\n    for pos, (ver, idx, nid, e) in enumerate(sel):\n        if nid not in first:\n            first[nid] = pos\n        applied = False\n        if e['deleted']:\n            if nid in records:\n                del records[nid]\n                applied = True\n                if policy['tombstone_wins']:\n                    tomb.add(nid)\n            elif policy['tombstone_wins'] and nid not in tomb:\n                tomb.add(nid)\n                applied = True\n        else:\n            if not (policy['tombstone_wins'] and nid in tomb):\n                cur = records.get(nid, {})\n                records[nid] = merge(cur, e['fields'], policy)\n                applied = True\n        if applied or policy['audit_all']:\n            audit.append('%s:%d:%s' % (nid, ver, 'applied' if applied else 'blocked'))\n    out = []\n    for nid, f in records.items():\n        f = copy.deepcopy(f)\n        if policy['unknown_fields'] == 'drop':\n            f = {k: v for k, v in f.items() if k in ('name', 'tags', 'meta')}\n        out.append((nid, f))\n    if policy['order'] == 'id':\n        out.sort(key=lambda t: t[0])\n    else:\n        out.sort(key=lambda t: (first[t[0]], t[0]))\n    return {'records': [{'id': n, 'fields': f} for n, f in out], 'audit': audit}\n"}}
```