"""Released environment operations and snapshot validation.""" from __future__ import annotations from copy import deepcopy as ext_deepcopy from datetime import datetime as ext_datetime from datetime import timedelta as ext_timedelta from datetime import timezone as ext_timezone from pathlib import Path as ext_Path from rescopebench.raw_module_isolation import isolated_package_namespace as ext_isolated_package_namespace from rescopebench.raw_module_isolation import load_isolated_modules as ext_load_isolated_modules from typing import Any as ext_Any import copy as mod_copy import hashlib as mod_hashlib import json as mod_json from .spec import CASE_DIR, DATA_TASK_IDS, DATA_SCHEDULE_2, DATA_POST_DRIFT_POLICY_OVERRIDES, DATA_CHANGED_RULE_IDS, DATA_PRE_RULES, DATA_PROFILE_REQUIREMENTS, DATA_CARE_TIERS, DATA_REQUEST_CLASSES, DATA_ALLOWED_TOOLS, DATA_READ_COSTS, DATA_WRITE_COSTS, DATA_POLICY_MATRIX, DATA_POLICY_PROFILE_IDS, DATA_REPLACEMENTS, DATA_STRUCTURE_BY_ID, DATA_TOOL_SCHEMAS, DATA_LIMIT_SCHEMA, DATA_TASK_BLUEPRINT, DATA_STREAM_TARGETS, DATA_CHANGED_RULE_IDS_2, DATA_T01_TARGETS def fn_delivered_grade(original): grade = ext_deepcopy(original) for artifact in grade['artifacts']: artifact['observation_diagnostics'] = artifact['milestones'] committed = bool(artifact['complete']) artifact['milestones'] = {'source_encounter_linked': committed, 'eligible_slot_booked': committed, 'follow_up_committed': committed} artifact['score'] = 25.0 if committed else 0.0 grade['score'] = sum((row['score'] for row in grade['artifacts'])) grade['score_basis'] = 'committed_policy_compliant_followups_only' return grade def fn_targets(task_id): rows = list(ext_deepcopy(fn_targets_2(task_id))) if task_id == 'T13': rows[0]['request_class'] = 'routine_review' rows[0]['rule_atom_id'] = fn_rule_atom_id(rows[0]['care_tier'], 'routine_review') if task_id == 'T15': rows[3]['request_class'] = 'care_plan_update' rows[3]['rule_atom_id'] = fn_rule_atom_id(rows[3]['care_tier'], 'care_plan_update') return tuple(rows) def fn_rule_atom_id(care_tier, request_class): return f'R{DATA_CARE_TIERS.index(care_tier) * len(DATA_REQUEST_CLASSES) + DATA_REQUEST_CLASSES.index(request_class) + 1:02d}' def fn_digest(value): return mod_hashlib.sha256(fn__canonical_2(value).encode('utf-8')).hexdigest() def fn_candidate_slots(target): date = ext_datetime.fromisoformat(target['date'] + 'T09:00:00+00:00') combinations = ((target['source_practitioner_id'], 'in_person'), (target['alternate_practitioner_id'], 'in_person'), (target['source_practitioner_id'], 'virtual'), (target['alternate_practitioner_id'], 'virtual')) rows = [] for (index, (practitioner_id, visit_mode)) in enumerate(combinations): start = date + ext_timedelta(hours=index) end = start + ext_timedelta(minutes=30) practitioner_slug = practitioner_id.removeprefix('practitioner-') patient_slug = target['patient_id'].removeprefix('patient-') rows.append({'slot_id': f"slot-followup-{patient_slug}-{start.strftime('%Y-%m-%dt%H-%M-%S').lower()}-{practitioner_slug}", 'site_id': target['site_id'], 'practitioner_id': practitioner_id, 'specialty': target['specialty'], 'visit_mode': visit_mode, 'start_at': start.astimezone(ext_timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'), 'end_at': end.astimezone(ext_timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'), 'slot_status': 'open', 'booking_hold_reason': None, 'created_at': '2026-05-25T12:00:00Z', 'updated_at': '2026-05-25T12:00:00Z'}) return rows def fn_policy_cell(care_tier, request_class): behavior = DATA_POLICY_MATRIX[care_tier][request_class] return {'policy_id': f'followup-v1-{care_tier}-{request_class}', 'care_tier': care_tier, 'request_class': request_class, 'routing_profile_id': DATA_POLICY_PROFILE_IDS[care_tier][request_class], 'routing_behavior': behavior, **DATA_PROFILE_REQUIREMENTS[behavior], 'policy_version': 'followup-routing-v1'} def fn__canonical(value): return mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True) def fn_targets_2(task_id): rows = [ext_deepcopy(row) for row in fn_stream_targets(task_id)] for (slot, (structure_id, request_class)) in DATA_REPLACEMENTS.get(task_id, {}).items(): row = rows[slot - 1] row.update(ext_deepcopy(DATA_STRUCTURE_BY_ID[structure_id])) row.update({'structure_atom_id': structure_id, 'request_class': request_class, 'rule_atom_id': fn_rule_atom_id(row['care_tier'], request_class), 'date': fn__stream_date(int(task_id[1:]), row['care_tier'])}) return tuple(rows) def fn__canonical_2(value): return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) def fn__validate_arguments(tool, arguments): if not isinstance(arguments, dict): return 'arguments must be an object' schema = DATA_TOOL_SCHEMAS[tool] properties = schema['properties'] unknown = sorted(set(arguments) - set(properties)) if unknown: return f"unsupported argument(s): {', '.join(unknown)}" missing = [name for name in schema.get('required', []) if name not in arguments] if missing: return f"missing required argument(s): {', '.join(missing)}" for (name, value) in arguments.items(): field = properties[name] if not fn__matches_type(value, field['type']): return f"{name} must be {field['type']}" if 'enum' in field and value not in field['enum']: return f"{name} must be one of: {', '.join(field['enum'])}" if 'minimum' in field and value < field['minimum']: return f"{name} must be at least {field['minimum']}" if 'maximum' in field and value > field['maximum']: return f"{name} must be at most {field['maximum']}" return None def fn__bounded_limit(arguments): if not isinstance(arguments, dict): return int(DATA_LIMIT_SCHEMA['default']) value = arguments.get('limit', DATA_LIMIT_SCHEMA['default']) if not isinstance(value, int) or isinstance(value, bool): return int(DATA_LIMIT_SCHEMA['default']) if not DATA_LIMIT_SCHEMA['minimum'] <= value <= DATA_LIMIT_SCHEMA['maximum']: return int(DATA_LIMIT_SCHEMA['default']) return value def fn_stream_targets(task_id): if task_id not in DATA_TASK_BLUEPRINT: raise ValueError(f'unknown stream task: {task_id}') if task_id == 'T01': return tuple(ext_deepcopy(fn_stream_targets_2(task_id))) position = int(task_id[1:]) targets = [] for (slot, (structure_id, request_class)) in enumerate(DATA_TASK_BLUEPRINT[task_id], 1): target = ext_deepcopy(DATA_STRUCTURE_BY_ID[structure_id]) target.update({'date': fn__stream_date(position, target['care_tier']), 'task_id': task_id, 'slot': slot, 'request_id': f'followup-request-{position:02d}-{slot:02d}', 'request_class': request_class, 'structure_atom_id': structure_id, 'rule_atom_id': fn_rule_atom_id(target['care_tier'], request_class), 'epoch': 'pre' if position <= 8 else 'post'}) targets.append(target) return tuple(targets) def fn__stream_date(position, care_tier): if position == 1: raise ValueError('T01 retains its frozen representative dates') start = ext_datetime(2026, 7, 1, tzinfo=ext_timezone.utc) value = start + ext_timedelta(days=(position - 2) * 7 + DATA_CARE_TIERS.index(care_tier)) return value.strftime('%Y-%m-%d') def fn__matches_type(value, expected): if expected == 'boolean': return isinstance(value, bool) if expected == 'integer': return isinstance(value, int) and (not isinstance(value, bool)) if expected == 'number': return isinstance(value, (int, float)) and (not isinstance(value, bool)) if expected == 'string': return isinstance(value, str) return True def fn_stream_targets_2(task_id): targets = list(ext_deepcopy(DATA_STREAM_TARGETS[task_id])) if task_id in {'T08', 'T09'}: targets.sort(key=lambda row: row['rule_atom_id'] in DATA_CHANGED_RULE_IDS_2) return tuple(targets) def fn__load_isolated_runtime(source): def initialize(modules): (healthcare_logic, server) = modules healthcare_logic.now_iso = lambda : '2026-05-25T12:00:00Z' server.load_tools() server.init_database(str(source / 'data')) return server.get_state_manager() (modules, manager) = ext_load_isolated_modules(source, ('mcp_servers.healthcare_logic', 'mcp_servers.server'), initialize=initialize) assert manager is not None return (modules[0], modules[1], manager) class World: def grade(self): return fn_delivered_grade(self._appointment_adapter_grade()) def snapshot(self): value = self._medical_portable_world_snapshot() if not getattr(self, '_restoring_delivery', False): value['delivery_scoring_contract'] = 'medical-delivered-followups-evolution-v5' return value def restore(self, snapshot): value = ext_deepcopy(snapshot) if value.pop('delivery_scoring_contract', None) != 'medical-delivered-followups-evolution-v5': raise ValueError('Medical delivered-followup snapshot version differs') self._restoring_delivery = True try: self._medical_portable_world_restore(value) finally: self._restoring_delivery = False if self.snapshot() != snapshot: raise ValueError('Medical delivered-followup snapshot did not round trip') def _priority_guard(self, arguments): return None def activate_task(self, task_id): if task_id not in DATA_TASK_IDS: raise ValueError('unknown Medical task') if self.active_task_id == task_id and self.activation_ledger: return {'status': 'success', 'task_id': task_id, 'idempotent': True, 'entry_lineage_hash': self.lineage_hash()} if task_id != f'T{len(self.activation_ledger) + 1:02d}': raise ValueError('out-of-order Medical task activation') (before_semantic, before_business) = (self.semantic_hash(), self.business_hash()) drift = None if int(task_id[1:]) == DATA_SCHEDULE_2['events'][0]['before_task']: drift = self.apply_policy_drift('followup-routing-v2-onset', DATA_POST_DRIFT_POLICY_OVERRIDES) for atom in DATA_CHANGED_RULE_IDS: self.rule_revalidation.setdefault(atom, 'awaiting_exact_stale') self.active_task_id = task_id self.active_targets = fn_targets(task_id) self._install_follow_up_fixture(self.active_targets) self.active_by_patient = {row['patient_id']: row for row in self.active_targets} self.remaining = self.initial_budget self.episode_receipt_start = len(self.receipts) event = {'sequence': len(self.activation_ledger) + 1, 'task_id': task_id, 'event_id': f'activate-{task_id.lower()}', 'drift_event_id': 'followup-routing-v2-onset' if drift else None, 'drift_applied': bool(drift and (not drift.get('idempotent'))), 'before_semantic_hash': before_semantic, 'before_business_hash': before_business, 'entry_semantic_hash': self.semantic_hash(), 'entry_business_hash': self.business_hash(), 'receipt_start': self.episode_receipt_start, 'request_ids': [row['request_id'] for row in self.active_targets]} self.activation_ledger.append(ext_deepcopy(event)) return {'status': 'success', 'idempotent': False, **ext_deepcopy(event), 'entry_lineage_hash': self.lineage_hash()} def _policy_evidence(self, care_tier, request_class): result = World._medical_rule_successor_policy_evidence(self, care_tier, request_class) atom = fn_rule_atom_id(care_tier, request_class) if self.rule_revalidation.get(atom) in {'awaiting_exact_stale', 'awaiting_fresh_policy'}: self.rule_revalidation[atom] = 'ready_current' return result def __init__(self, source=CASE_DIR / 'raw', budget=72): self.rule_revalidation: dict[str, str] = {} self._medical_rule_successor_init(source=source, budget=budget) def semantic_hash(self): return fn_digest({'base': self._appointment_adapter_semantic_hash(), 'rule_revalidation': self.rule_revalidation}) def _target_for_source(self, source_appointment_id): return next((target for target in self.active_targets if target['source_appointment_id'] == source_appointment_id), None) def _matches_rule_tuple(self, target, slot, arguments, rule): same_practitioner = slot.get('practitioner_id') == target['source_practitioner_id'] relation_matches = same_practitioner if rule['practitioner_relation'] == 'source_practitioner' else not same_practitioner return bool(arguments.get('routing_profile_id') == rule['routing_profile_id'] and slot.get('site_id') == target['site_id'] and (slot.get('specialty') == target['specialty']) and (slot.get('visit_mode') == rule['visit_mode']) and str(slot.get('start_at', '')).startswith(target['date']) and relation_matches) def _follow_up_guard(self, arguments): priority_error = self._priority_guard(arguments) if priority_error is not None: return priority_error target = self._target_for_source(arguments.get('source_appointment_id', '')) if target is not None: atom_id = target['rule_atom_id'] if self.rule_revalidation.get(atom_id) == 'awaiting_exact_stale': slot = self.manager.get_entity('schedule_slot', arguments.get('new_slot_id', ''), id_field='slot_id') if slot is not None and self._matches_rule_tuple(target, slot, arguments, DATA_PRE_RULES[atom_id]): self.rule_revalidation[atom_id] = 'awaiting_fresh_policy' return self._medical_rule_successor_follow_up_guard(arguments) def dispatch(self, tool, arguments, actor='follow_up_scheduler'): target = None if tool == 'create_follow_up_appointment' and isinstance(arguments, dict): target = self._target_for_source(arguments.get('source_appointment_id', '')) result = self._medical_rule_successor_dispatch(tool, arguments, actor) if target is not None and result.get('content', {}).get('status') == 'success' and (target['rule_atom_id'] in self.rule_revalidation): self.rule_revalidation[target['rule_atom_id']] = 'validated' if self.receipts and self.receipts[-1]['index'] == result.get('receipt_index'): self.receipts[-1]['after_hash'] = self.semantic_hash() return result def _cost(self, tool, arguments): if tool == 'get_patient_scheduling_context': return 16 return self._appointment_adapter_cost(tool, arguments) def _slot_observed_in_current_episode(self, slot_id): for receipt in self.current_episode_receipts(): if receipt.get('tool') != 'search_appointment_slots' or receipt.get('status') != 'success': continue if any((slot.get('slot_id') == slot_id for slot in receipt.get('observed', {}).get('slots', []))): return True return False def _patient_context(self, patient_id): result = self._medical_rule_successor_patient_context(patient_id) if result.get('content', {}).get('status') == 'success': result = ext_deepcopy(result) result['content']['data'].pop('routing_policy_epoch', None) return result @property def routing_epoch(self): return 'routing-epoch-8f34' if self.policy_overrides else 'routing-epoch-5c21' def apply_policy_drift(self, event_id, changed_cells): result = self._appointment_adapter_apply_policy_drift(event_id, changed_cells) result.pop('changed_cells', None) result['public_notice'] = '' return result def current_episode_receipts(self): return ext_deepcopy(self.receipts[self.episode_receipt_start:]) def close(self): self.server.cleanup_runtime() def _manager_snapshot(self): with ext_isolated_package_namespace(self.source): return self.manager.snapshot() def _install_follow_up_fixture(self, targets): for target in targets: patient = self.manager.get_entity('patient_profile', target['patient_id'], id_field='patient_id') source = self.manager.get_entity('appointment', target['source_appointment_id'], id_field='appointment_id') site = self.manager.get_entity('clinic_site', target['site_id'], id_field='site_id') source_slot = self.manager.get_entity('schedule_slot', source.get('slot_id', '') if source else '', id_field='slot_id') alternate = self.manager.get_entity('practitioner', target['alternate_practitioner_id'], id_field='practitioner_id') if patient is None or source is None or site is None or (source_slot is None) or (alternate is None): raise RuntimeError(f"missing follow-up fixture source for {target['patient_id']}") if patient.get('care_tier') != target['care_tier']: raise RuntimeError(f"care-tier drift for {target['patient_id']}") fixture_checks = {'patient': source.get('patient_id') == target['patient_id'], 'completed_source': source.get('status') == 'completed', 'patient_home_site': patient.get('primary_site_id') == target['site_id'], 'source_site': source.get('site_id') == target['site_id'], 'source_practitioner': source.get('practitioner_id') == target['source_practitioner_id'], 'source_specialty': source_slot.get('specialty') == target['specialty'], 'schedulable_site': site.get('operating_status') in {'open', 'limited'}, 'virtual_capability': site.get('supports_virtual') is True} if not all(fixture_checks.values()): failed = sorted((name for (name, passed) in fixture_checks.items() if not passed)) raise RuntimeError(f"invalid follow-up fixture for {target['patient_id']}: {', '.join(failed)}") self.manager.update_entity('appointment', target['source_appointment_id'], {'follow_up_required': True}, id_field='appointment_id') for slot in fn_candidate_slots(target): if self.manager.get_entity('schedule_slot', slot['slot_id'], id_field='slot_id') is None: self.manager.add_entity('schedule_slot', slot, id_field='slot_id') def _result(self, tool, status, data=None, message=''): return {'type': 'tool_result', 'tool': tool, 'content': {'status': status, 'data': data or {}, 'message': message}} def _error(self, tool, code, message, cost=0): result = self._result(tool, 'error', message=f'{code}: {message}') result['budget'] = {'charged': cost, 'remaining': self.remaining} return result def _record(self, tool, actor, arguments, cost, before_hash, result): receipt = {'index': len(self.receipts) + 1, 'tool': tool, 'actor': actor, 'arguments': mod_copy.deepcopy(arguments), 'status': result.get('content', {}).get('status'), 'observed': mod_copy.deepcopy(result.get('content', {}).get('data', {})), 'cost': cost, 'before_hash': before_hash, 'after_hash': self.semantic_hash()} self.receipts.append(receipt) result['budget'] = {'charged': cost, 'remaining': self.remaining} result['receipt_index'] = receipt['index'] return result def _current_policy(self, care_tier, request_class): row = fn_policy_cell(care_tier, request_class) override = self.policy_overrides.get((care_tier, request_class)) if override is not None: row['routing_profile_id'] = override['routing_profile_id'] row['routing_behavior'] = override['routing_behavior'] row.update(DATA_PROFILE_REQUIREMENTS[override['routing_behavior']]) row['policy_version'] = 'followup-routing-v2' return row def business_hash(self): return mod_hashlib.sha256(fn__canonical(self._manager_snapshot()['database']).encode('utf-8')).hexdigest() def lineage_hash(self): payload = {'semantic_hash': self.semantic_hash(), 'initial_budget': self.initial_budget, 'active_task_id': self.active_task_id, 'active_request_ids': [row.get('request_id') for row in self.active_targets], 'episode_receipt_start': self.episode_receipt_start, 'activation_ledger': self.activation_ledger} return mod_hashlib.sha256(fn__canonical(payload).encode('utf-8')).hexdigest() def _episode_receipts(self): return self.receipts[self.episode_receipt_start:] def _observed_context(self, patient_id): return any((receipt.get('tool') == 'get_patient_scheduling_context' and receipt.get('status') == 'success' and (receipt.get('observed', {}).get('patient_id') == patient_id) for receipt in self._episode_receipts())) def _observed_eligible_slot(self, target): expected = self._current_policy(target['care_tier'], target['request_class']) for receipt in self._episode_receipts(): if receipt.get('tool') != 'search_appointment_slots' or receipt.get('status') != 'success': continue for slot in receipt.get('observed', {}).get('slots', []): same_practitioner = slot.get('practitioner_id') == target['source_practitioner_id'] relation_matches = same_practitioner if expected['practitioner_relation'] == 'source_practitioner' else not same_practitioner if slot.get('site_id') == target['site_id'] and slot.get('specialty') == target['specialty'] and (slot.get('visit_mode') == expected['visit_mode']) and str(slot.get('start_at', '')).startswith(target['date']) and relation_matches: return True return False def _appointment_adapter_grade(self): database = self._manager_snapshot()['database'] appointments = database.get('appointment', []) slots = {row.get('slot_id'): row for row in database.get('schedule_slot', [])} artifacts = [] for target in self.active_targets: expected = self._current_policy(target['care_tier'], target['request_class']) matches = [row for row in appointments if row.get('follow_up_for_appointment_id') == target['source_appointment_id']] source = self.manager.get_entity('appointment', target['source_appointment_id'], id_field='appointment_id') appointment: dict[str, ext_Any] = {} for candidate in reversed(matches): candidate_slot = slots.get(candidate.get('slot_id'), {}) same_practitioner = candidate_slot.get('practitioner_id') == target['source_practitioner_id'] relation_matches = same_practitioner if expected['practitioner_relation'] == 'source_practitioner' else bool(candidate_slot) and (not same_practitioner) if candidate.get('status') == 'scheduled' and candidate.get('patient_id') == target['patient_id'] and (candidate_slot.get('slot_status') == 'booked') and (candidate_slot.get('site_id') == target['site_id']) and (candidate_slot.get('specialty') == target['specialty']) and (candidate_slot.get('visit_mode') == expected['visit_mode']) and str(candidate_slot.get('start_at', '')).startswith(target['date']) and relation_matches: appointment = candidate break completed = bool(appointment and source is not None and (source.get('follow_up_required') is False)) milestones = {'context_resolved': completed or self._observed_context(target['patient_id']), 'eligible_slot_identified': completed or self._observed_eligible_slot(target), 'follow_up_committed': completed} score = 25.0 if completed else 2.5 * milestones['context_resolved'] + 2.5 * milestones['eligible_slot_identified'] artifacts.append({'patient_id': target['patient_id'], 'request_class': target['request_class'], 'score': score, 'complete': completed, 'appointment_id': appointment.get('appointment_id'), 'slot_id': appointment.get('slot_id'), 'milestones': milestones}) return {'task_id': self.active_task_id, 'score': sum((row['score'] for row in artifacts)), 'completed_artifacts': sum((row['complete'] for row in artifacts)), 'artifacts': artifacts} def _medical_portable_world_snapshot(self): value = World._medical_context_world_snapshot(self) value['active_targets'] = list(value['active_targets']) value['independent_followups_contract'] = 'medical-independent-portable-evolution-v4' return value def _medical_portable_world_restore(self, snapshot): value = ext_deepcopy(snapshot) if value.pop('independent_followups_contract', None) != 'medical-independent-portable-evolution-v4': raise ValueError('Medical portable-followup snapshot version differs') World._medical_context_world_restore(self, value) if self.snapshot() != snapshot: raise ValueError('Medical portable-followup snapshot did not round trip') def _medical_rule_successor_policy_evidence(self, care_tier, request_class): old = fn_policy_cell(care_tier, request_class) current = self._current_policy(care_tier, request_class) rows = [old] if current != old: rows.append(current) evidence = [] for row in rows: candidate = {key: ext_deepcopy(value) for (key, value) in row.items() if key != 'policy_version'} candidate['evidence_id'] = 'PE-' + fn_digest({'care_tier': care_tier, 'request_class': request_class, 'routing_profile_id': row['routing_profile_id']})[:12].upper() evidence.append(candidate) evidence.sort(key=lambda row: row['evidence_id']) return self._result('get_follow_up_policy', 'success', {'care_tier': care_tier, 'request_class': request_class, 'evidence': evidence}) def _medical_rule_successor_init(self, source=CASE_DIR / 'raw', budget=72): self._medical_rule_successor_init_2(source=source, budget=budget) def _appointment_adapter_semantic_hash(self): payload = {'database': self._manager_snapshot()['database'], 'remaining': self.remaining, 'receipts': self.receipts, 'policy_overrides': sorted(((care_tier, request_class, fn__canonical(profile)) for ((care_tier, request_class), profile) in self.policy_overrides.items())), 'boundary_events': sorted(self.applied_boundary_events)} return mod_hashlib.sha256(fn__canonical(payload).encode('utf-8')).hexdigest() def _medical_rule_successor_follow_up_guard(self, arguments): if not self._slot_observed_in_current_episode(arguments['new_slot_id']): return self._error('create_follow_up_appointment', 'SLOT_EVIDENCE_REQUIRED', 'the selected slot must be observed by a successful search in this episode') return self._appointment_adapter_follow_up_guard(arguments) def _medical_rule_successor_dispatch(self, tool, arguments, actor='follow_up_scheduler'): if tool != 'get_follow_up_policy': return self._appointment_adapter_dispatch(tool, arguments, actor) if actor != 'follow_up_scheduler': return self._error(tool, 'ROLE_FORBIDDEN', 'actor is not a follow-up scheduler') if tool not in DATA_ALLOWED_TOOLS: return self._error(tool, 'TOOL_FORBIDDEN', 'tool is outside the follow-up slice') cost = self._cost(tool, arguments) if self.remaining < cost: return self._error(tool, 'WORK_QUOTA_EXHAUSTED', 'insufficient API-work quota') before_hash = self.semantic_hash() validation_error = fn__validate_arguments(tool, arguments) self.remaining -= cost if validation_error is not None: result = self._error(tool, 'INVALID_ARGUMENTS', validation_error, cost) else: result = self._policy_evidence(arguments['care_tier'], arguments['request_class']) return self._record(tool, actor, arguments, cost, before_hash, result) def _appointment_adapter_cost(self, tool, arguments): if tool in DATA_READ_COSTS: return DATA_READ_COSTS[tool] if tool == 'search_appointment_slots': return 2 + fn__bounded_limit(arguments) return DATA_WRITE_COSTS[tool] def _medical_rule_successor_patient_context(self, patient_id): result = self._appointment_adapter_patient_context(patient_id) if result.get('content', {}).get('status') == 'success': result = ext_deepcopy(result) result['content']['data']['routing_policy_epoch'] = self.routing_epoch return result def _appointment_adapter_apply_policy_drift(self, event_id, changed_cells): if event_id in self.applied_boundary_events: return {'status': 'success', 'event_id': event_id, 'idempotent': True} for (cell, profile) in changed_cells.items(): (care_tier, request_class) = cell if care_tier not in DATA_POLICY_MATRIX or request_class not in DATA_POLICY_MATRIX[care_tier]: raise ValueError(f'unknown policy cell: {cell}') behavior = profile.get('routing_behavior') profile_id = profile.get('routing_profile_id') if behavior not in DATA_PROFILE_REQUIREMENTS: raise ValueError(f'unknown routing behavior: {behavior}') if not isinstance(profile_id, str) or not profile_id: raise ValueError('routing_profile_id must be a non-empty string') if profile_id in {value for rows in DATA_POLICY_PROFILE_IDS.values() for value in rows.values()}: raise ValueError('drift profile id must differ from every pre-drift id') self.policy_overrides[care_tier, request_class] = mod_copy.deepcopy(profile) self.applied_boundary_events.add(event_id) return {'status': 'success', 'event_id': event_id, 'idempotent': False, 'changed_cells': [f'{a}|{b}' for (a, b) in changed_cells]} def _medical_context_world_snapshot(self): value = self._medical_evolution_snapshot() value['evolution_contract']['case_version'] = 'medical-context-scope-evolution-v2' return value def _medical_context_world_restore(self, snapshot): value = ext_deepcopy(snapshot) if value.get('evolution_contract', {}).get('case_version') != 'medical-context-scope-evolution-v2': raise ValueError('Medical context-scope snapshot version differs') value['evolution_contract']['case_version'] = 'medical-lifecycle-evolution-v1' self._medical_evolution_restore(value) def _medical_rule_successor_init_2(self, source=CASE_DIR / 'raw', budget=72): self._medical_rule_successor_init_3(source=source, budget=budget) def _appointment_adapter_follow_up_guard(self, arguments): source = self.manager.get_entity('appointment', arguments['source_appointment_id'], id_field='appointment_id') if source is None: return None patient = self.manager.get_entity('patient_profile', source.get('patient_id', ''), id_field='patient_id') if patient is None: return self._error('create_follow_up_appointment', 'FOLLOW_UP_CONTEXT_INCOMPLETE', 'the source encounter has no patient scheduling context') target = self.active_by_patient.get(patient.get('patient_id')) if target is None or target['source_appointment_id'] != source.get('appointment_id'): return self._error('create_follow_up_appointment', 'FOLLOW_UP_REQUEST_NOT_ACTIVE', 'the source encounter is not the active follow-up request') slot = self.manager.get_entity('schedule_slot', arguments['new_slot_id'], id_field='slot_id') if slot is None: return None source_slot = self.manager.get_entity('schedule_slot', source.get('slot_id', ''), id_field='slot_id') if source_slot is None: return self._error('create_follow_up_appointment', 'FOLLOW_UP_CONTEXT_INCOMPLETE', 'the source encounter has no complete scheduling context') if arguments['request_class'] != target['request_class']: return self._error('create_follow_up_appointment', 'REQUEST_CLASS_MISMATCH', 'the supplied request class does not match the active request') expected = self._current_policy(patient['care_tier'], arguments['request_class']) if arguments['routing_profile_id'] != expected['routing_profile_id']: return self._error('create_follow_up_appointment', 'FOLLOW_UP_POLICY_MISMATCH', 'the selected routing profile id does not satisfy the current policy cell') if slot.get('site_id') != patient.get('primary_site_id'): return self._error('create_follow_up_appointment', 'FOLLOW_UP_SITE_MISMATCH', "the selected slot is outside the patient's home-site continuity group") if slot.get('specialty') != source_slot.get('specialty'): return self._error('create_follow_up_appointment', 'FOLLOW_UP_SPECIALTY_MISMATCH', 'the selected slot does not preserve the source specialty') if not str(slot.get('start_at', '')).startswith(target['date']): return self._error('create_follow_up_appointment', 'FOLLOW_UP_DATE_MISMATCH', 'the selected slot is outside the active request date') if slot.get('visit_mode') != expected['visit_mode']: return self._error('create_follow_up_appointment', 'FOLLOW_UP_MODE_MISMATCH', 'the selected slot mode does not satisfy the routing profile') same_practitioner = slot.get('practitioner_id') == source.get('practitioner_id') relation = expected['practitioner_relation'] if relation == 'source_practitioner' and (not same_practitioner): return self._error('create_follow_up_appointment', 'FOLLOW_UP_CONTINUITY_MISMATCH', 'the selected slot does not preserve source-clinician continuity') if relation == 'alternate_same_specialty' and same_practitioner: return self._error('create_follow_up_appointment', 'FOLLOW_UP_TEAM_MISMATCH', 'the selected slot does not use an alternate clinician from the specialty team') return None def _appointment_adapter_dispatch(self, tool, arguments, actor='follow_up_scheduler'): if actor != 'follow_up_scheduler': return self._error(tool, 'ROLE_FORBIDDEN', 'actor is not a follow-up scheduler') if tool not in DATA_ALLOWED_TOOLS: return self._error(tool, 'TOOL_FORBIDDEN', 'tool is outside the follow-up slice') cost = self._cost(tool, arguments) if self.remaining < cost: return self._error(tool, 'WORK_QUOTA_EXHAUSTED', 'insufficient API-work quota') before_hash = self.semantic_hash() validation_error = fn__validate_arguments(tool, arguments) self.remaining -= cost if validation_error is not None: result = self._error(tool, 'INVALID_ARGUMENTS', validation_error, cost) return self._record(tool, actor, arguments, cost, before_hash, result) if tool == 'get_patient_scheduling_context': result = self._patient_context(arguments['patient_id']) elif tool == 'get_follow_up_policy': result = self._result(tool, 'success', self._current_policy(arguments['care_tier'], arguments['request_class'])) elif tool == 'search_appointment_slots': result = self.server.call_tool(tool, state_manager=self.manager, **arguments) else: guarded = self._follow_up_guard(arguments) if guarded is not None: result = guarded else: raw_arguments = mod_copy.deepcopy(arguments) raw_arguments.pop('request_class') raw_arguments.pop('routing_profile_id') result = self.server.call_tool('create_follow_up_appointment', state_manager=self.manager, **raw_arguments) result['tool'] = tool return self._record(tool, actor, arguments, cost, before_hash, result) def _appointment_adapter_patient_context(self, patient_id): target = self.active_by_patient.get(patient_id) if target is None: return self._error('get_patient_scheduling_context', 'FOLLOW_UP_REQUEST_NOT_ACTIVE', 'no active follow-up request matches this patient') patient = self.manager.get_entity('patient_profile', patient_id, id_field='patient_id') source = self.manager.get_entity('appointment', target['source_appointment_id'], id_field='appointment_id') source_slot = self.manager.get_entity('schedule_slot', source.get('slot_id', '') if source else '', id_field='slot_id') if patient is None or source is None or source_slot is None: return self._error('get_patient_scheduling_context', 'FOLLOW_UP_CONTEXT_INCOMPLETE', 'the active follow-up dossier is incomplete') return self._result('get_patient_scheduling_context', 'success', {'patient_id': patient_id, 'care_tier': patient.get('care_tier'), 'home_site_id': patient.get('primary_site_id'), 'source_appointment_id': source.get('appointment_id'), 'source_status': source.get('status'), 'source_follow_up_required': bool(source.get('follow_up_required')), 'source_practitioner_id': source.get('practitioner_id'), 'source_specialty': source_slot.get('specialty'), 'source_visit_mode': source.get('visit_mode'), 'last_verified': '2026-05-25T12:00:00Z'}) def _medical_evolution_snapshot(self): value = self._medical_rule_successor_snapshot() value['evolution_contract'] = {'case_version': 'medical-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2)} return value def _medical_evolution_restore(self, snapshot): value = ext_deepcopy(snapshot) if value.pop('evolution_contract', None) != {'case_version': 'medical-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2}: raise ValueError('Medical evolution snapshot contract differs') self._medical_rule_successor_restore(value) def _medical_rule_successor_init_3(self, source=CASE_DIR / 'raw', budget=132): self._appointment_adapter_init(ext_Path(source), budget=budget, auto_activate_t01=False) def _medical_rule_successor_snapshot(self): value = self._medical_rule_successor_snapshot_2() value['schema'] = 'rescopebench-medical-rule-stream/v6' value['rule_revalidation'] = ext_deepcopy(self.rule_revalidation) return value def _medical_rule_successor_restore(self, snapshot): if snapshot.get('schema') != 'rescopebench-medical-rule-stream/v6': raise ValueError('unsupported Medical rule v6 snapshot') value = ext_deepcopy(snapshot) self.rule_revalidation = ext_deepcopy(value.pop('rule_revalidation', {})) value['schema'] = 'rescopebench-medical-rule-stream/v4' self._medical_rule_successor_restore_2(value) def _appointment_adapter_init(self, source, budget=56, *, auto_activate_t01=True): source = ext_Path(source).resolve() self.source = source (self.logic, self.server, self.manager) = fn__load_isolated_runtime(source) self.initial_budget = int(budget) self.remaining = int(budget) self.receipts: list[dict[str, ext_Any]] = [] self.policy_overrides: dict[tuple[str, str], dict[str, str]] = {} self.applied_boundary_events: set[str] = set() self.active_task_id: str | None = 'T01' if auto_activate_t01 else None self.active_targets: tuple[dict[str, ext_Any], ...] = tuple(mod_copy.deepcopy(DATA_T01_TARGETS)) if auto_activate_t01 else () self.active_by_patient: dict[str, dict[str, ext_Any]] = {row['patient_id']: row for row in self.active_targets} self.episode_receipt_start = 0 self.activation_ledger: list[dict[str, ext_Any]] = [] if auto_activate_t01: self._install_follow_up_fixture(self.active_targets) def _medical_rule_successor_snapshot_2(self): value = self._medical_rule_successor_snapshot_3() value['schema'] = 'rescopebench-medical-rule-stream/v4' return value def _medical_rule_successor_restore_2(self, snapshot): if snapshot.get('schema') != 'rescopebench-medical-rule-stream/v4': raise ValueError('unsupported Medical rule v4 snapshot') value = ext_deepcopy(snapshot) value['schema'] = 'rescopebench-medical-rule-stream/v3' self._medical_rule_successor_restore_3(value) def _medical_rule_successor_snapshot_3(self): value = self._medical_rule_successor_snapshot_4() value['schema'] = 'rescopebench-medical-rule-stream/v3' value['provider_tools_sha256'] = '1d5426ebbfdd2204858a0dabdca9acec0cab6cd23642748680fa0f888237999b' return value def _medical_rule_successor_restore_3(self, snapshot): if snapshot.get('schema') != 'rescopebench-medical-rule-stream/v3': raise ValueError('unsupported Medical rule v3 snapshot') value = ext_deepcopy(snapshot) value['schema'] = 'rescopebench-medical-rule-stream/v2' value['provider_tools_sha256'] = self._medical_rule_successor_snapshot_4()['provider_tools_sha256'] self._medical_rule_successor_restore_4(value) def _medical_rule_successor_snapshot_4(self): value = self._appointment_adapter_snapshot() value['schema'] = 'rescopebench-medical-rule-stream/v2' value['provider_tools_sha256'] = '52f5daa6af97aedf70819ce08e378bdf9538e8fa4c3cd28714a74172c75e3260' return value def _medical_rule_successor_restore_4(self, snapshot): if snapshot.get('schema') != 'rescopebench-medical-rule-stream/v2': raise ValueError('unsupported Medical rule successor snapshot') value = ext_deepcopy(snapshot) value.pop('schema', None) value.pop('provider_tools_sha256', None) self._appointment_adapter_restore(value) def _appointment_adapter_snapshot(self): return {'raw': mod_copy.deepcopy(self._manager_snapshot()), 'db_id_counters': mod_copy.deepcopy(self.manager.db._id_counters), 'initial_budget': self.initial_budget, 'remaining': self.remaining, 'receipts': mod_copy.deepcopy(self.receipts), 'policy_overrides': {f'{care_tier}|{request_class}': mod_copy.deepcopy(profile) for ((care_tier, request_class), profile) in self.policy_overrides.items()}, 'applied_boundary_events': sorted(self.applied_boundary_events), 'active_task_id': self.active_task_id, 'active_targets': mod_copy.deepcopy(self.active_targets), 'episode_receipt_start': self.episode_receipt_start, 'activation_ledger': mod_copy.deepcopy(self.activation_ledger)} def _appointment_adapter_restore(self, snapshot): database = mod_copy.deepcopy(snapshot['raw']['database']) self.manager.db._data = database self.manager.db._id_counters = mod_copy.deepcopy(snapshot.get('db_id_counters', {})) for entity_type in database: self.manager.db._flush(entity_type) self.manager._counters = mod_copy.deepcopy(snapshot['raw'].get('counters', {})) self.manager.invalidate_core_state() self.initial_budget = int(snapshot.get('initial_budget', self.initial_budget)) self.remaining = int(snapshot['remaining']) self.receipts = mod_copy.deepcopy(snapshot['receipts']) self.policy_overrides = {tuple(key.split('|', 1)): mod_copy.deepcopy(value) for (key, value) in snapshot.get('policy_overrides', {}).items()} self.applied_boundary_events = set(snapshot.get('applied_boundary_events', [])) self.active_task_id = snapshot.get('active_task_id', 'T01') fallback_targets = DATA_T01_TARGETS if self.active_task_id == 'T01' else () self.active_targets = tuple(mod_copy.deepcopy(snapshot.get('active_targets', fallback_targets))) self.active_by_patient = {row['patient_id']: row for row in self.active_targets} self.episode_receipt_start = int(snapshot.get('episode_receipt_start', 0)) self.activation_ledger = mod_copy.deepcopy(snapshot.get('activation_ledger', []))