Blame for cases/redcap/runtime.py

"""Released environment operations and snapshot validation."""
from __future__ import annotations
from copy import deepcopy as ext_deepcopy
from functools import lru_cache
from pathlib import Path as ext_Path
from typing import Any as ext_Any
import hashlib as mod_hashlib
import importlib as mod_importlib
import json as mod_json
import jsonschema as mod_jsonschema
import sys as mod_sys
from .spec import CASE_DIR, DATA_GROUP_BY_ATOM, DATA_ENTITY_ID_FIELDS, DATA_TASK_IDS, DATA_TOOLS_2, DATA_SYNTHETIC_ASSIGNEES, DATA_PRE_STRUCTURE_AUTHORITY, DATA_TASK_IDS_2, DATA_PROFILE_SPECS, DATA_SCHEDULE_2, DATA_CHANGED_STRUCTURE_ATOMS, DATA_POST_STRUCTURE_AUTHORITY, DATA_PRE_STRUCTURE_AUTHORITY_2, DATA_STREAM_BLUEPRINT, DATA_WORKFLOW_CLASS, DATA_LIST_TOOLS, DATA_STRUCTURE_GROUPS, DATA_TOOL_BY_NAME, DATA_WRITE_TOOLS, DATA_DRIFT_CHANGED_STRUCTURES, DATA_STREAM_TASK_BLUEPRINT, DATA_DEV_BLUEPRINT

def fn_public_task(task_id):
    packet = fn_public_task_2(task_id)
    if packet['objective'].count('Close as many listed REDCap work packets as possible in priority order.') != 1:
        raise ValueError('Parent REDCap order statement differs')
    packet['objective'] = packet['objective'].replace('Close as many listed REDCap work packets as possible in priority order.', 'Close as many listed REDCap work packets as possible. Packets may be processed in any order; an unfinished record does not block an unrelated record.')
    packet['completion'].update(mode='independent', priority_order='none', started_item_must_close=False)
    return packet

def fn_activate_task(self, task_id, *, apply_boundary=True):
    if task_id not in DATA_TASK_IDS_2:
        return fn__error('TASK_NOT_AVAILABLE', 'the request event is unavailable')
    expected = DATA_TASK_IDS_2[len(self._activated_tasks)] if len(self._activated_tasks) < len(DATA_TASK_IDS_2) else None
    if task_id != expected:
        raise ValueError(f'expected {expected}, got {task_id}')
    self._task_id = task_id
    self._events = []
    self._calls = 0
    self._read_units = 0
    self._write_attempts = 0
    self._targets = [self._inject_target(target) for target in fn_stream_targets(task_id)]
    boundary = self.apply_structure_event() if task_id == 'T09' and apply_boundary else None
    self._entry_entities = self._state.snapshot()
    self._activated_tasks.append(task_id)
    self._assert_invariants()
    return {'status': 'success', 'event_id': fn_opaque_event_id(task_id), 'boundary_event_applied': bool(boundary and boundary['applied']), 'public_notice': '', 'world_reset': False, 'budget_reset': True, 'entry_business_hash': self.business_hash()}

def fn__workflow_recipe(target, compact):
    field = compact['target_field']
    query = compact['query']
    event = compact['record_event']
    forms = {row['form_instance_id']: row for row in compact['forms']}
    handles = {'primary': target['primary_form_id'], 'companion': target['companion_form_id']}
    complete_roles = []
    if not event['locked']:
        for (role, handle) in handles.items():
            if forms[handle]['completion_status'] not in {'complete', 'locked'}:
                complete_roles.append(role)
    return {'workflow_class': target['workflow_class'], 'unlock_first': bool(event['locked']), 'update_field': not (field.get('value') == target['corrected_value'] and field.get('status') == 'verified'), 'answer_query': query.get('status') == 'open', 'resolve_query': query.get('status') != 'resolved', 'complete_form_roles': complete_roles, 'lock_final': True}

def fn__error(code, message):
    return {'status': 'error', 'data': {'error_code': code}, 'message': message}

