Blame for cases/medical_appointment/runtime.py

"""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', []))