| """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) |
|
|