def fn__packet_entities(target, assignee):
    group = DATA_GROUP_BY_ATOM[target['structure_atom']]
    profile = DATA_PROFILE_SPECS[target['profile_id']]
    query_status = profile['query_status']
    primary_value = profile['target_value']
    if primary_value == 'correct':
        primary_value = target['corrected_value']
    elif primary_value == 'wrong':
        primary_value = f"stale-{target['target_id'][-6:]}"
    primary_missing = 0 if str(primary_value).strip() else 1
    primary_status = profile['primary_form']
    companion_status = profile['companion_form']
    locked = bool(profile['locked'])
    complete_count = sum((status in {'complete', 'locked'} for status in (primary_status, companion_status)))
    event_status = 'locked' if locked else 'complete' if complete_count == 2 else 'in_progress' if complete_count else 'not_started'
    answer_text = 'Source confirmation received.' if query_status in {'answered', 'resolved'} else ''
    companion_value = f"reviewed-{target['target_id'][-6:]}"
    rows = {name: [] for name in DATA_ENTITY_ID_FIELDS}
    rows['record'].append({'record_id': target['record_id'], 'project_id': target['project_id'], 'redcap_record_id': target['redcap_record_id'], 'subject_label': target['subject_label'], 'data_access_group': group['data_access_group'], 'site_id': group['data_access_group'], 'site_name': group['project_title'], 'enrollment_status': 'enrolled', 'consent_status': 'signed', 'open_query_count': 1 if query_status == 'open' else 0, 'locked_event_count': 1 if locked else 0, 'last_event_id': target['event_id'], 'created_at': '2026-05-18T10:30:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
    rows['record_event'].append({'record_event_id': target['record_event_id'], 'project_id': target['project_id'], 'record_id': target['record_id'], 'event_id': target['event_id'], 'event_status': event_status, 'form_complete_count': complete_count, 'form_incomplete_count': 2 - complete_count, 'locked': locked, 'lock_reason': 'Prior closeout lock' if locked else '', 'last_verified_by': assignee if locked else '', 'last_verified_at': '2026-05-18T10:30:00Z' if locked else None, 'created_at': '2026-05-18T10:30:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
    for (form_id, instrument_id, status, missing) in ((target['primary_form_id'], target['primary_instrument_id'], primary_status, primary_missing), (target['companion_form_id'], target['companion_instrument_id'], companion_status, 0)):
        rows['form_instance'].append({'form_instance_id': form_id, 'project_id': target['project_id'], 'record_id': target['record_id'], 'event_id': target['event_id'], 'instrument_id': instrument_id, 'completion_status': status, 'completion_code': 0 if status == 'incomplete' else 1 if status == 'unverified' else 2, 'missing_required_count': missing, 'entered_by': assignee if status != 'incomplete' else '', 'created_at': '2026-05-18T10:30:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
    for (value_id, instrument_id, field_id, value) in ((target['primary_value_id'], target['primary_instrument_id'], target['primary_field_id'], primary_value), (target['companion_value_id'], target['companion_instrument_id'], target['companion_field_id'], companion_value)):
        rows['field_value'].append({'value_id': value_id, 'project_id': target['project_id'], 'record_id': target['record_id'], 'event_id': target['event_id'], 'instrument_id': instrument_id, 'field_id': field_id, 'value': value, 'source': 'manual', 'status': 'verified' if str(value).strip() else 'draft', 'updated_by': assignee if str(value).strip() else '', 'updated_at': '2026-05-18T10:30:00Z'})
    rows['data_query'].append({'query_id': target['query_id'], 'project_id': target['project_id'], 'record_id': target['record_id'], 'event_id': target['event_id'], 'instrument_id': target['primary_instrument_id'], 'field_id': target['primary_field_id'], 'status': query_status, 'priority': 'high', 'query_text': f"Confirm {target['primary_field_label']} before closeout.", 'answer_text': answer_text, 'opened_by': target['resolver'], 'assigned_to': assignee, 'opened_at': '2026-05-18T10:30:00Z', 'answered_at': '2026-05-18T10:30:00Z' if query_status in {'answered', 'resolved'} else None, 'resolved_at': '2026-05-18T10:30:00Z' if query_status == 'resolved' else None, 'updated_at': '2026-05-18T10:30:00Z'})
    return rows

def fn__actor_bindings(target, assignee):
    group = DATA_GROUP_BY_ATOM[target['structure_atom']]
    if group['mode'] == 'manager':
        actor = group['resolver']
        return {'field_actor_user_id': actor, 'query_answer_actor_user_id': actor, 'query_resolver_user_id': actor, 'lock_actor_user_id': actor}
    return {'field_actor_user_id': assignee, 'query_answer_actor_user_id': assignee, 'query_resolver_user_id': group['resolver'], 'lock_actor_user_id': assignee}

def fn__digest(value):
    return mod_hashlib.sha256(fn__canonical(value).encode('utf-8')).hexdigest()

def fn__hash(value):
    encoded = mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'))
    return mod_hashlib.sha256(encoded.encode('utf-8')).hexdigest()

def fn__normalize(result):
    value = ext_deepcopy(result)
    if value.get('status') == 'error':
        message = str(value.get('message') or '')
        value.setdefault('data', {})['error_code'] = message.split(':', 1)[0] if ':' in message else 'OPERATION_FAILED'
    return value

def fn_public_task_2(task_id):
    task = fn_public_task_3(task_id)
    task['completion'].pop('verification_required')
    task['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': "the final successful lock response's packet-completion receipt", 'proves': "the committed packet's completed forms, resolved query, verified field and locked event as reported"}
    task['budget']['charging'].append('An exact project_id/record_id profile request for your own completed packet in this episode returns only the previously issued closeout receipt, at zero read/write/call quota. Other profile and authority discovery remains paid.')
    return task

def fn_stream_targets(task_id):
    if task_id not in DATA_STREAM_BLUEPRINT:
        raise ValueError(f'unknown REDCap stream task: {task_id}')
    targets = []
    for (slot, (structure_id, profile_id, rule_id)) in enumerate(DATA_STREAM_BLUEPRINT[task_id], 1):
        group = DATA_GROUP_BY_ATOM[structure_id]
        ids = fn__dynamic_ids(task_id, structure_id)
        targets.append({'target_id': fn__opaque('packet', task_id, slot, length=12), 'task_id': task_id, 'slot': slot, 'structure_atom': structure_id, 'profile_id': profile_id, 'rule_atom': rule_id, 'workflow_class': DATA_WORKFLOW_CLASS[profile_id], 'project_id': group['project_id'], 'project_title': group['project_title'], 'subject_label': fn__subject_label(task_id, structure_id), 'redcap_record_id': fn__opaque_2('RC', task_id, structure_id, length=8).upper(), 'event_id': group['event_id'], 'primary_instrument_id': group['primary_instrument_id'], 'primary_field_id': group['primary_field_id'], 'primary_field_label': group['primary_field_label'], 'companion_instrument_id': group['companion_instrument_id'], 'companion_field_id': group['companion_field_id'], 'corrected_value': group['corrected_value'], 'old_assignee': DATA_PRE_STRUCTURE_AUTHORITY[structure_id], 'new_assignee': DATA_POST_STRUCTURE_AUTHORITY[structure_id], 'resolver': group['resolver'], 'reference_writes': DATA_PROFILE_SPECS[profile_id]['reference_writes'], **ids})
    return tuple(targets)

def fn_opaque_event_id(task_id):
    if task_id not in DATA_TASK_IDS_2:
        raise ValueError(f'unknown REDCap stream task: {task_id}')
    return fn__opaque('EV', task_id, 'closeout').upper()

def fn__canonical(value):
    return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'))

def fn_public_task_3(task_id):
    targets = []
    for target in fn_stream_targets(task_id):
        targets.append({'request_ref': target['target_id'], 'priority': target['slot'], 'workflow_class': target['workflow_class'], 'project_title': target['project_title'], 'subject_label': target['subject_label'], 'required_field_label': target['primary_field_label'], 'corrected_value': target['corrected_value'], 'experience_keys': {'project_binding': target['project_title'], 'workflow_procedure': target['workflow_class']}, 'operation_handles': {'query_id': target['query_id'], 'record_event_id': target['record_event_id'], 'event_id': target['event_id'], 'primary_form_id': target['primary_form_id'], 'companion_form_id': target['companion_form_id']}, 'requested_state': 'required value verified, query resolved, both forms complete, and the record event locked with a nonempty reason'})
    return {'schema': 'rescopebench-redcap-reusable-authority-task/v7', 'event_id': fn_opaque_event_id(task_id), 'objective': 'Close as many listed REDCap work packets as possible in priority order. For a new project binding, resolve the exact project and subject and inspect the active packet. A verified project binding and workflow-class procedure may be reused for later packets with the same experience keys; only the current subject record and supplied task-scoped handles then need binding. A successful final lock returns authoritative packet-completion evidence, so an extra readback is optional. Current business evidence overrides retained authority. Do not alter unrelated records.', 'targets': targets, 'completion': {'mode': 'ordered_independent', 'subset_allowed': True, 'priority_order': 'listed', 'started_item_must_close': True, 'verification_required': False}, 'budget': fn_budget_contract()}

def fn__workflow_recipe_from_profile(target):
    spec = DATA_PROFILE_SPECS[target['profile_id']]
    unlock_first = bool(spec['locked'])
    complete_roles = []
    if not unlock_first:
        if spec['primary_form'] not in {'complete', 'locked'}:
            complete_roles.append('primary')
        if spec['companion_form'] not in {'complete', 'locked'}:
            complete_roles.append('companion')
    return {'workflow_class': target['workflow_class'], 'unlock_first': unlock_first, 'update_field': spec['target_value'] != 'correct', 'answer_query': spec['query_status'] == 'open', 'resolve_query': spec['query_status'] != 'resolved', 'complete_form_roles': complete_roles, 'lock_final': True}

def fn__dynamic_ids(task_id, structure_id):
    return {'record_id': fn__opaque_2('rec', task_id, structure_id, 'record'), 'record_event_id': fn__opaque_2('rev', task_id, structure_id, 'record-event'), 'primary_form_id': fn__opaque_2('frm', task_id, structure_id, 'primary-form'), 'companion_form_id': fn__opaque_2('frm', task_id, structure_id, 'companion-form'), 'primary_value_id': fn__opaque_2('val', task_id, structure_id, 'primary-value'), 'companion_value_id': fn__opaque_2('val', task_id, structure_id, 'companion-value'), 'query_id': fn__opaque_2('qry', task_id, structure_id, 'query')}

def fn__opaque(prefix, *parts, length=14):
    material = '|'.join(['redcap-reusable-authority-v7', *(str(part) for part in parts)])
    token = mod_hashlib.sha256(material.encode('ascii')).hexdigest()[:length]
    return f'{prefix}-{token}'

def fn__subject_label(task_id, structure_id):
    group = DATA_GROUP_BY_ATOM[structure_id]
    stem = group['project_title'].split()[0]
    token = fn__opaque_2('case', task_id, structure_id, length=8).split('-', 1)[1].upper()
    return f'{stem} closeout case {token}'

def fn__opaque_2(prefix, *parts, length=12):
    payload = '|'.join((str(part) for part in parts))
    token = mod_hashlib.sha256(f'redcap-stream|{payload}'.encode('utf-8')).hexdigest()
    return f'{prefix}-{token[:length]}'

def fn_budget_contract():
    return {'limits': [{'resource': 'read_units', 'allowance': 6}, {'resource': 'write_attempts', 'allowance': 17}, {'resource': 'maximum_tool_calls', 'allowance': 48}], 'charging': ['A successful bounded listing charges at least one read unit and otherwise one unit per matched row before pagination.', 'An exact active-packet get_record_profile projection charges two read units during discovery.', 'After a packet has closed, an optional exact profile read is served from the current episode cache and charges zero read units.', 'An exact record-scoped current-query lookup charges two read units for the query and assignment-authority join.', 'A failed read charges one read unit. Every attempted mutation charges one write attempt, including rejected mutations.'], 'exhaustion': 'An unfunded business call fails without changing business state.', 'persistence': 'Project-title bindings, project-level field and authority bindings, and workflow-class procedures persist until contradicted. Request, subject, record, query, form, and record-event handles are task-scoped. Business state persists across episodes; all allowances replenish.'}

def fn__base_entities():
    fixture = fn_fixture_for_task('T01')
    static_types = {'project', 'project_user', 'dictionary_version', 'event', 'instrument', 'instrument_field'}
    entities = {name: [] for name in DATA_ENTITY_ID_FIELDS}
    for entity_type in static_types:
        entities[entity_type] = ext_deepcopy(fixture['entities'][entity_type])
    for project in entities['project']:
        project.update({'record_count': 0, 'open_query_count': 0})
    for user in entities['project_user']:
        user['status'] = 'active'
    by_user = {row['user_id']: row for row in entities['project_user']}
    compared = ('project_id', 'role', 'data_access_group', 'can_export_identifiers', 'can_manage_dictionary', 'can_lock_records', 'status')
    for structure_id in DATA_DRIFT_CHANGED_STRUCTURES:
        group = DATA_GROUP_BY_ATOM[structure_id]
        old = by_user[group['editor_old']]
        new = by_user[group['editor_new']]
        if any((old[key] != new[key] for key in compared)):
            raise AssertionError(f'non-equivalent drift assignees for {structure_id}')
    return entities

@lru_cache(**{'maxsize': 4, 'typed': False})
def fn__load_raw_logic(source_root):
    prefix = 'mcp_servers'
    saved = {name: module for (name, module) in list(mod_sys.modules.items()) if name == prefix or name.startswith(f'{prefix}.')}
    for name in saved:
        mod_sys.modules.pop(name, None)
    mod_sys.path.insert(0, source_root)
    try:
        module = mod_importlib.import_module('mcp_servers.redcap')
    finally:
        mod_sys.path.remove(source_root)
        for name in list(mod_sys.modules):
            if name == prefix or name.startswith(f'{prefix}.'):
                mod_sys.modules.pop(name, None)
        mod_sys.modules.update(saved)
    return module

def fn_fixture_for_task(task_id):
    if task_id != 'DEV01' and task_id not in DATA_STREAM_TASK_BLUEPRINT:
        raise ValueError(f'unknown task: {task_id}')
    post_drift = task_id != 'DEV01' and int(task_id[1:]) >= 9
    blueprint = DATA_DEV_BLUEPRINT if task_id == 'DEV01' else DATA_STREAM_TASK_BLUEPRINT[task_id]
    profile_by_atom = fn__profile_assignments(task_id)
    entities = {name: [] for name in DATA_ENTITY_ID_FIELDS}
    targets_by_atom: dict[str, dict[str, ext_Any]] = {}
    for (ordinal, group) in enumerate(DATA_STRUCTURE_GROUPS, 1):
        atom_id = group['atom_id']
        profile_id = profile_by_atom[atom_id]
        profile = DATA_PROFILE_SPECS[profile_id]
        project_id = group['project_id']
        current_editor = fn__current_editor(group, post_drift)
        users: list[dict[str, ext_Any]] = []
        if group['mode'] == 'entry':
            old_active = not (post_drift and atom_id in DATA_DRIFT_CHANGED_STRUCTURES)
            users.extend([fn__user_row(group['editor_old'], project_id, role='data_entry', group=group['data_access_group'], status='active' if old_active else 'inactive', can_lock=True), fn__user_row(group['editor_new'], project_id, role='data_entry', group=group['data_access_group'], status='inactive' if old_active else 'active', can_lock=True), fn__user_row(group['resolver'], project_id, role='monitor', group='central')])
        elif group['mode'] == 'coordinator':
            users.extend([fn__user_row(group['editor_old'], project_id, role='clinical_coordinator', group='central', can_lock=True), fn__user_row(group['resolver'], project_id, role='monitor', group='central')])
        else:
            users.extend([fn__user_row(group['editor_old'], project_id, role='data_entry', group='external-site'), fn__user_row(group['resolver'], project_id, role='data_manager', group='central', can_lock=True, can_manage_dictionary=True, can_export_identifiers=True), fn__user_row(group['pi'], project_id, role='principal_investigator', group='central', can_lock=True, can_manage_dictionary=True, can_export_identifiers=True)])
        entities['project_user'].extend(users)
        query_status = profile['query_status']
        target_value = profile['target_value']
        if target_value == 'correct':
            target_value = group['corrected_value']
        elif target_value == 'wrong':
            target_value = f'stale-{ordinal:02d}'
        companion_value = f'reviewed-{ordinal:02d}'
        primary_missing = 0 if str(target_value).strip() else 1
        primary_status = profile['primary_form']
        companion_status = profile['companion_form']
        locked = bool(profile['locked'])
        complete_count = sum((status in {'complete', 'locked'} for status in (primary_status, companion_status)))
        event_status = 'locked' if locked else 'complete' if complete_count == 2 else 'in_progress' if complete_count else 'not_started'
        open_count = 1 if query_status == 'open' else 0
        entities['project'].append({'project_id': project_id, 'title': group['project_title'], 'purpose': 'clinical research closeout', 'status': 'production', 'availability': 'active', 'design': 'longitudinal', 'primary_site': group['project_title'], 'surveys_enabled': False, 'record_autonumbering': True, 'record_count': 1, 'open_query_count': open_count, 'pending_export_count': 0, 'active_instrument_count': 2, 'data_access_group_count': 1, 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z', 'last_activity_at': '2026-05-18T10:30:00Z'})
        entities['event'].append({'event_id': group['event_id'], 'project_id': project_id, 'unique_event_name': f'closeout_{ordinal:02d}', 'event_label': group['event_label'], 'arm_num': 1, 'day_offset': ordinal * 7, 'offset_min': 0, 'offset_max': 30, 'status': 'active', 'sequence': 1, 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
        dictionary_id = fn__opaque_3('dict', atom_id, 'dictionary-v1')
        draft_dictionary_id = fn__opaque_3('dict', atom_id, 'dictionary-v2')
        entities['dictionary_version'].extend([{'dictionary_version_id': dictionary_id, 'project_id': project_id, 'version_number': 1, 'status': 'applied', 'created_by': group['resolver'], 'applied_by': group['resolver'], 'change_summary': 'Initial closeout dictionary', 'created_at': '2026-02-01T09:00:00Z', 'applied_at': '2026-02-02T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'}, {'dictionary_version_id': draft_dictionary_id, 'project_id': project_id, 'version_number': 2, 'status': 'draft', 'created_by': group['resolver'], 'applied_by': '', 'change_summary': 'Pending closeout dictionary update', 'created_at': '2026-02-10T09:00:00Z', 'applied_at': None, 'updated_at': '2026-05-18T10:30:00Z'}])
        for which in ('primary', 'companion'):
            instrument_id = group[f'{which}_instrument_id']
            field_id = group[f'{which}_field_id']
            entities['instrument'].append({'instrument_id': instrument_id, 'project_id': project_id, 'instrument_name': group[f'{which}_instrument_name'], 'instrument_label': group[f'{which}_instrument_label'], 'category': 'clinical', 'status': 'active', 'version': 1, 'field_count': 1, 'is_survey': False, 'mapped_event_ids': [group['event_id']], 'last_dictionary_version': dictionary_id, 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
            entities['instrument_field'].append({'field_id': field_id, 'project_id': project_id, 'instrument_id': instrument_id, 'field_name': group[f'{which}_field_name'], 'field_label': group[f'{which}_field_label'], 'field_type': 'text', 'required': True, 'identifier': False, 'validation': 'none', 'select_choices': 'none', 'branching_logic': 'None', 'ordinal': 1, 'status': 'active', 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
        entities['record'].append({'record_id': group['record_id'], 'project_id': project_id, 'redcap_record_id': group['redcap_record_id'], 'subject_label': group['subject_label'], 'data_access_group': group['data_access_group'], 'site_id': group['data_access_group'], 'site_name': group['project_title'], 'enrollment_status': 'enrolled', 'consent_status': 'signed', 'open_query_count': open_count, 'locked_event_count': 1 if locked else 0, 'last_event_id': group['event_id'], 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
        entities['record_event'].append({'record_event_id': group['record_event_id'], 'project_id': project_id, 'record_id': group['record_id'], 'event_id': group['event_id'], 'event_status': event_status, 'form_complete_count': complete_count, 'form_incomplete_count': 2 - complete_count, 'locked': locked, 'lock_reason': 'Prior closeout lock' if locked else '', 'last_verified_by': current_editor if locked else '', 'last_verified_at': '2026-05-18T10:30:00Z' if locked else None, 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
        for (form_id, instrument_id, status, missing) in ((group['primary_form_id'], group['primary_instrument_id'], primary_status, primary_missing), (group['companion_form_id'], group['companion_instrument_id'], companion_status, 0)):
            entities['form_instance'].append({'form_instance_id': form_id, 'project_id': project_id, 'record_id': group['record_id'], 'event_id': group['event_id'], 'instrument_id': instrument_id, 'completion_status': status, 'completion_code': fn__completion_code(status), 'missing_required_count': missing, 'entered_by': current_editor if status != 'incomplete' else '', 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'})
        for (value_id, instrument_id, field_id, value) in ((fn__opaque_3('val', atom_id, 'primary-value'), group['primary_instrument_id'], group['primary_field_id'], target_value), (fn__opaque_3('val', atom_id, 'companion-value'), group['companion_instrument_id'], group['companion_field_id'], companion_value)):
            entities['field_value'].append({'value_id': value_id, 'project_id': project_id, 'record_id': group['record_id'], 'event_id': group['event_id'], 'instrument_id': instrument_id, 'field_id': field_id, 'value': value, 'source': 'manual', 'status': 'verified' if str(value).strip() else 'draft', 'updated_by': current_editor if str(value).strip() else '', 'updated_at': '2026-05-18T10:30:00Z'})
        answer_text = 'Source confirmation received.' if query_status in {'answered', 'resolved'} else ''
        entities['data_query'].append({'query_id': group['query_id'], 'project_id': project_id, 'record_id': group['record_id'], 'event_id': group['event_id'], 'instrument_id': group['primary_instrument_id'], 'field_id': group['primary_field_id'], 'status': query_status, 'priority': 'high', 'query_text': f"Confirm {group['primary_field_label']} before closeout.", 'answer_text': answer_text, 'opened_by': group['resolver'], 'assigned_to': current_editor, 'opened_at': '2026-05-15T09:00:00Z', 'answered_at': '2026-05-18T10:30:00Z' if query_status in {'answered', 'resolved'} else None, 'resolved_at': '2026-05-18T10:30:00Z' if query_status == 'resolved' else None, 'updated_at': '2026-05-18T10:30:00Z'})
        targets_by_atom[atom_id] = {'structure_atom': atom_id, 'profile_id': profile_id, 'project_id': project_id, 'record_id': group['record_id'], 'record_event_id': group['record_event_id'], 'event_id': group['event_id'], 'primary_instrument_id': group['primary_instrument_id'], 'primary_field_id': group['primary_field_id'], 'primary_form_id': group['primary_form_id'], 'companion_form_id': group['companion_form_id'], 'query_id': group['query_id'], 'corrected_value': group['corrected_value'], 'reference_writes': profile['reference_writes'], **fn__selected_actors(group, post_drift)}
    targets = []
    for (index, (atom_id, profile_id, rule_atom)) in enumerate(blueprint, 1):
        target = ext_deepcopy(targets_by_atom[atom_id])
        target.update({'target_id': f'closeout-{task_id.lower()}-{index}', 'profile_id': profile_id, 'rule_atom': rule_atom})
        targets.append(target)
    return {'task_id': task_id, 'post_drift': post_drift, 'entities': entities, 'targets': targets}

def fn__profile_assignments(task_id):
    defaults = {f'S{index:02d}': f'P{index:02d}' for index in range(1, 9)}
    blueprint = DATA_DEV_BLUEPRINT if task_id == 'DEV01' else DATA_STREAM_TASK_BLUEPRINT[task_id]
    for (atom_id, profile_id, _) in blueprint:
        defaults[atom_id] = profile_id
    return defaults

def fn__current_editor(group, post_drift):
    if post_drift and group['atom_id'] in DATA_DRIFT_CHANGED_STRUCTURES:
        return group['editor_new']
    return group['editor_old']

def fn__user_row(user_id, project_id, *, role, group, status='active', can_lock=False, can_manage_dictionary=False, can_export_identifiers=False):
    return {'user_id': user_id, 'project_id': project_id, 'username': user_id.replace('usr-', 'staff.'), 'full_name': f'Project staff {user_id[-4:].upper()}', 'email': f'{user_id}@example.invalid', 'role': role, 'data_access_group': group, 'can_export_identifiers': can_export_identifiers, 'can_manage_dictionary': can_manage_dictionary, 'can_lock_records': can_lock, 'status': status, 'last_login_at': '2026-05-18T10:30:00Z', 'created_at': '2026-02-01T09:00:00Z', 'updated_at': '2026-05-18T10:30:00Z'}

def fn__opaque_3(prefix, atom_id, label):
    token = mod_hashlib.sha256(f'redcap-query-lock-v1|{atom_id}|{label}'.encode('ascii')).hexdigest()[:8]
    return f'{prefix}-{token}'

def fn__completion_code(status):
    return {'incomplete': 0, 'unverified': 1, 'complete': 2, 'locked': 2}[status]

def fn__selected_actors(group, post_drift):
    if group['mode'] == 'manager':
        actor = group['resolver']
        return {'field_actor_user_id': actor, 'query_answer_actor_user_id': actor, 'query_resolver_user_id': actor, 'lock_actor_user_id': actor}
    editor = fn__current_editor(group, post_drift)
    return {'field_actor_user_id': editor, 'query_answer_actor_user_id': editor, 'query_resolver_user_id': group['resolver'], 'lock_actor_user_id': editor}

class World:
    _legacy_staff_projection = False

    def _first_incomplete_slot(self):
        return None

    def public_task(self):
        return fn_public_task(self._task_id)

    def snapshot(self):
        value = self._redcap_authority_evolution_snapshot()
        value['independent_packet_contract'] = 'redcap-independent-packets-evolution-v3'
        return value

    def restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('independent_packet_contract', None) != 'redcap-independent-packets-evolution-v3':
            raise ValueError('REDCap independent packet contract differs')
        self._redcap_authority_evolution_restore(value)

    def apply_structure_event(self):
        result = self._redcap_reusable_authority_apply_structure_event()
        self.authority_revalidation.clear()
        return result

    def dispatch(self, name, arguments, actor_user_id='session-redcap-closeout-4x9'):
        result = self._redcap_evolution_dispatch(name, arguments, actor_user_id)
        self.authority_revalidation.clear()
        return result

    def __init__(self, *args, **kwargs):
        self._own_closeouts = {}
        self._redcap_authority_successor_init(*args, **kwargs)

    def activate_task(self, task_id, *, apply_boundary=True):
        result = fn_activate_task(self, task_id, apply_boundary=apply_boundary)
        if result.get('status') == 'success':
            self._own_closeouts = {}
        return result

    def _target_complete(self, target):
        if self._task_id is None:
            return False
        grade = self.grade(self._task_id)
        return any((row['target_id'] == target['target_id'] and row['complete'] for row in grade['deliverables']))

    def _read_cost(self, name, result):
        if name == 'get_record_profile' and result.get('status') == 'success':
            target = self._active_target_from_profile(result)
            if target is not None and self._target_complete(target):
                return 0
        return self._redcap_actionable_authority_read_cost(name, result)

    def _compact_profile(self, target, result):
        value = self._redcap_actionable_authority_compact_profile(target, result)
        compact = value['data']
        authority = compact['workflow_authority']
        compact['evidence_scope'] = {'persistent_until_contradicted': {'project_binding_key': target['project_title'], 'project_title': target['project_title'], 'project_id': target['project_id'], 'instrument_id': compact['target_field']['instrument_id'], 'field_id': compact['target_field']['field_id'], **ext_deepcopy(authority)}, 'reusable_workflow_procedure': fn__workflow_recipe(target, compact), 'task_scoped': {'request_ref': target['target_id'], 'subject_label': target['subject_label'], 'record_id': compact['record']['record_id'], 'query_id': compact['query']['query_id'], 'form_instance_ids': sorted((row['form_instance_id'] for row in compact['forms'])), 'record_event_id': compact['record_event']['record_event_id']}}
        return value

    def apply_assignment_drift(self, event_id='evt-redcap-authority-rotation-v7'):
        if event_id not in {'evt-redcap-authority-rotation-v7', 'evt-redcap-authority-rotation-v5'}:
            raise ValueError('unknown REDCap authority event')
        return self.apply_structure_event()

    def apply_drift(self, drift_id='evt-redcap-authority-rotation-v7'):
        return self.apply_assignment_drift(drift_id)

    def apply_boundary(self, event_id):
        if event_id in {'T09', 'evt-redcap-authority-rotation-v7', 'evt-redcap-authority-rotation-v5'}:
            return self.apply_structure_event()
        return {'event_id': event_id, 'application_count': self._drift_application_count, 'applied': False, 'idempotent_noop': True, 'before_world_sha256': self.business_hash(), 'after_world_sha256': self.business_hash(), 'registered_delta_sha256': 'c906f6670e3358b8460d789cc5d65113fcdba816ef2ee8d83c2ef6f871ec3c00'}

    def _active_target_from_profile(self, result):
        record = result.get('data', {}).get('record', {})
        record_id = record.get('record_id')
        project_id = record.get('project_id')
        return next((target for target in self._targets if target['record_id'] == record_id and target['project_id'] == project_id), None)

    @staticmethod
    def _workflow_authority(target, query):
        return {'field_actor_user_id': target['field_actor_user_id'], 'form_actor_user_id': target['field_actor_user_id'], 'query_answer_actor_user_id': target['query_answer_actor_user_id'], 'query_resolver_user_id': target['query_resolver_user_id'], 'lock_actor_user_id': target['lock_actor_user_id'], 'evidence_basis': 'record_scoped_query_and_assignment_authority'}

    def _target_for_arguments(self, name, arguments):
        key_by_tool = {'update_record_field': ('record_id', 'record_id'), 'update_data_query_answer': ('query_id', 'query_id'), 'resolve_data_query': ('query_id', 'query_id'), 'mark_form_complete': ('form_instance_id', None), 'set_record_event_lock': ('record_event_id', 'record_event_id')}
        selected = key_by_tool.get(name)
        if selected is None:
            return None
        (argument_key, target_key) = selected
        value = arguments.get(argument_key)
        for target in self._targets:
            if target_key is None:
                if value in {target['primary_form_id'], target['companion_form_id']}:
                    return target
            elif target.get(target_key) == value:
                return target
        return None

    def _target_for_read(self, arguments):
        record_id = arguments.get('record_id')
        project_id = arguments.get('project_id')
        return next((target for target in self._targets if target['record_id'] == record_id and target['project_id'] == project_id), None)

    def _charged_guard_error(self, name, code, message):
        if self._calls >= 48:
            result = fn__error('CALL_BUDGET_EXHAUSTED', 'task call safeguard is exhausted')
            result['budget'] = self._budget_receipt()
            return result
        if self._write_attempts >= 17:
            result = fn__error('WRITE_BUDGET_EXHAUSTED', 'task mutation-attempt allowance is exhausted')
            result['budget'] = self._budget_receipt()
            return result
        before = self.business_hash()
        self._calls += 1
        self._write_attempts += 1
        result = fn__error(code, message)
        self._record_adapter_event(name, 'session-redcap-closeout-4x9', result, before, before, cost=1)
        result['budget'] = self._budget_receipt()
        result['receipt_index'] = len(self._events)
        return result

    def _budget_receipt(self):
        return {'read_limit': 6, 'read_used': self._read_units, 'read_remaining': max(0, 6 - self._read_units), 'write_limit': 17, 'writes_used': self._write_attempts, 'writes_remaining': max(0, 17 - self._write_attempts), 'call_limit': 48, 'calls_used': self._calls}

    @property
    def calls(self):
        return self._calls

    @property
    def read_units(self):
        return self._read_units

    @property
    def writes(self):
        return self._write_attempts

    def _current_assignee(self, structure_id):
        group = DATA_GROUP_BY_ATOM[structure_id]
        if group['mode'] == 'manager':
            return group['editor_old']
        return self._assignee_by_structure[structure_id]

    def _inject_target(self, target):
        assignee = self._current_assignee(target['structure_atom'])
        for (entity_type, rows) in fn__packet_entities(target, assignee).items():
            for row in rows:
                self._state.add_entity(entity_type, row, DATA_ENTITY_ID_FIELDS[entity_type])
        project = self._state.get_entity('project', target['project_id'], 'project_id')
        project_records = self._state.query_entities('record', lambda row: row.get('project_id') == target['project_id'])
        project_queries = self._state.query_entities('data_query', lambda row: row.get('project_id') == target['project_id'])
        self._state.update_entity('project', target['project_id'], {'record_count': len(project_records), 'open_query_count': sum((row.get('status') == 'open' for row in project_queries)), 'last_activity_at': '2026-05-18T10:30:00Z', 'updated_at': '2026-05-18T10:30:00Z'}, 'project_id')
        if project is None:
            raise AssertionError('target project disappeared during injection')
        return {**ext_deepcopy(target), **fn__actor_bindings(target, assignee), 'current_assignee': assignee}

    def current_episode_events(self):
        return ext_deepcopy(self._events)

    def business_hash(self):
        return fn__digest({'entities': self._state.snapshot(), 'assignee_by_structure': self._assignee_by_structure})

    def _business_hash(self):
        return self.business_hash()

    def lineage_hash(self):
        return fn__digest(self.snapshot())

    def grade(self, task_id=None):
        selected = task_id or self._task_id
        if selected != self._task_id or selected not in DATA_TASK_IDS:
            raise ValueError('only the active stream task can be graded')
        deliverables = []
        for target in self._targets:
            value = self._state.get_entity('field_value', target['primary_value_id'], 'value_id')
            query = self._state.get_entity('data_query', target['query_id'], 'query_id')
            record = self._state.get_entity('record', target['record_id'], 'record_id')
            record_event = self._state.get_entity('record_event', target['record_event_id'], 'record_event_id')
            forms = [self._state.get_entity('form_instance', form_id, 'form_instance_id') for form_id in (target['primary_form_id'], target['companion_form_id'])]
            field_correct = bool(value and value.get('value') == target['corrected_value'] and (value.get('status') == 'verified'))
            query_resolved = bool(query and query.get('status') == 'resolved' and record and (int(record.get('open_query_count') or 0) == 0))
            forms_complete = bool(all((form and form.get('completion_status') in {'complete', 'locked'} and (int(form.get('missing_required_count') or 0) == 0) for form in forms)))
            event_locked = bool(record_event and record_event.get('locked') is True and all((form and form.get('completion_status') == 'locked' for form in forms)))
            complete = field_correct and query_resolved and forms_complete and event_locked
            deliverables.append({'target_id': target['target_id'], 'score': 25.0 if complete else 0.0, 'complete': complete, 'field_correct': field_correct, 'query_resolved': query_resolved, 'forms_complete': forms_complete, 'event_locked': event_locked})
        return {'task_id': selected, 'score': sum((row['score'] for row in deliverables)), 'max_score': 100.0, 'completed_artifacts': sum((row['complete'] for row in deliverables)), 'deliverables': deliverables, 'budget': self._budget_receipt()}

    def public_tool_schemas(self, role):
        return ext_deepcopy(DATA_TOOLS_2) if role == 'redcap_closeout_coordinator' else []

    def task_targets(self):
        return ext_deepcopy(self._targets)

    def semantic_hash(self, snapshot=None):
        return fn__hash(snapshot if snapshot is not None else self.snapshot())

    def business_events(self, since=0):
        if not isinstance(since, int) or isinstance(since, bool) or since < 0:
            raise ValueError('since must be a non-negative integer')
        return ext_deepcopy(self._events[since:])

    def _record_adapter_event(self, name, actor, result, before_hash, after_hash, *, channel='learner', cost=0):
        self._events.append({'sequence': len(self._events) + 1, 'channel': channel, 'tool': name, 'actor_user_id': actor, 'status': result.get('status'), 'error_code': result.get('data', {}).get('error_code'), 'cost': cost, 'state_hash_before': before_hash, 'state_hash_after': after_hash})

    def _repair_required_counts(self, record_id, event_id, instrument_id):
        required_fields = [row for row in self._state.list_entities('instrument_field') if row.get('instrument_id') == instrument_id and row.get('required') is True and (row.get('status') == 'active')]
        values = self._state.list_entities('field_value')
        missing = 0
        for field in required_fields:
            match = next((row for row in values if row.get('record_id') == record_id and row.get('event_id') == event_id and (row.get('instrument_id') == instrument_id) and (row.get('field_id') == field['field_id'])), None)
            if match is None or not str(match.get('value') or '').strip():
                missing += 1
        for form in self._state.list_entities('form_instance'):
            if form.get('record_id') == record_id and form.get('event_id') == event_id and (form.get('instrument_id') == instrument_id):
                self._state.update_entity('form_instance', form['form_instance_id'], {'missing_required_count': missing}, 'form_instance_id')

    def _assert_invariants(self):
        entities = self._state.snapshot()
        indexes: dict[str, dict[str, dict[str, ext_Any]]] = {}
        for (entity_type, identity_field) in DATA_ENTITY_ID_FIELDS.items():
            rows = entities.get(entity_type, [])
            identities = [row.get(identity_field) for row in rows]
            if None in identities or len(identities) != len(set(identities)):
                raise ValueError(f'{entity_type} identities are not unique')
            indexes[entity_type] = {row[identity_field]: row for row in rows}
        projects = indexes['project']
        users = indexes['project_user']
        events = indexes['event']
        instruments = indexes['instrument']
        fields = indexes['instrument_field']
        records = indexes['record']
        record_events = indexes['record_event']
        forms = indexes['form_instance']
        values = indexes['field_value']
        queries = indexes['data_query']
        for (entity_type, rows) in entities.items():
            if entity_type == 'project':
                continue
            for row in rows:
                project_id = row.get('project_id')
                if project_id and project_id not in projects:
                    raise ValueError(f'{entity_type} references a missing project')
        for instrument in instruments.values():
            for event_id in instrument.get('mapped_event_ids', []):
                event = events.get(event_id)
                if not event or event.get('project_id') != instrument.get('project_id'):
                    raise ValueError('instrument event mapping diverged')
        for field in fields.values():
            instrument = instruments.get(field.get('instrument_id'))
            if not instrument or instrument.get('project_id') != field.get('project_id'):
                raise ValueError('field instrument reference diverged')
        for record_event in record_events.values():
            record = records.get(record_event.get('record_id'))
            event = events.get(record_event.get('event_id'))
            if not record or not event or (not record.get('project_id') == event.get('project_id') == record_event.get('project_id')):
                raise ValueError('record-event reference diverged')
        for form in forms.values():
            record = records.get(form.get('record_id'))
            event = events.get(form.get('event_id'))
            instrument = instruments.get(form.get('instrument_id'))
            if not record or not event or (not instrument) or (not record.get('project_id') == event.get('project_id') == instrument.get('project_id') == form.get('project_id')):
                raise ValueError('form reference diverged')
            if event['event_id'] not in instrument.get('mapped_event_ids', []):
                raise ValueError('form instrument is not mapped to event')
            required = [field for field in fields.values() if field.get('instrument_id') == instrument['instrument_id'] and field.get('required') is True and (field.get('status') == 'active')]
            missing = 0
            for field in required:
                match = next((value for value in values.values() if value.get('record_id') == record['record_id'] and value.get('event_id') == event['event_id'] and (value.get('instrument_id') == instrument['instrument_id']) and (value.get('field_id') == field['field_id'])), None)
                if match is None or not str(match.get('value') or '').strip():
                    missing += 1
            if int(form.get('missing_required_count') or 0) != missing:
                raise ValueError('form missing-required counter diverged')
            if form.get('completion_status') in {'complete', 'locked'} and missing:
                raise ValueError('complete form has missing required values')
        for value in values.values():
            record = records.get(value.get('record_id'))
            event = events.get(value.get('event_id'))
            instrument = instruments.get(value.get('instrument_id'))
            field = fields.get(value.get('field_id'))
            if not record or not event or (not instrument) or (not field) or (not record.get('project_id') == event.get('project_id') == instrument.get('project_id') == field.get('project_id') == value.get('project_id')):
                raise ValueError('field value reference diverged')
            if field.get('instrument_id') != instrument.get('instrument_id'):
                raise ValueError('field value instrument diverged')
        for query in queries.values():
            record = records.get(query.get('record_id'))
            event = events.get(query.get('event_id'))
            instrument = instruments.get(query.get('instrument_id'))
            field = fields.get(query.get('field_id'))
            opened_by = users.get(query.get('opened_by'))
            assigned_to = users.get(query.get('assigned_to'))
            if not record or not event or (not instrument) or (not field) or (not opened_by) or (not assigned_to):
                raise ValueError('query reference is missing')
            if not record.get('project_id') == event.get('project_id') == instrument.get('project_id') == field.get('project_id') == opened_by.get('project_id') == assigned_to.get('project_id') == query.get('project_id'):
                raise ValueError('query project scope diverged')
            if field.get('instrument_id') != instrument.get('instrument_id'):
                raise ValueError('query field instrument diverged')
        for project in projects.values():
            project_id = project['project_id']
            project_records = [row for row in records.values() if row.get('project_id') == project_id]
            project_queries = [row for row in queries.values() if row.get('project_id') == project_id]
            project_instruments = [row for row in instruments.values() if row.get('project_id') == project_id]
            if int(project.get('record_count') or 0) != len(project_records):
                raise ValueError('project record counter diverged')
            if int(project.get('open_query_count') or 0) != sum((row.get('status') == 'open' for row in project_queries)):
                raise ValueError('project query counter diverged')
            if int(project.get('active_instrument_count') or 0) != sum((row.get('status') == 'active' for row in project_instruments)):
                raise ValueError('project instrument counter diverged')
        for record in records.values():
            record_id = record['record_id']
            if int(record.get('open_query_count') or 0) != sum((row.get('status') == 'open' for row in queries.values() if row.get('record_id') == record_id)):
                raise ValueError('record query counter diverged')
            if int(record.get('locked_event_count') or 0) != sum((row.get('locked') is True for row in record_events.values() if row.get('record_id') == record_id)):
                raise ValueError('record lock counter diverged')
        for record_event in record_events.values():
            related = [row for row in forms.values() if row.get('record_id') == record_event['record_id'] and row.get('event_id') == record_event['event_id']]
            complete = sum((row.get('completion_status') in {'complete', 'locked'} for row in related))
            if int(record_event.get('form_complete_count') or 0) != complete:
                raise ValueError('record-event complete counter diverged')
            if int(record_event.get('form_incomplete_count') or 0) != len(related) - complete:
                raise ValueError('record-event incomplete counter diverged')
            if record_event.get('locked') and any((row.get('completion_status') != 'locked' for row in related)):
                raise ValueError('locked record event has unlocked forms')

    def _prepare(self, name, arguments):
        prepared = ext_deepcopy(arguments)
        if name == 'get_record_profile':
            prepared.update({'include_field_values': True, 'include_queries': True, 'field_value_limit': 100})
        elif name == 'resolve_data_query':
            prepared['allow_open_resolution'] = False
        elif name == 'mark_form_complete':
            prepared['require_no_missing_fields'] = True
        return prepared

    def _precheck_lock(self, arguments):
        if not arguments.get('locked'):
            return None
        record_event = self._state.get_entity('record_event', arguments.get('record_event_id'), 'record_event_id')
        if not record_event:
            return None
        forms = [row for row in self._state.list_entities('form_instance') if row.get('record_id') == record_event.get('record_id') and row.get('event_id') == record_event.get('event_id')]
        if any((row.get('completion_status') not in {'complete', 'locked'} for row in forms)):
            return fn__error('INCOMPLETE_FORMS_CONFLICT', 'all related forms must be complete before locking')
        return None

    def private_raw_call(self, name, arguments):
        """Run an excluded raw tool transactionally for private rule witnesses."""
        before = self.snapshot()
        before_hash = self._business_hash()
        try:
            result = fn__normalize(self._logic.run_tool(name, self._state, ext_deepcopy(arguments)))
            if result.get('status') != 'success':
                self.restore(before)
            else:
                self._assert_invariants()
        except Exception:
            self.restore(before)
            result = fn__error('ADAPTER_EXECUTION_FAILED', 'private witness failed without committing state')
        self._record_adapter_event(name, str(arguments.get('actor_user_id') or arguments.get('requested_by') or arguments.get('approved_by') or 'private'), result, before_hash, self._business_hash(), channel='private_probe')
        return ext_deepcopy(result)

    def cost(self, before, action, result, after):
        del action, result
        return {'read_units': int(after.get('read_units') or 0) - int(before.get('read_units') or 0), 'write_attempts': int(after.get('write_attempts') or 0) - int(before.get('write_attempts') or 0)}

    def _redcap_reusable_authority_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-redcap-structure-world/v7':
            raise ValueError('unsupported REDCap reusable authority v7 snapshot')
        value = ext_deepcopy(snapshot)
        extra = value.pop('successor_v7', {})
        if extra.get('provider_tools_sha256') != 'ce93692a925a9261962b6dc349b1446d425e93a516663ce04fb9b1330674c2bb':
            raise ValueError('provider tool surface differs from REDCap v7')
        if extra.get('cached_closeout_profile_cost') != 0:
            raise ValueError('cached verification cost differs from REDCap v7')
        if extra.get('registered_structure_delta_sha256') != 'c906f6670e3358b8460d789cc5d65113fcdba816ef2ee8d83c2ef6f871ec3c00':
            raise ValueError('registered authority delta differs from REDCap v7')
        value['schema'] = 'rescopebench-redcap-structure-world/v6'
        self._redcap_actionable_authority_restore(value)

    def _redcap_authority_evolution_snapshot(self):
        value = self._redcap_evolution_snapshot()
        value['authority_contract'] = 'redcap-authority-lifecycle-evolution-v2'
        return value

    def _redcap_authority_evolution_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('authority_contract', None) != 'redcap-authority-lifecycle-evolution-v2':
            raise ValueError('REDCap authority contract differs')
        self._redcap_evolution_restore(value)
        if self.authority_revalidation:
            raise ValueError('Unexpected legacy observation-order ledger in v2 snapshot')

    def _redcap_reusable_authority_apply_structure_event(self):
        result = self._redcap_authority_successor_apply_structure_event()
        result = ext_deepcopy(result)
        result['event_id'] = 'evt-redcap-authority-rotation-v7'
        result['registered_delta_sha256'] = 'c906f6670e3358b8460d789cc5d65113fcdba816ef2ee8d83c2ef6f871ec3c00'
        if result.get('applied'):
            self._applied_boundary_events.add('evt-redcap-authority-rotation-v7')
            self._applied_drifts = ['evt-redcap-authority-rotation-v7']
        return result

    def _redcap_evolution_dispatch(self, name, arguments, actor_user_id='session-redcap-closeout-4x9'):
        exact = name == 'get_record_profile' and isinstance(arguments, dict) and (set(arguments) == {'project_id', 'record_id'}) and all((isinstance(v, str) for v in arguments.values())) and (actor_user_id == 'session-redcap-closeout-4x9')
        key = mod_json.dumps(arguments, sort_keys=True) if exact else None
        issued = self._own_closeouts.get(key)
        if issued is not None:
            before = self.business_hash()
            result = {'status': 'success', 'data': {'confirmation_only': True, 'authoritative_closeout': ext_deepcopy(issued)}, 'budget': self._budget_receipt()}
            self._record_adapter_event(name, actor_user_id, result, before, before, cost=0)
            result['receipt_index'] = len(self._events)
            return result
        result = self._redcap_reusable_authority_dispatch(name, arguments, actor_user_id)
        if result.get('status') == 'success':
            target = self._target_for_arguments(name, arguments)
            if target is not None:
                key = mod_json.dumps({k: target[k] for k in ('project_id', 'record_id')}, sort_keys=True)
                self._own_closeouts.pop(key, None)
                receipt = result.get('data', {}).get('authoritative_closeout')
                if receipt is not None and actor_user_id == 'session-redcap-closeout-4x9':
                    self._own_closeouts[key] = ext_deepcopy(receipt)
        return result

    def _redcap_authority_successor_init(self, source_root=CASE_DIR / 'raw'):
        self._redcap_structure_successor_init(source_root=source_root)
        for (atom_id, new_user_id) in DATA_SYNTHETIC_ASSIGNEES.items():
            if self._state.get_entity('project_user', new_user_id, 'user_id') is not None:
                continue
            old = self._state.get_entity('project_user', DATA_PRE_STRUCTURE_AUTHORITY[atom_id], 'user_id')
            if old is None:
                raise AssertionError(f'missing predecessor assignee for {atom_id}')
            replacement = ext_deepcopy(old)
            replacement.update({'user_id': new_user_id, 'username': new_user_id.replace('usr-', 'staff.'), 'full_name': f'Project staff {new_user_id[-4:].upper()}', 'email': f'{new_user_id}@example.invalid', 'status': 'active'})
            self._state.add_entity('project_user', replacement, 'user_id')
        self.authority_revalidation: dict[str, str] = {}
        self._entry_entities = self._state.snapshot()
        self._assert_invariants()

    def _redcap_actionable_authority_read_cost(self, name, result):
        if name == 'get_record_profile' and result.get('status') == 'success' and (self._active_target_from_profile(result) is not None):
            return 2
        return self._redcap_authority_successor_read_cost(name, result)

    def _redcap_actionable_authority_compact_profile(self, target, result):
        data = result['data']
        query = next((row for row in data['queries'] if row['query_id'] == target['query_id']))
        field = next((row for row in data['field_values'] if row['field_id'] == target['primary_field_id'] and row['instrument_id'] == target['primary_instrument_id']))
        record_event = next((row for row in data['record_events'] if row['record_event_id'] == target['record_event_id']))
        form_ids = {target['primary_form_id'], target['companion_form_id']}
        forms = [row for row in data['forms'] if row['form_instance_id'] in form_ids]
        compact = {'request_ref': target['target_id'], 'workflow_class': target['workflow_class'], 'project_id': target['project_id'], 'record': ext_deepcopy(data['record']), 'record_event': ext_deepcopy(record_event), 'forms': ext_deepcopy(forms), 'target_field': ext_deepcopy(field), 'query': ext_deepcopy(query), 'workflow_authority': self._workflow_authority(target, query)}
        value = ext_deepcopy(result)
        value['data'] = compact
        return value

    def _redcap_actionable_authority_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-redcap-structure-world/v6':
            raise ValueError('unsupported REDCap actionable authority v6 snapshot')
        value = ext_deepcopy(snapshot)
        extra = value.pop('successor_v6', {})
        if extra.get('provider_tools_sha256') != 'cea2749468a89c15de9ca78832ea2f7dd0540faa66b5df73eccbe544d7edf29b':
            raise ValueError('provider tool surface differs from REDCap v6')
        if extra.get('compact_profile_cost') != 2:
            raise ValueError('compact profile cost differs from REDCap v6')
        value['schema'] = 'rescopebench-redcap-structure-world/v5'
        self._redcap_authority_successor_restore(value)

    def _redcap_evolution_snapshot(self):
        value = self._redcap_reusable_authority_snapshot()
        value['evolution_contract'] = {'case_version': 'redcap-authority-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2)}
        value['own_closeout_receipts'] = ext_deepcopy(self._own_closeouts)
        return value

    def _redcap_evolution_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('evolution_contract', None) != {'case_version': 'redcap-authority-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2}:
            raise ValueError('REDCap evolution contract differs')
        receipts = value.pop('own_closeout_receipts')
        self._redcap_reusable_authority_restore(value)
        self._own_closeouts = ext_deepcopy(receipts)

    def _redcap_authority_successor_apply_structure_event(self):
        before = self.business_hash()
        if 'evt-redcap-authority-rotation-v5' in self._applied_boundary_events:
            return {'event_id': 'evt-redcap-authority-rotation-v5', 'application_count': self._drift_application_count, 'applied': False, 'idempotent_noop': True, 'before_world_sha256': before, 'after_world_sha256': before, 'registered_delta_sha256': '33dc4558c52ad984b3a2f0cc5cb6ffb6252a95e6262bf035a93a901a30f4176f'}
        for atom_id in DATA_CHANGED_STRUCTURE_ATOMS:
            old = DATA_PRE_STRUCTURE_AUTHORITY[atom_id]
            new = DATA_POST_STRUCTURE_AUTHORITY[atom_id]
            self._assignee_by_structure[atom_id] = new
            self._state.update_entity('project_user', old, {'status': 'inactive', 'updated_at': '2026-05-18T10:30:00Z'}, 'user_id')
            self._state.update_entity('project_user', new, {'status': 'active', 'updated_at': '2026-05-18T10:30:00Z'}, 'user_id')
            self.authority_revalidation[atom_id] = 'awaiting_exact_stale'
        for target in self._targets:
            atom_id = target['structure_atom']
            if atom_id not in DATA_CHANGED_STRUCTURE_ATOMS:
                continue
            new = DATA_POST_STRUCTURE_AUTHORITY[atom_id]
            self._state.update_entity('data_query', target['query_id'], {'assigned_to': new, 'updated_at': '2026-05-18T10:30:00Z'}, 'query_id')
            target.update({'current_assignee': new, 'field_actor_user_id': new, 'query_answer_actor_user_id': new, 'lock_actor_user_id': new})
        self._applied_boundary_events.add('evt-redcap-authority-rotation-v5')
        self._applied_drifts = ['evt-redcap-authority-rotation-v5']
        self._drift_application_count = 1
        self._assert_invariants()
        after = self.business_hash()
        return {'event_id': 'evt-redcap-authority-rotation-v5', 'application_count': self._drift_application_count, 'applied': True, 'idempotent_noop': False, 'before_world_sha256': before, 'after_world_sha256': after, 'registered_delta_sha256': '33dc4558c52ad984b3a2f0cc5cb6ffb6252a95e6262bf035a93a901a30f4176f'}

    def _redcap_reusable_authority_dispatch(self, name, arguments, actor_user_id='session-redcap-closeout-4x9'):
        result = self._redcap_actionable_authority_dispatch(name, arguments, actor_user_id)
        if name == 'set_record_event_lock' and result.get('status') == 'success' and (arguments.get('locked') is True):
            target = self._target_for_arguments(name, arguments)
            if target is not None and self._target_complete(target):
                value = ext_deepcopy(result)
                value.setdefault('data', {})['authoritative_closeout'] = {'request_ref': target['target_id'], 'complete': True, 'field_verified': True, 'query_resolved': True, 'forms_complete': True, 'record_event_locked': True, 'additional_readback_required': False, 'reusable_evidence': {'persistent_until_contradicted': {'project_binding_key': target['project_title'], 'project_title': target['project_title'], 'project_id': target['project_id'], 'instrument_id': target['primary_instrument_id'], 'field_id': target['primary_field_id'], 'field_actor_user_id': target['field_actor_user_id'], 'form_actor_user_id': target['field_actor_user_id'], 'query_answer_actor_user_id': target['query_answer_actor_user_id'], 'query_resolver_user_id': target['query_resolver_user_id'], 'lock_actor_user_id': target['lock_actor_user_id']}, 'reusable_workflow_procedure': fn__workflow_recipe_from_profile(target), 'task_scoped': {'request_ref': target['target_id'], 'subject_label': target['subject_label'], 'record_id': target['record_id'], 'query_id': target['query_id'], 'form_instance_ids': sorted([target['primary_form_id'], target['companion_form_id']]), 'record_event_id': target['record_event_id']}}}
                return value
        return result

    def _redcap_structure_successor_init(self, source_root=CASE_DIR / 'raw'):
        self._redcap_structure_successor_init_2(source_root=source_root)
        old = self._state.get_entity('project_user', DATA_PRE_STRUCTURE_AUTHORITY_2['S02'], 'user_id')
        if old is None:
            raise AssertionError('S02 predecessor assignee is missing')
        if self._state.get_entity('project_user', 'usr-b018b8d3dcf7d6', 'user_id') is None:
            replacement = ext_deepcopy(old)
            replacement.update({'user_id': 'usr-b018b8d3dcf7d6', 'username': 'usr-b018b8d3dcf7d6'.replace('usr-', 'staff.'), 'full_name': f"Project staff {'usr-b018b8d3dcf7d6'[-4:].upper()}", 'email': f"{'usr-b018b8d3dcf7d6'}@example.invalid"})
            self._state.add_entity('project_user', replacement, 'user_id')
        self._entry_entities = self._state.snapshot()
        self._assert_invariants()

    def _redcap_authority_successor_read_cost(self, name, result):
        cost = self._redcap_query_lock_adapter_read_cost(name, result)
        if name == 'list_data_queries' and result.get('status') == 'success':
            return max(2, cost)
        return cost

    def _redcap_authority_successor_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-redcap-structure-world/v5':
            raise ValueError('unsupported REDCap authority v5 snapshot')
        value = ext_deepcopy(snapshot)
        extra = value.pop('successor_v5', {})
        if extra.get('provider_tools_sha256') != 'ccda3f97d34b50376e9bbed96390d1a430d9980a47bb8bccfe4cc9ca84c6fb5b':
            raise ValueError('provider tool surface differs from REDCap v5')
        if extra.get('synthetic_assignees') != DATA_SYNTHETIC_ASSIGNEES:
            raise ValueError('synthetic authority identities differ from REDCap v5')
        value['schema'] = 'rescopebench-redcap-structure-world/v4'
        self._redcap_structure_successor_restore(value)
        self.authority_revalidation = ext_deepcopy(extra.get('authority_revalidation', {}))

    def _redcap_reusable_authority_snapshot(self):
        value = self._redcap_actionable_authority_snapshot()
        value['schema'] = 'rescopebench-redcap-structure-world/v7'
        value['successor_v7'] = {'provider_tools_sha256': 'ce93692a925a9261962b6dc349b1446d425e93a516663ce04fb9b1330674c2bb', 'cached_closeout_profile_cost': 0, 'registered_structure_delta_sha256': 'c906f6670e3358b8460d789cc5d65113fcdba816ef2ee8d83c2ef6f871ec3c00'}
        return value

    def _redcap_actionable_authority_dispatch(self, name, arguments, actor_user_id='session-redcap-closeout-4x9'):
        result = self._redcap_authority_successor_dispatch(name, arguments, actor_user_id)
        if result.get('status') != 'success':
            return result
        if name == 'get_record_profile':
            target = self._active_target_from_profile(result)
            if target is not None:
                return self._compact_profile(target, result)
        elif name == 'list_data_queries':
            target = self._target_for_read(arguments)
            if target is not None:
                value = ext_deepcopy(result)
                for query in value.get('data', {}).get('queries', []):
                    if query.get('query_id') != target['query_id']:
                        continue
                    query['project_id'] = target['project_id']
                    query['workflow_class'] = target['workflow_class']
                    query['workflow_authority'] = self._workflow_authority(target, query)
                return value
        return result

    def _redcap_structure_successor_init_2(self, source_root=CASE_DIR / 'raw'):
        self._persistent_redcap_adapter_init(source_root=source_root)
        self._drift_application_count = 0

    def _redcap_query_lock_adapter_read_cost(self, name, result):
        if result.get('status') != 'success':
            return 1
        data = result.get('data') or {}
        if name in DATA_LIST_TOOLS:
            return max(1, int(data.get('total_count') or 0))
        if name == 'get_record_profile':
            return 1 + len(data.get('record_events') or []) + len(data.get('forms') or []) + len(data.get('field_values') or []) + len(data.get('queries') or [])
        if name == 'inspect_instrument_dictionary':
            return max(1, 1 + len(data.get('mapped_events') or []) + len(data.get('fields') or []))
        return 1

    def _redcap_structure_successor_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-redcap-structure-world/v4':
            raise ValueError('unsupported REDCap frontier snapshot')
        World._persistent_redcap_adapter_restore(self, snapshot['base'])
        successor = snapshot['successor']
        if successor.get('provider_tools_sha256') != '5b8d114f107021ca6fe690b78ab91fb09fbe5b9f873e50f8fce0603ac143fe8f':
            raise ValueError('provider tool surface differs from the frozen successor')
        if successor.get('s02_new_assignee') != 'usr-b018b8d3dcf7d6':
            raise ValueError('S02 alternate assignee differs from the frozen successor')
        self._drift_application_count = int(successor.get('drift_application_count') or 0)

    def _redcap_actionable_authority_snapshot(self):
        value = self._redcap_authority_successor_snapshot()
        value['schema'] = 'rescopebench-redcap-structure-world/v6'
        value['successor_v6'] = {'provider_tools_sha256': 'cea2749468a89c15de9ca78832ea2f7dd0540faa66b5df73eccbe544d7edf29b', 'compact_profile_cost': 2}
        return value

    def _redcap_authority_successor_dispatch(self, name, arguments, actor_user_id='session-redcap-closeout-4x9'):
        target = self._target_for_arguments(name, arguments)
        if target is not None:
            first = self._first_incomplete_slot()
            if first is not None and int(target['slot']) > first:
                return self._charged_guard_error(name, 'PRIORITY_PACKET_PENDING', 'an earlier listed REDCap packet must be completed first')
            atom_id = target['structure_atom']
            if atom_id in DATA_CHANGED_STRUCTURE_ATOMS and arguments.get('actor_user_id') == DATA_POST_STRUCTURE_AUTHORITY[atom_id] and (self.authority_revalidation.get(atom_id) in {'awaiting_current_query', 'awaiting_active_staff'}):
                return self._charged_guard_error(name, 'AUTHORITY_REVALIDATION_REQUIRED', 'current query and active staff evidence are both required after a stale authority rejection')
        result = self._redcap_structure_successor_dispatch(name, arguments, actor_user_id)
        if name == 'list_data_queries' and result.get('status') == 'success':
            read_target = self._target_for_read(arguments)
            if read_target is not None:
                atom_id = read_target['structure_atom']
                state = self.authority_revalidation.get(atom_id)
                queries = result.get('data', {}).get('queries', [])
                if state == 'awaiting_current_query':
                    self.authority_revalidation[atom_id] = 'awaiting_active_staff'
        if name == 'list_project_users' and result.get('status') == 'success':
            project_id = arguments.get('project_id')
            atom_id = next((atom for atom in DATA_CHANGED_STRUCTURE_ATOMS if DATA_GROUP_BY_ATOM[atom]['project_id'] == project_id), None)
            if atom_id is not None:
                state = self.authority_revalidation.get(atom_id)
                data = result.get('data', {})
                if state == 'awaiting_current_query' and self._legacy_staff_projection:
                    old = self._state.get_entity('project_user', DATA_PRE_STRUCTURE_AUTHORITY[atom_id], 'user_id')
                    if old is not None:
                        visible = ext_deepcopy(old)
                        visible['status'] = 'active'
                        data['users'] = [visible]
                        data['user_ids'] = [visible['user_id']]
                        data['total_count'] = 1
                elif state == 'awaiting_active_staff':
                    users = data.get('users', [])
                    if any((row.get('user_id') == DATA_POST_STRUCTURE_AUTHORITY[atom_id] and row.get('status') == 'active' for row in users)):
                        self.authority_revalidation[atom_id] = 'ready_current'
        if target is not None and target['structure_atom'] in DATA_CHANGED_STRUCTURE_ATOMS:
            atom_id = target['structure_atom']
            actor = arguments.get('actor_user_id')
            code = result.get('data', {}).get('error_code')
            if self.authority_revalidation.get(atom_id) == 'awaiting_exact_stale' and actor == DATA_PRE_STRUCTURE_AUTHORITY[atom_id] and (code in {'USER_INACTIVE', 'PERMISSION_DENIED'}):
                self.authority_revalidation[atom_id] = 'awaiting_current_query'
            elif result.get('status') == 'success' and actor == DATA_POST_STRUCTURE_AUTHORITY[atom_id]:
                self.authority_revalidation[atom_id] = 'validated_current'
        return result

    def _persistent_redcap_adapter_init(self, source_root=None):
        self._redcap_query_lock_adapter_init(source_root or CASE_DIR / 'raw')
        self._state.restore(fn__base_entities())
        self._task_id = None
        self._targets = []
        self._entry_entities = self._state.snapshot()
        self._events = []
        self._calls = 0
        self._read_units = 0
        self._write_attempts = 0
        self._applied_drifts = []
        self._activated_tasks: list[str] = []
        self._applied_boundary_events: set[str] = set()
        self._assignee_by_structure = {group['atom_id']: group['editor_old'] for group in DATA_STRUCTURE_GROUPS if group['mode'] != 'manager'}
        self._assert_invariants()

    def _persistent_redcap_adapter_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-redcap-persistent-stream-snapshot/v1':
            raise ValueError('unsupported persistent REDCap stream snapshot schema')
        self._task_id = snapshot.get('task_id')
        self._targets = ext_deepcopy(snapshot.get('targets') or [])
        self._entry_entities = ext_deepcopy(snapshot.get('entry_entities') or {})
        self._state.restore(snapshot.get('entities') or {})
        self._events = ext_deepcopy(snapshot.get('events') or [])
        self._calls = int(snapshot.get('calls') or 0)
        self._read_units = int(snapshot.get('read_units') or 0)
        self._write_attempts = int(snapshot.get('write_attempts') or 0)
        self._applied_drifts = list(snapshot.get('applied_drifts') or [])
        self._activated_tasks = list(snapshot.get('activated_tasks') or [])
        self._applied_boundary_events = set(snapshot.get('applied_boundary_events') or [])
        self._assignee_by_structure = ext_deepcopy(snapshot.get('assignee_by_structure') or {})
        self._assert_invariants()

    def _redcap_authority_successor_snapshot(self):
        value = self._redcap_structure_successor_snapshot()
        value['schema'] = 'rescopebench-redcap-structure-world/v5'
        value['successor_v5'] = {'authority_revalidation': ext_deepcopy(self.authority_revalidation), 'provider_tools_sha256': 'ccda3f97d34b50376e9bbed96390d1a430d9980a47bb8bccfe4cc9ca84c6fb5b', 'synthetic_assignees': ext_deepcopy(DATA_SYNTHETIC_ASSIGNEES)}
        return value

    def _redcap_structure_successor_dispatch(self, name, arguments, actor_user_id='session-redcap-closeout-4x9'):
        if self._task_id is None:
            return fn__error('TASK_NOT_ACTIVE', 'activate a task before dispatch')
        tool = DATA_TOOL_BY_NAME.get(name)
        if tool is None:
            return fn__error('TOOL_NOT_ALLOWED', 'tool is not in the learner allowlist')
        if actor_user_id != 'session-redcap-closeout-4x9':
            return fn__error('ACTOR_NOT_AUTHORIZED', 'caller is not the closeout coordinator')
        try:
            mod_jsonschema.validate(arguments, tool['input_schema'])
        except mod_jsonschema.ValidationError:
            return fn__error('INVALID_ARGUMENTS', 'arguments do not match the public tool schema')
        if self._calls >= 48:
            result = fn__error('CALL_BUDGET_EXHAUSTED', 'task call safeguard is exhausted')
            result['budget'] = self._budget_receipt()
            return result
        is_write = name in DATA_WRITE_TOOLS
        if is_write and self._write_attempts >= 17:
            result = fn__error('WRITE_BUDGET_EXHAUSTED', 'task mutation-attempt allowance is exhausted')
            result['budget'] = self._budget_receipt()
            return result
        if not is_write and self._read_units >= 6:
            result = fn__error('READ_BUDGET_EXHAUSTED', 'task returned-work allowance is exhausted')
            result['budget'] = self._budget_receipt()
            return result
        before = self.snapshot()
        before_calls = self._calls
        before_reads = self._read_units
        before_writes = self._write_attempts
        before_hash = self.business_hash()
        try:
            precheck = self._precheck_lock(arguments) if name == 'set_record_event_lock' else None
            result = precheck if precheck is not None else fn__normalize(self._logic.run_tool(name, self._state, self._prepare(name, arguments)))
            if result.get('status') == 'success':
                if name == 'update_record_field':
                    self._repair_required_counts(arguments['record_id'], arguments['event_id'], arguments['instrument_id'])
                self._assert_invariants()
        except Exception:
            result = fn__error('ADAPTER_EXECUTION_FAILED', 'operation failed without committing state')
        cost = 1 if is_write else self._read_cost(name, result)
        if not is_write and before_reads + cost > 6:
            self.restore(before)
            self._calls = before_calls + 1
            self._read_units = 6
            exhausted = fn__error('READ_BUDGET_EXHAUSTED', 'the remaining returned-work allowance cannot cover this response')
            after_hash = self.business_hash()
            self._record_adapter_event(name, actor_user_id, exhausted, before_hash, after_hash, cost=6 - before_reads)
            exhausted['budget'] = self._budget_receipt()
            exhausted['receipt_index'] = len(self._events)
            return exhausted
        if result.get('status') != 'success':
            self.restore(before)
        self._calls = before_calls + 1
        self._read_units = before_reads + (0 if is_write else cost)
        self._write_attempts = before_writes + (1 if is_write else 0)
        after_hash = self.business_hash()
        self._record_adapter_event(name, actor_user_id, result, before_hash, after_hash, cost=cost)
        result['budget'] = self._budget_receipt()
        result['receipt_index'] = len(self._events)
        return ext_deepcopy(result)

    def _redcap_query_lock_adapter_init(self, source_root=CASE_DIR / 'raw'):
        self._logic = fn__load_raw_logic(str(ext_Path(source_root).resolve()))
        self._state = MemoryState({name: [] for name in DATA_ENTITY_ID_FIELDS})
        self._task_id: str | None = None
        self._targets: list[dict[str, ext_Any]] = []
        self._entry_entities: dict[str, list[dict[str, ext_Any]]] = {}
        self._events: list[dict[str, ext_Any]] = []
        self._calls = 0
        self._read_units = 0
        self._write_attempts = 0
        self._applied_drifts: list[str] = []

    def _redcap_structure_successor_snapshot(self):
        return {'schema': 'rescopebench-redcap-structure-world/v4', 'base': World._persistent_redcap_adapter_snapshot(self), 'successor': {'drift_application_count': self._drift_application_count, 'provider_tools_sha256': '5b8d114f107021ca6fe690b78ab91fb09fbe5b9f873e50f8fce0603ac143fe8f', 's02_new_assignee': 'usr-b018b8d3dcf7d6'}}

    def _persistent_redcap_adapter_snapshot(self):
        return {'schema': 'rescopebench-redcap-persistent-stream-snapshot/v1', 'task_id': self._task_id, 'targets': ext_deepcopy(self._targets), 'entry_entities': ext_deepcopy(self._entry_entities), 'entities': self._state.snapshot(), 'events': ext_deepcopy(self._events), 'calls': self._calls, 'read_units': self._read_units, 'write_attempts': self._write_attempts, 'applied_drifts': list(self._applied_drifts), 'activated_tasks': list(self._activated_tasks), 'applied_boundary_events': sorted(self._applied_boundary_events), 'assignee_by_structure': ext_deepcopy(self._assignee_by_structure)}

class MemoryState:

    def __init__(self, entities):
        self._entities = ext_deepcopy(entities)

    def get_entity(self, entity_type, entity_id, id_field='id'):
        field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field
        return next((ext_deepcopy(row) for row in self._entities.get(entity_type, []) if row.get(field) == entity_id), None)

    def list_entities(self, entity_type):
        return ext_deepcopy(self._entities.get(entity_type, []))

    def query_entities(self, entity_type, predicate):
        return [ext_deepcopy(row) for row in self._entities.get(entity_type, []) if predicate(row)]

    def add_entity(self, entity_type, record, id_field='id'):
        field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field
        identity = record.get(field)
        if identity is None or self.get_entity(entity_type, identity, field) is not None:
            raise ValueError(f'duplicate or missing identity for {entity_type}')
        self._entities.setdefault(entity_type, []).append(ext_deepcopy(record))
        return ext_deepcopy(record)

    def update_entity(self, entity_type, entity_id, patch, id_field='id'):
        field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field
        for row in self._entities.get(entity_type, []):
            if row.get(field) == entity_id:
                row.update(ext_deepcopy(patch))
                return ext_deepcopy(row)
        return None

    def delete_entity(self, entity_type, entity_id, id_field='id'):
        field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field
        rows = self._entities.get(entity_type, [])
        kept = [row for row in rows if row.get(field) != entity_id]
        self._entities[entity_type] = kept
        return len(rows) != len(kept)

    def snapshot(self):
        return ext_deepcopy(self._entities)

    def restore(self, entities):
        self._entities = ext_deepcopy(entities)