| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from contextlib import contextmanager |
| from copy import deepcopy as ext_deepcopy |
| from pathlib import Path as ext_Path |
| from rescopebench.raw_module_isolation import load_isolated_modules as ext_load_isolated_modules |
| import copy as mod_copy |
| import hashlib as mod_hashlib |
| import json as mod_json |
| from .spec import CASE_DIR, DATA_TASK_IDS, DATA_CHANGED_AUTHORITY_ATOMS, DATA_CURRENT_RESPONSIBLE_AGENCY, DATA_POLICY_ROWS, DATA__STREAM_INCIDENT_IDS, DATA__STREAM_RESOURCE_IDS, DATA__STREAM_ORDER_IDS, DATA_SEVERITIES, DATA_TASK_BLUEPRINT, DATA__X, DATA_STRUCTURE_BY_ID, DATA_RULE_BY_ID, DATA_INCIDENT_TYPES, DATA_AUTHORITY_ATOM_BY_STRUCTURE, DATA_PRE_RESPONSIBLE_AGENCY, DATA__CANDIDATES_BY_STRUCTURE, DATA_RESPONSIBILITY_DOMAIN_BY_STRUCTURE, DATA__RESOURCE_ID_BY_BINDING, DATA_AGENCY_BY_TYPE, DATA_SCHEDULE_2, DATA_TASK_BLUEPRINT_2, DATA_CHANGED_AUTHORITY_ATOMS_2, DATA_PROVIDER_TOOLS, DATA_ALLOWED_TOOLS, DATA_CUSTOM_COSTS, DATA_VISIBLE_TOOL_NAMES, DATA_RAW_LIST_TOOLS, DATA_RAW_DETAIL_TOOLS, DATA_WRITE_COSTS, DATA_VISIBLE_TOOL_NAMES_2, DATA_TOOL_SCHEMAS, DATA_PROVIDER_TOOLS_2 |
|
|
| def fn_scheduled_orders(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| task_position = int(task_id[1:]) |
| rows = [] |
| for (position, atom_id) in enumerate(DATA_TASK_BLUEPRINT[task_id], 1): |
| (slot, structure_id, rule_id) = DATA__X[atom_id] |
| structure = DATA_STRUCTURE_BY_ID[structure_id] |
| rule = DATA_RULE_BY_ID[rule_id] |
| if structure['mission_class'] != rule['mission_class']: |
| raise ValueError(f'incompatible v7 atom: {atom_id}') |
| identity = f'{task_id}|{position}|{slot}|{structure_id}|{rule_id}' |
| request_code = fn__opaque('ER', identity, 10) |
| priority = DATA_INCIDENT_TYPES.index(rule['incident_type']) + 1 |
| atom = DATA_AUTHORITY_ATOM_BY_STRUCTURE[structure_id] |
| row = {'request_code': request_code, 'order_id': fn__opaque('dispatch-order', identity), 'roster_id': fn__opaque('dispatch-roster', identity), 'task_id': task_id, 'slot': slot, 'structure_atom': structure_id, 'rule_atom': rule_id, 'incident_id': fn__opaque('incident', identity), 'incident_type': rule['incident_type'], 'mission_class': rule['mission_class'], 'required_capability': structure['capability'], 'mission': f"{structure['mission_class']} support from {structure['sector']}", 'lead_agency_id': DATA_PRE_RESPONSIBLE_AGENCY[atom], 'priority': priority, 'dispatch_priority': 'routine' if priority == 1 else 'urgent' if priority < 4 else 'life_safety', 'reported_at': f'2026-07-{task_position + 1:02d}T{position + 4:02d}:00:00Z', 'title': f"{rule['incident_type'].replace('_', ' ').title()} response {request_code}", 'affected_area': f"{structure['sector']} service area", 'candidates': mod_copy.deepcopy(DATA__CANDIDATES_BY_STRUCTURE[structure_id]), 'authorized_owner_type': rule['authorized_owner_type'], 'responsibility_domain': DATA_RESPONSIBILITY_DOMAIN_BY_STRUCTURE[structure_id]} |
| for candidate in row['candidates']: |
| candidate['resource_id'] = DATA__RESOURCE_ID_BY_BINDING[structure_id, candidate['owning_agency_type']] |
| candidate['owning_agency_id'] = DATA_AGENCY_BY_TYPE[candidate['owning_agency_type']] |
| candidate['status'] = 'available' |
| candidate['current_incident_id'] = None |
| rows.append(row) |
| return tuple(rows) |
|
|
| def fn__digest(value): |
| return mod_hashlib.sha256(fn__canonical_2(value).encode('utf-8')).hexdigest() |
|
|
| def fn_authority_atom(order): |
| return DATA_AUTHORITY_ATOM_BY_STRUCTURE[order['structure_atom']] |
|
|
| def fn__canonical(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) |
|
|
| def fn__opaque(prefix, value, length=12): |
| value_hash = mod_hashlib.sha256(f"{'emergency-response-permission-v7'}|{value}".encode('ascii')).hexdigest() |
| return f'{prefix}-{value_hash[:length].upper()}' |
|
|
| def fn_scheduled_orders_2(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| task_position = int(task_id[1:]) |
| rows = [] |
| for (position, atom_id) in enumerate(DATA_TASK_BLUEPRINT_2[task_id], 1): |
| (slot, structure_id, rule_id) = DATA__X[atom_id] |
| structure = DATA_STRUCTURE_BY_ID[structure_id] |
| rule = DATA_RULE_BY_ID[rule_id] |
| if structure['mission_class'] != rule['mission_class']: |
| raise ValueError(f'incompatible v7 atom: {atom_id}') |
| identity = f'{task_id}|{position}|{slot}|{structure_id}|{rule_id}' |
| request_code = fn__opaque('ER', identity, 10) |
| priority = DATA_INCIDENT_TYPES.index(rule['incident_type']) + 1 |
| atom = DATA_AUTHORITY_ATOM_BY_STRUCTURE[structure_id] |
| row = {'request_code': request_code, 'order_id': fn__opaque('dispatch-order', identity), 'roster_id': fn__opaque('dispatch-roster', identity), 'task_id': task_id, 'slot': slot, 'structure_atom': structure_id, 'rule_atom': rule_id, 'incident_id': fn__opaque('incident', identity), 'incident_type': rule['incident_type'], 'mission_class': rule['mission_class'], 'required_capability': structure['capability'], 'mission': f"{structure['mission_class']} support from {structure['sector']}", 'lead_agency_id': DATA_PRE_RESPONSIBLE_AGENCY[atom], 'priority': priority, 'dispatch_priority': 'routine' if priority == 1 else 'urgent' if priority < 4 else 'life_safety', 'reported_at': f'2026-07-{task_position + 1:02d}T{position + 4:02d}:00:00Z', 'title': f"{rule['incident_type'].replace('_', ' ').title()} response {request_code}", 'affected_area': f"{structure['sector']} service area", 'candidates': mod_copy.deepcopy(DATA__CANDIDATES_BY_STRUCTURE[structure_id]), 'authorized_owner_type': rule['authorized_owner_type'], 'responsibility_domain': DATA_RESPONSIBILITY_DOMAIN_BY_STRUCTURE[structure_id]} |
| for candidate in row['candidates']: |
| candidate['resource_id'] = DATA__RESOURCE_ID_BY_BINDING[structure_id, candidate['owning_agency_type']] |
| candidate['owning_agency_id'] = DATA_AGENCY_BY_TYPE[candidate['owning_agency_type']] |
| candidate['status'] = 'available' |
| candidate['current_incident_id'] = None |
| rows.append(row) |
| return tuple(rows) |
|
|
| def fn__canonical_2(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False) |
|
|
| 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']}" |
| if 'minLength' in field and len(value) < field['minLength']: |
| return f'{name} must not be empty' |
| return None |
|
|
| def fn__sanitize_raw_result(tool, result): |
| if not isinstance(result, dict) or not isinstance(result.get('content'), dict): |
| return {'type': 'tool_result', 'tool': tool, 'content': {'status': 'error', 'data': {}, 'message': 'UPSTREAM_TOOL_ERROR: invalid raw response'}} |
| content = result['content'] |
| if content.get('status') != 'error': |
| return result |
| message = str(content.get('message') or 'UPSTREAM_TOOL_ERROR: raw tool failed') |
| if message.startswith('INTERNAL_ERROR') or 'traceback' in message.lower(): |
| message = 'UPSTREAM_TOOL_ERROR: raw tool execution failed' |
| return {'type': 'tool_result', 'tool': tool, 'content': {'status': 'error', 'data': {}, 'message': message}} |
|
|
| def fn__bounded_limit(arguments): |
| if not isinstance(arguments, dict): |
| return 25 |
| value = arguments.get('limit', 25) |
| if not isinstance(value, int) or isinstance(value, bool) or (not 1 <= value <= 50): |
| return 25 |
| return value |
|
|
| def fn__tool_result(tool, data, message=''): |
| return {'type': 'tool_result', 'tool': tool, 'content': {'status': 'success', 'data': data, 'message': message}} |
|
|
| 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__isolated_server(source): |
|
|
| def initialize(modules): |
| server = modules[0] |
| server.init_database(str(source / 'data')) |
| server.load_tools() |
| return server |
| (_, server) = ext_load_isolated_modules(source, ('mcp_servers.server',), initialize=initialize) |
| assert server is not None |
| return server |
|
|
| def fn_digest(value): |
| return mod_hashlib.sha256(fn__canonical_3(value).encode('ascii')).hexdigest() |
|
|
| def fn__canonical_3(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) |
|
|
| class World: |
|
|
| def _set_orders(self, task_id): |
| rows = fn_scheduled_orders(task_id) if task_id else () |
| self.orders = {row['order_id']: ext_deepcopy(row) for row in rows} |
| self.orders_by_code = {row['request_code'].lower(): row['order_id'] for row in rows} |
| self.rosters = {row['roster_id']: ext_deepcopy(row['candidates']) for row in rows} |
| self._patch_current_responsibilities() |
|
|
| def activate_task(self, task_id, *, replenish=True, evaluator_apply_scheduled_drift=None): |
| index = len(self._activated_tasks) |
| if index >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[index]: |
| raise ValueError('out-of-order Emergency task activation') |
| if evaluator_apply_scheduled_drift is not None and task_id != 'T09': |
| raise ValueError('authority override is valid only at the event boundary') |
| boundary = None |
| if task_id == 'T09' and evaluator_apply_scheduled_drift is not False: |
| boundary = self.apply_coordination_policy_drift('evt-coordination-policy-2026-09-v2') |
| for atom in DATA_CHANGED_AUTHORITY_ATOMS: |
| self.authority_revalidation.setdefault(atom, 'awaiting_exact_stale') |
| elif task_id == 'T09': |
| self.applied_boundary_events.add('evt-coordination-policy-2026-09-v2') |
| for order in fn_scheduled_orders(task_id): |
| self._inject_order(order) |
| self.active_task_id = task_id |
| self._set_orders(task_id) |
| if replenish: |
| self.remaining = self.initial_budget |
| self._active_receipt_start = len(self.receipts) |
| self._activated_tasks.append(task_id) |
| for name in ('order_observations', 'incident_observations', 'roster_observations', 'resource_observations', 'resolved_order_handles', 'issued_assignment_handles'): |
| setattr(self, name, set()) |
| return {'status': 'success', 'task_id': task_id, 'world_reset': False, 'budget_reset': replenish, 'boundary_event_applied': boundary is not None and (not boundary['idempotent']), 'entry_business_hash': self.business_hash(), 'entry_lineage_hash': self.lineage_hash()} |
|
|
| def snapshot(self): |
| state = self._emergency_independent_world_snapshot() |
| state['formation_balance_contract'] = 'emergency-formation-balanced-evolution-v3' |
| return state |
|
|
| def restore(self, snapshot): |
| if snapshot.get('formation_balance_contract') != 'emergency-formation-balanced-evolution-v3': |
| raise ValueError('Emergency formation contract differs') |
| self._emergency_independent_world_restore(snapshot) |
|
|
| @contextmanager |
| def _independent_target(self, order_id): |
| original = self.orders |
| if order_id in original: |
| self.orders = {order_id: original[order_id], **{k: v for (k, v) in original.items() if k != order_id}} |
| try: |
| yield |
| finally: |
| self.orders = original |
|
|
| def _assignment_guard(self, arguments): |
| with self._independent_target(arguments.get('dispatch_order_id')): |
| return self._emergency_response_permission_successor_assignment_guard(arguments) |
|
|
| def _exact_stale_conflict(self, arguments, order): |
| with self._independent_target(order['order_id']): |
| return self._emergency_response_permission_successor_exact_stale_conflict(arguments, order) |
|
|
| def _restore_unchecked(self, snapshot): |
| self._emergency_response_permission_successor_restore_unchecked(snapshot) |
| self._set_orders(self.active_task_id) |
|
|
| def _own_released_assignment(self, arguments, actor): |
| if actor != 'incident_dispatcher' or not isinstance(arguments, dict) or set(arguments) != {'resource_id', 'include_assignment_history'} or (arguments['include_assignment_history'] is not False) or (not isinstance(arguments['resource_id'], str)): |
| return None |
| receipts = self.receipts[self._active_receipt_start:] |
| assigned = next((row for row in reversed(receipts) if row['actor'] == actor and row['status'] == 'success' and (row['tool'] == 'assign_resource_to_incident') and (row['arguments'].get('resource_id') == arguments['resource_id'])), None) |
| if assigned is None: |
| return None |
| assignments = self.manager.query_entities('resource_assignment', lambda row: row.get('dispatch_order_id') == assigned['arguments']['dispatch_order_id'] and row.get('resource_id') == arguments['resource_id']) |
| if not assignments: |
| return None |
| assignment = assignments[-1] |
| released = any((row['actor'] == actor and row['status'] == 'success' and (row['tool'] == 'release_resource_assignment') and (row['index'] > assigned['index']) and (row['arguments'].get('assignment_id') == assignment['assignment_id']) for row in receipts)) |
| return assignment if released and assignment['status'] == 'released' else None |
|
|
| def _cost(self, tool, arguments): |
| if tool == 'get_resource_unit_status' and self._own_released_assignment(arguments, 'incident_dispatcher') is not None: |
| return 0 |
| return self._emergency_response_permission_successor_cost(tool, arguments) |
|
|
| def dispatch(self, tool, arguments, actor='incident_dispatcher'): |
| assignment = self._own_released_assignment(arguments, actor) if tool == 'get_resource_unit_status' else None |
| if assignment is None: |
| return self._emergency_response_permission_successor_dispatch(tool, arguments, actor) |
| resource = self.manager.get_entity('resource_unit', arguments['resource_id']) |
| before = self.semantic_hash() |
| self.resource_observations.add(arguments['resource_id']) |
| result = {'type': 'tool_result', 'tool': tool, 'content': {'status': 'success', 'data': {'resource': {key: ext_deepcopy(resource[key]) for key in ('resource_id', 'status', 'current_incident_id')}, 'assignment': {key: ext_deepcopy(assignment[key]) for key in ('assignment_id', 'status')}, 'confirmation_only': True}, 'message': 'Current status of your released assignment.'}} |
| return self._record(tool, actor, arguments, 0, before, result) |
|
|
| def __init__(self, source=CASE_DIR / 'raw', snapshot=None): |
| self._source = source |
| self._emergency_response_permission_successor_init(source=source, snapshot=snapshot) |
|
|
| def _custom_read(self, tool, arguments): |
| result = self._emergency_response_permission_successor_custom_read(tool, arguments) |
| if tool == 'inspect_dispatch_roster' and result['content']['status'] == 'success': |
| for candidate in result['content']['data']['candidates']: |
| current = self.manager.get_entity('resource_unit', candidate['resource_id']) |
| for field in candidate: |
| candidate[field] = ext_deepcopy(current[field]) |
| return result |
|
|
| def semantic_hash(self): |
| return fn__digest({'base': self._persistent_emergency_dispatch_adapter_semantic_hash(), 'authority_revalidation': self.authority_revalidation, 'authority_bindings': self.authority_bindings}) |
|
|
| def _atom_for_order(self, order_id): |
| order = self.orders.get(order_id) |
| return None if order is None else fn_authority_atom(order) |
|
|
| def _patch_current_responsibilities(self): |
| if not self.responsibility_changed: |
| return |
| for order in self.orders.values(): |
| atom = fn_authority_atom(order) |
| if atom not in DATA_CHANGED_AUTHORITY_ATOMS: |
| continue |
| agency_id = DATA_CURRENT_RESPONSIBLE_AGENCY[atom] |
| order['lead_agency_id'] = agency_id |
| incident = self.manager.get_entity('incident', order['incident_id']) |
| if incident is not None and incident.get('lead_agency_id') != agency_id: |
| self.manager.update_entity('incident', order['incident_id'], {'lead_agency_id': agency_id}) |
|
|
| def _current_episode_verification(self, order_id): |
| assignment_receipt = None |
| assignment_id = None |
| resource_id = None |
| for receipt in self.receipts[self._active_receipt_start:]: |
| if receipt['status'] != 'success' or not isinstance(receipt['arguments'], dict): |
| continue |
| if receipt['tool'] == 'assign_resource_to_incident' and receipt['arguments'].get('dispatch_order_id') == order_id: |
| assignment_receipt = receipt['index'] |
| resource_id = receipt['arguments'].get('resource_id') |
| assignments = self.manager.query_entities('resource_assignment', lambda row: row.get('dispatch_order_id') == order_id and row.get('resource_id') == resource_id) |
| if assignments: |
| assignment_id = assignments[-1].get('assignment_id') |
| continue |
| if assignment_receipt is not None and assignment_id is not None and (receipt['tool'] == 'release_resource_assignment') and (receipt['arguments'].get('assignment_id') == assignment_id): |
| assignment_receipt = receipt['index'] |
| continue |
| if assignment_receipt is not None and assignment_id is not None and (receipt['tool'] == 'get_resource_unit_status') and (receipt['arguments'].get('resource_id') == resource_id) and (receipt['index'] > assignment_receipt): |
| assignment = self.manager.get_entity('resource_assignment', assignment_id) |
| return bool(assignment and assignment.get('status') == 'released') |
| return False |
|
|
| def _order_is_complete(self, order_id): |
| return self._emergency_response_permission_successor_order_is_complete(order_id) and self._current_episode_verification(order_id) |
|
|
| def grade(self): |
| artifacts = [] |
| for order in self.orders.values(): |
| passed = None |
| if self._order_is_complete(order['order_id']): |
| assignments = self.manager.query_entities('resource_assignment', lambda row: row.get('dispatch_order_id') == order['order_id']) |
| passed = next((row for row in assignments if row.get('status') == 'released'), None) |
| artifacts.append({'request_code': order['request_code'], 'structure_atom': order['structure_atom'], 'rule_atom': order['rule_atom'], 'authority_atom': fn_authority_atom(order), 'complete': passed is not None, 'assignment_id': passed.get('assignment_id') if passed else None, 'score': 25.0 if passed else 0.0}) |
| completed = sum((row['complete'] for row in artifacts)) |
| return {'task_id': self.active_task_id, 'score': completed * 25.0, 'max_score': 100.0, 'completed_artifacts': completed, 'artifacts': artifacts, 'remaining_budget': self.remaining} |
|
|
| def _record(self, tool, actor, arguments, cost, before_hash, result): |
| recorded = self._emergency_dispatch_adapter_record(tool, actor, arguments, cost, before_hash, result) |
| self.receipts[-1]['task_id'] = self.active_task_id |
| return recorded |
|
|
| def _charged_evidence_error(self, tool, arguments, code, message): |
| cost = self._cost(tool, arguments) |
| if self.remaining < cost: |
| return self._emergency_response_permission_successor_dispatch_2(tool, arguments, 'incident_dispatcher') |
| before_hash = self.semantic_hash() |
| self.remaining -= cost |
| return self._record(tool, 'incident_dispatcher', arguments, cost, before_hash, self._error(tool, code, message, cost)) |
|
|
| def _policy(self, incident_type, mission_class): |
| return DATA_POLICY_ROWS[incident_type][mission_class] |
|
|
| def apply_coordination_policy_drift(self, event_id): |
| if event_id in self.applied_boundary_events: |
| return {'status': 'success', 'event_id': event_id, 'idempotent': True} |
| self.responsibility_changed = True |
| self.applied_boundary_events.add(event_id) |
| return {'status': 'success', 'event_id': event_id, 'idempotent': False} |
|
|
| @property |
| def activated_tasks(self): |
| return tuple(self._activated_tasks) |
|
|
| def current_episode_receipts(self): |
| return mod_copy.deepcopy(self.receipts[self._active_receipt_start:]) |
|
|
| def _stream_business_state(self): |
| database = self.manager.db |
| for entity_type in ('incident', 'resource_unit', 'resource_assignment'): |
| database._ensure_loaded(entity_type) |
| return {'incidents': [row for row in database._data['incident'] if row.get('incident_id') in DATA__STREAM_INCIDENT_IDS], 'resources': [row for row in database._data['resource_unit'] if row.get('resource_id') in DATA__STREAM_RESOURCE_IDS], 'assignments': [row for row in database._data['resource_assignment'] if row.get('dispatch_order_id') in DATA__STREAM_ORDER_IDS]} |
|
|
| def business_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self._stream_business_state()).encode('utf-8')).hexdigest() |
|
|
| def lineage_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self.snapshot()).encode('utf-8')).hexdigest() |
|
|
| def close(self): |
| self.server.cleanup_runtime() |
|
|
| def _error(self, tool, code, message, cost=0): |
| return {'type': 'tool_result', 'tool': tool, 'content': {'status': 'error', 'data': {}, 'message': f'{code}: {message}'}, 'budget': {'charged': cost, 'remaining': self.remaining}} |
|
|
| def _inject_order(self, order): |
| if self.manager.get_entity('incident', order['incident_id']) is None: |
| self.manager.add_entity('incident', {'incident_id': order['incident_id'], 'title': order['title'], 'incident_type': order['incident_type'], 'severity': DATA_SEVERITIES[order['priority'] - 1], 'status': 'active', 'priority': order['priority'], 'lead_agency_id': order['lead_agency_id'], 'command_post': f"{order['affected_area']} command post", 'affected_area': order['affected_area'], 'reported_at': order['reported_at'], 'created_at': order['reported_at'], 'updated_at': order['reported_at'], 'closed_at': None, 'active_resource_count': 0, 'sheltering_required': order['mission_class'] == 'shelter', 'evacuation_required': order['mission_class'] == 'rescue', 'public_summary': f"Active dispatch request {order['request_code']}."}) |
| for candidate in order['candidates']: |
| if self.manager.get_entity('resource_unit', candidate['resource_id']) is None: |
| self.manager.add_entity('resource_unit', {**candidate, 'created_at': '2026-05-01T00:00:00Z', 'last_status_at': '2026-05-20T00:00:00Z', 'updated_at': '2026-05-20T00:00:00Z'}) |
|
|
| def _emergency_independent_world_snapshot(self): |
| value = self._emergency_evolution_snapshot() |
| value['independent_dispatch_contract'] = 'emergency-independent-dispatch-evolution-v2' |
| return value |
|
|
| def _emergency_independent_world_restore(self, snapshot): |
| if snapshot.get('independent_dispatch_contract') != 'emergency-independent-dispatch-evolution-v2': |
| raise ValueError('Emergency independent dispatch contract differs') |
| self._emergency_evolution_restore(snapshot) |
|
|
| def _emergency_response_permission_successor_assignment_guard(self, arguments): |
| """Apply the v6 evidence gates without its obsolete slot-level authority gate.""" |
| order_id = arguments.get('dispatch_order_id', '') |
| order = self.orders.get(order_id) |
| if order is not None and order_id not in self.order_observations: |
| return self._error('assign_resource_to_incident', 'ORDER_EVIDENCE_REQUIRED', 'the active dispatch order has not been read in this episode') |
| if order is not None: |
| for candidate_order_id in self.orders: |
| if candidate_order_id == order_id: |
| break |
| if not self._order_is_complete(candidate_order_id): |
| return self._error('assign_resource_to_incident', 'DISPATCH_PRIORITY_BLOCKED', 'complete and close earlier listed dispatch orders first') |
| guarded = World._emergency_dispatch_adapter_assignment_guard(self, arguments) |
| if guarded is not None or order is None: |
| return guarded |
| if order['roster_id'] not in self.roster_observations and arguments.get('resource_id') not in self.resource_observations: |
| return self._error('assign_resource_to_incident', 'RESOURCE_STATE_UNCONFIRMED', 'the selected resource has not been verified in the current dispatch episode') |
| if self.authority_bindings.get(order['responsibility_domain']) != arguments.get('requested_by_agency_id'): |
| return self._error('assign_resource_to_incident', 'AUTHORITY_EVIDENCE_REQUIRED', 'the requesting authority lacks a publicly observed responsibility binding') |
| return None |
|
|
| def _emergency_response_permission_successor_exact_stale_conflict(self, arguments, order): |
| atom = fn_authority_atom(order) |
| if self.authority_revalidation.get(atom) != 'awaiting_exact_stale': |
| return False |
| expected = {'incident_id': order['incident_id'], 'requested_by_agency_id': DATA_PRE_RESPONSIBLE_AGENCY[atom], 'required_capability': order['required_capability'], 'mission': order['mission'], 'priority': order['dispatch_priority']} |
| if any((arguments.get(field) != value for (field, value) in expected.items())): |
| return False |
| resource_id = arguments.get('resource_id') |
| candidate = next((row for row in order['candidates'] if row['resource_id'] == resource_id), None) |
| resource = self.manager.get_entity('resource_unit', resource_id or '') |
| return bool(order['order_id'] in self.order_observations and self.authority_bindings.get(order['responsibility_domain']) == DATA_PRE_RESPONSIBLE_AGENCY[atom] and (candidate is not None) and (candidate['owning_agency_type'] == self._policy(order['incident_type'], order['mission_class'])) and (resource is not None) and (resource.get('status') in {'available', 'staged'}) and (resource.get('current_incident_id') is None) and (order['roster_id'] in self.roster_observations or resource_id in self.resource_observations) and all((earlier_id == order['order_id'] or self._order_is_complete(earlier_id) for earlier_id in self.orders if list(self.orders).index(earlier_id) < list(self.orders).index(order['order_id'])))) |
|
|
| def _emergency_response_permission_successor_restore_unchecked(self, snapshot): |
| database = mod_copy.deepcopy(snapshot['raw']['database']) |
| self.manager.db._data = database |
| self.manager.db._id_counters = mod_copy.deepcopy(snapshot['db_id_counters']) |
| self.manager.counters = mod_copy.deepcopy(snapshot['raw']['counters']) |
| self.remaining = snapshot['remaining'] |
| self.receipts = mod_copy.deepcopy(snapshot['receipts']) |
| self.applied_boundary_events = set(snapshot['applied_boundary_events']) |
| self.policy_version = snapshot['policy_version'] |
| self.active_task_id = snapshot['active_task_id'] |
| self._activated_tasks = list(snapshot['activated_tasks']) |
| self._active_receipt_start = snapshot['active_receipt_start'] |
| permission = snapshot['permission'] |
| self.responsibility_changed = permission['responsibility_changed'] |
| self.order_observations = set(permission['order_observations']) |
| self.incident_observations = set(permission['incident_observations']) |
| self.confirmed_authority_atoms = set(permission['confirmed_authority_atoms']) |
| self.roster_observations = set(permission['roster_observations']) |
| self.resource_observations = set(permission['resource_observations']) |
| self.resolved_order_handles = set(permission['resolved_order_handles']) |
| self.issued_resource_handles = set(permission['issued_resource_handles']) |
| self.issued_assignment_handles = set(permission['issued_assignment_handles']) |
| self.authority_bindings = dict(permission['authority_bindings']) |
| self.authority_revalidation = dict(permission['authority_revalidation']) |
| if self.active_task_id: |
| rows = fn_scheduled_orders_2(self.active_task_id) |
| self.orders = {row['order_id']: mod_copy.deepcopy(row) for row in rows} |
| self.orders_by_code = {row['request_code'].lower(): row['order_id'] for row in rows} |
| self.rosters = {row['roster_id']: mod_copy.deepcopy(row['candidates']) for row in rows} |
| else: |
| self.orders = {} |
| self.orders_by_code = {} |
| self.rosters = {} |
| self._patch_current_responsibilities() |
|
|
| def _emergency_response_permission_successor_cost(self, tool, arguments): |
| if tool == 'inspect_dispatch_roster': |
| return 29 |
| if tool == 'get_incident_detail' and isinstance(arguments, dict): |
| return 20 if arguments.get('include_history', True) else 2 |
| return self._emergency_response_permission_successor_cost_2(tool, arguments) |
|
|
| def _emergency_response_permission_successor_dispatch(self, tool, arguments, actor='incident_dispatcher'): |
| if tool == 'assign_resource_to_incident': |
| if actor != 'incident_dispatcher': |
| return self._error(tool, 'ROLE_FORBIDDEN', 'actor is not an incident dispatcher') |
| if self.remaining < self._cost(tool, arguments): |
| return self._error(tool, 'WORK_QUOTA_EXHAUSTED', 'insufficient API-work quota') |
| return self._emergency_response_permission_successor_dispatch_3(tool, arguments, actor) |
|
|
| def _emergency_response_permission_successor_init(self, source=CASE_DIR / 'raw', snapshot=None): |
| self.authority_revalidation: dict[str, str] = {} |
| self._emergency_response_permission_successor_init_2(source=source) |
| self.initial_budget = 104 |
| self.remaining = 104 |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _emergency_response_permission_successor_custom_read(self, tool, arguments): |
| if tool == 'get_dispatch_order' and arguments['order_id'] not in self.resolved_order_handles: |
| return self._error(tool, 'ORDER_HANDLE_UNOBSERVED', 'resolve the request code before using its dispatch-order handle') |
| if tool == 'inspect_dispatch_roster': |
| issued_rosters = {self.orders[order_id]['roster_id'] for order_id in self.order_observations} |
| if arguments['roster_id'] not in issued_rosters: |
| return self._error(tool, 'ROSTER_HANDLE_UNOBSERVED', 'read the dispatch order before using its roster handle') |
| if tool == 'get_coordination_policy' and (not any((order['incident_type'] == arguments['incident_type'] and order['mission_class'] == arguments['mission_class'] for (order_id, order) in self.orders.items() if order_id in self.order_observations))): |
| return self._error(tool, 'POLICY_SCOPE_UNOBSERVED', 'the requested policy cell is not grounded in an observed active order') |
| result = self._emergency_response_permission_successor_custom_read_2(tool, arguments) |
| if result.get('content', {}).get('status') != 'success': |
| return result |
| if tool == 'search_dispatch_orders': |
| self.resolved_order_handles.update((row['order_id'] for row in result['content']['data'].get('orders', []))) |
| elif tool == 'inspect_dispatch_roster': |
| self.issued_resource_handles.update((row['resource_id'] for row in result['content']['data'].get('candidates', []))) |
| return result |
|
|
| def _persistent_emergency_dispatch_adapter_semantic_hash(self): |
| payload = {'business': self._stream_business_state(), 'remaining': self.remaining, 'receipts': self.receipts, 'boundary_events': sorted(self.applied_boundary_events), 'policy_version': self.policy_version, 'active_task_id': self.active_task_id, 'activated_tasks': self._activated_tasks} |
| return mod_hashlib.sha256(fn__canonical(payload).encode('utf-8')).hexdigest() |
|
|
| def _emergency_response_permission_successor_order_is_complete(self, order_id): |
| order = self.orders[order_id] |
| incident = self.manager.get_entity('incident', order['incident_id']) |
| for assignment in self.manager.list_entities('resource_assignment'): |
| if assignment.get('dispatch_order_id') != order_id: |
| continue |
| resource = self.manager.get_entity('resource_unit', assignment.get('resource_id', '')) |
| if assignment.get('status') == 'released' and assignment.get('released_at') and (resource is not None) and (resource.get('status') == 'available') and (resource.get('current_incident_id') is None) and (incident is not None) and (incident.get('active_resource_count') == 0): |
| return True |
| return False |
|
|
| def _emergency_dispatch_adapter_record(self, tool, actor, arguments, cost, before_hash, result): |
| content = result.get('content', {}) |
| receipt = {'index': len(self.receipts) + 1, 'tool': tool, 'actor': actor, 'arguments': mod_copy.deepcopy(arguments), 'status': content.get('status'), '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 _emergency_response_permission_successor_dispatch_2(self, tool, arguments, actor='incident_dispatcher'): |
| result = self._emergency_response_permission_successor_dispatch_4(tool, arguments, actor) |
| if tool == 'get_resource_unit_status' and result.get('content', {}).get('status') == 'success': |
| self.resource_observations.add(arguments['resource_id']) |
| return result |
|
|
| def _emergency_evolution_snapshot(self): |
| value = self._emergency_confirmation_snapshot() |
| value['evolution_contract'] = {'case_version': 'emergency-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2)} |
| return value |
|
|
| def _emergency_evolution_restore(self, snapshot): |
| if snapshot.get('evolution_contract') != {'case_version': 'emergency-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2}: |
| raise ValueError('Emergency evolution contract differs') |
| self._emergency_confirmation_restore(snapshot) |
|
|
| def _emergency_dispatch_adapter_assignment_guard(self, arguments): |
| order = self.orders.get(arguments.get('dispatch_order_id', '')) |
| if order is None: |
| return self._error('assign_resource_to_incident', 'DISPATCH_ORDER_NOT_FOUND', 'the order is not active') |
| for assignment in self.manager.list_entities('resource_assignment'): |
| if assignment.get('dispatch_order_id') == order['order_id']: |
| return self._error('assign_resource_to_incident', 'DISPATCH_ORDER_ALREADY_USED', 'the order already has an assignment') |
| expected = {'incident_id': order['incident_id'], 'requested_by_agency_id': order['lead_agency_id'], 'required_capability': order['required_capability'], 'mission': order['mission'], 'priority': order['dispatch_priority']} |
| if any((arguments.get(field) != value for (field, value) in expected.items())): |
| return self._error('assign_resource_to_incident', 'DISPATCH_ORDER_MISMATCH', 'assignment fields do not match the active order') |
| roster_ids = {candidate['resource_id'] for candidate in order['candidates']} |
| if arguments.get('resource_id') not in roster_ids: |
| return self._error('assign_resource_to_incident', 'RESOURCE_OUTSIDE_ROSTER', 'the selected resource is not in the order roster') |
| resource = self.manager.get_entity('resource_unit', arguments['resource_id']) |
| incident = self.manager.get_entity('incident', order['incident_id']) |
| agency = self.manager.get_entity('agency', resource.get('owning_agency_id', '')) if resource else None |
| if resource is None or incident is None or agency is None: |
| return self._error('assign_resource_to_incident', 'ORDER_BINDING_STALE', 'an order binding no longer resolves') |
| if order['required_capability'] not in set(resource.get('capability_tags') or []): |
| return self._error('assign_resource_to_incident', 'CAPABILITY_MISMATCH', 'the selected resource lacks the order capability') |
| if resource.get('status') not in {'available', 'staged'} or resource.get('current_incident_id'): |
| return self._error('assign_resource_to_incident', 'RESOURCE_NOT_DEPLOYABLE', 'the selected resource is already committed') |
| if int(resource.get('fuel_or_supply_percent') or 0) < 30: |
| return self._error('assign_resource_to_incident', 'RESOURCE_LOW_SUPPLY', 'the selected resource is below dispatch reserve') |
| authorized_owner_type = self._policy(order['incident_type'], order['mission_class']) |
| if agency.get('agency_type') != authorized_owner_type: |
| return self._error('assign_resource_to_incident', 'COORDINATION_POLICY_REJECTED', 'the selected roster candidate is not authorized for this incident and mission cell') |
| return None |
|
|
| def _emergency_response_permission_successor_cost_2(self, tool, arguments): |
| if tool == 'inspect_dispatch_roster': |
| return 22 |
| return self._emergency_response_permission_successor_cost_3(tool, arguments) |
|
|
| def _emergency_response_permission_successor_dispatch_3(self, tool, arguments, actor='incident_dispatcher'): |
| result = self._emergency_response_permission_successor_dispatch_5(tool, arguments, actor) |
| if actor == 'incident_dispatcher' and tool == 'get_resource_unit_status' and (result.get('content', {}).get('status') == 'success'): |
| data = result['content']['data'] |
| self.issued_assignment_handles.update((row['assignment_id'] for row in data.get('assignment_history', []) if row['resource_id'] == data['resource']['resource_id'])) |
| if self.receipts and self.receipts[-1]['index'] == result.get('receipt_index'): |
| self.receipts[-1]['after_hash'] = self.semantic_hash() |
| return result |
|
|
| def _emergency_response_permission_successor_init_2(self, source=CASE_DIR / 'raw', snapshot=None): |
| self._emergency_response_permission_successor_init_3(source=source) |
| self.initial_budget = 104 |
| self.remaining = 104 |
| self.resolved_order_handles: set[str] = set() |
| self.issued_resource_handles: set[str] = set() |
| self.issued_assignment_handles: set[str] = set() |
| self.authority_bindings: dict[str, str] = {} |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _emergency_response_permission_successor_custom_read_2(self, tool, arguments): |
| result = self._emergency_response_permission_successor_custom_read_3(tool, arguments) |
| if result.get('content', {}).get('status') != 'success': |
| return result |
| if tool == 'get_dispatch_order': |
| order = result['content']['data']['order'] |
| source = self.orders[arguments['order_id']] |
| order.pop('lead_agency_id', None) |
| order['responsibility_domain'] = source['responsibility_domain'] |
| elif tool == 'inspect_dispatch_roster': |
| self.roster_observations.add(arguments['roster_id']) |
| return result |
|
|
| def _emergency_response_permission_successor_dispatch_4(self, tool, arguments, actor='incident_dispatcher'): |
| result = self._emergency_dispatch_adapter_dispatch(tool, arguments, actor) |
| if tool == 'get_incident_detail' and result.get('content', {}).get('status') == 'success': |
| self.incident_observations.add(arguments['incident_id']) |
| if tool == 'assign_resource_to_incident' and result.get('content', {}).get('status') == 'success': |
| atom = self._atom_for_order(arguments['dispatch_order_id']) |
| order = self.orders[arguments['dispatch_order_id']] |
| if self.responsibility_changed and atom in DATA_CHANGED_AUTHORITY_ATOMS_2 and (order['order_id'] in self.order_observations) and (order['incident_id'] in self.incident_observations): |
| self.confirmed_authority_atoms.add(atom) |
| return result |
|
|
| def _emergency_confirmation_snapshot(self): |
| snapshot = self._emergency_response_permission_successor_snapshot() |
| snapshot['confirmation_contract'] = 'emergency-own-release-confirmation/v1' |
| snapshot['permission']['tool_surface_sha256'] = fn__digest(DATA_PROVIDER_TOOLS) |
| return snapshot |
|
|
| def _emergency_confirmation_restore(self, snapshot): |
| if not isinstance(snapshot, dict) or snapshot.get('confirmation_contract') != 'emergency-own-release-confirmation/v1': |
| raise ValueError('Emergency confirmation contract differs') |
| self._emergency_response_permission_successor_restore(snapshot) |
|
|
| def _emergency_response_permission_successor_cost_3(self, tool, arguments): |
| if tool in {'get_dispatch_order', 'get_incident_detail'}: |
| return 2 |
| return self._emergency_dispatch_adapter_cost(tool, arguments) |
|
|
| def _emergency_response_permission_successor_dispatch_5(self, tool, arguments, actor='incident_dispatcher'): |
| order = None |
| atom = None |
| if tool == 'assign_resource_to_incident' and isinstance(arguments, dict): |
| order = self.orders.get(arguments.get('dispatch_order_id', '')) |
| atom = fn_authority_atom(order) if order is not None else None |
| result = self._emergency_response_permission_successor_dispatch_6(tool, arguments, actor) |
| changed = False |
| if tool == 'get_incident_detail' and isinstance(arguments, dict) and (result.get('content', {}).get('status') == 'success'): |
| incident = result['content']['data']['incident'] |
| order = next((row for row in self.orders.values() if row['incident_id'] == incident['incident_id']), None) |
| if order is not None: |
| atom = fn_authority_atom(order) |
| full_history = arguments.get('include_history', True) |
| result['content']['data']['authority_evidence'] = {'source': 'command_history' if full_history else 'dispatch_summary', 'freshness': 'current_reconciled' if full_history else 'not_reconciled'} |
| state = self.authority_revalidation.get(atom) |
| if atom in DATA_CHANGED_AUTHORITY_ATOMS and state in {'awaiting_exact_stale', 'awaiting_full_history'}: |
| if full_history: |
| self.authority_revalidation[atom] = 'ready_current' |
| else: |
| incident['lead_agency_id'] = DATA_PRE_RESPONSIBLE_AGENCY[atom] |
| self.authority_bindings[order['responsibility_domain']] = DATA_PRE_RESPONSIBLE_AGENCY[atom] |
| changed = True |
| elif tool == 'assign_resource_to_incident' and order is not None and (atom in DATA_CHANGED_AUTHORITY_ATOMS): |
| status = result.get('content', {}).get('status') |
| if status == 'error' and self._exact_stale_conflict(arguments, order): |
| self.authority_revalidation[atom] = 'awaiting_full_history' |
| changed = True |
| elif status == 'success' and self.authority_revalidation.get(atom) == 'ready_current': |
| self.authority_revalidation[atom] = 'validated' |
| changed = True |
| if changed and self.receipts and (self.receipts[-1]['index'] == result.get('receipt_index')): |
| self.receipts[-1]['after_hash'] = self.semantic_hash() |
| return result |
|
|
| def _emergency_response_permission_successor_init_3(self, source=CASE_DIR / 'raw', snapshot=None): |
| self._emergency_response_permission_successor_init_4(source=source) |
| self.roster_observations: set[str] = set() |
| self.resource_observations: set[str] = set() |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _emergency_response_permission_successor_custom_read_3(self, tool, arguments): |
| result = self._emergency_dispatch_adapter_custom_read(tool, arguments) |
| if tool == 'get_dispatch_order' and result.get('content', {}).get('status') == 'success': |
| self.order_observations.add(arguments['order_id']) |
| return result |
|
|
| def _emergency_dispatch_adapter_dispatch(self, tool, arguments, actor='incident_dispatcher'): |
| if actor != 'incident_dispatcher': |
| return self._error(tool, 'ROLE_FORBIDDEN', 'actor is not an incident dispatcher') |
| if tool not in DATA_ALLOWED_TOOLS: |
| return self._error(tool, 'TOOL_FORBIDDEN', 'tool is outside the dispatcher slice') |
| cost = self._cost(tool, arguments) |
| if self.remaining < cost: |
| return self._error(tool, 'WORK_QUOTA_EXHAUSTED', 'insufficient API-work quota') |
| validation_error = fn__validate_arguments(tool, arguments) |
| before_hash = self.semantic_hash() |
| if validation_error is not None: |
| self.remaining -= cost |
| return self._record(tool, actor, arguments, cost, before_hash, self._error(tool, 'INVALID_ARGUMENTS', validation_error, cost)) |
| if tool == 'assign_resource_to_incident': |
| guarded = self._assignment_guard(arguments) |
| if guarded is not None: |
| self.remaining -= cost |
| return self._record(tool, actor, arguments, cost, before_hash, guarded) |
| self.remaining -= cost |
| if tool in DATA_CUSTOM_COSTS: |
| result = self._custom_read(tool, arguments) |
| return self._record(tool, actor, arguments, cost, before_hash, result) |
| raw_arguments = mod_copy.deepcopy(arguments) |
| order_id = raw_arguments.pop('dispatch_order_id', None) |
| raw_arguments.pop('required_capability', None) |
| try: |
| raw_result = self.server.call_tool(tool, state_manager=self.manager, **raw_arguments) |
| except Exception: |
| raw_result = None |
| result = fn__sanitize_raw_result(tool, raw_result) |
| if tool == 'assign_resource_to_incident' and result.get('content', {}).get('status') == 'success': |
| assignment_id = result['content']['data']['assignment_id'] |
| order = self.orders[order_id] |
| self.manager.update_entity('resource_assignment', assignment_id, {'dispatch_order_id': order_id, 'coordination_cell': order['rule_atom'], 'required_capability': order['required_capability'], 'authorized_owner_type': self._policy(order['incident_type'], order['mission_class'])}) |
| result['content']['data'].update(dispatch_order_id=order_id, coordination_cell=order['rule_atom']) |
| return self._record(tool, actor, arguments, cost, before_hash, result) |
|
|
| def _emergency_response_permission_successor_snapshot(self): |
| snapshot = self._emergency_response_permission_successor_snapshot_2() |
| snapshot['schema'] = 'rescopebench-emergency-response-permission-snapshot/v7.4' |
| snapshot['schedule_version'] = 'emergency-response-permission-v7.4' |
| return snapshot |
|
|
| def _emergency_response_permission_successor_restore(self, snapshot): |
| if not isinstance(snapshot, dict) or snapshot.get('schema') != 'rescopebench-emergency-response-permission-snapshot/v7.4' or snapshot.get('schedule_version') != 'emergency-response-permission-v7.4': |
| raise ValueError('Unsupported Emergency Response v7.4 snapshot') |
| (activated, receipts, permission) = (snapshot.get(k) for k in ('activated_tasks', 'receipts', 'permission')) |
| if not isinstance(activated, list) or activated != list(DATA_TASK_IDS[:len(activated)]) or (not isinstance(receipts, list)) or (len(receipts) > 1024) or (not isinstance(permission, dict)) or (type(permission.get('responsibility_changed')) is not bool): |
| raise ValueError('Malformed Emergency Response v7.4 replay input') |
| if any((not isinstance(r, dict) or r.get('tool') not in DATA_VISIBLE_TOOL_NAMES or r.get('actor') != 'incident_dispatcher' or (not isinstance(r.get('arguments'), dict)) for r in receipts)): |
| raise ValueError('Malformed Emergency Response v7.4 receipt') |
| replay = type(self)(source=self._source) |
| try: |
| cursor = 0 |
| for task_id in activated: |
| drift = False if task_id == 'T09' and (not permission['responsibility_changed']) else None |
| replay.activate_task(task_id, evaluator_apply_scheduled_drift=drift) |
| while cursor < len(receipts) and receipts[cursor].get('task_id') == task_id: |
| receipt = receipts[cursor] |
| count = len(replay.receipts) |
| replay.dispatch(receipt['tool'], ext_deepcopy(receipt['arguments']), receipt['actor']) |
| if len(replay.receipts) != count + 1 or replay.receipts[-1] != receipt: |
| raise ValueError('Emergency Response v7.4 receipt replay diverged') |
| cursor += 1 |
| if cursor != len(receipts) or replay.snapshot() != snapshot: |
| raise ValueError('Emergency Response v7.4 canonical replay diverged') |
| finally: |
| replay.close() |
| self._restore_unchecked(snapshot) |
| if self.snapshot() != snapshot: |
| raise ValueError('Emergency Response v7.4 snapshot did not round trip') |
|
|
| def _emergency_dispatch_adapter_cost(self, tool, arguments): |
| if tool in DATA_CUSTOM_COSTS: |
| return DATA_CUSTOM_COSTS[tool] |
| if tool in DATA_RAW_LIST_TOOLS: |
| return 2 + fn__bounded_limit(arguments) |
| if tool in DATA_RAW_DETAIL_TOOLS: |
| return 1 |
| return DATA_WRITE_COSTS[tool] |
|
|
| def _emergency_response_permission_successor_dispatch_6(self, tool, arguments, actor='incident_dispatcher'): |
| if actor == 'incident_dispatcher' and tool not in DATA_VISIBLE_TOOL_NAMES_2: |
| return self._error(tool, 'TOOL_FORBIDDEN', 'tool is outside the public dispatcher slice') |
| if actor == 'incident_dispatcher' and tool in {'get_incident_detail', 'get_resource_unit_status', 'release_resource_assignment'} and (fn__validate_arguments(tool, arguments) is None): |
| if tool == 'get_incident_detail': |
| issued_incidents = {self.orders[order_id]['incident_id'] for order_id in self.order_observations} |
| if arguments['incident_id'] not in issued_incidents: |
| return self._charged_evidence_error(tool, arguments, 'INCIDENT_HANDLE_UNOBSERVED', 'read the dispatch order before using its incident handle') |
| elif tool == 'get_resource_unit_status' and arguments['resource_id'] not in self.issued_resource_handles: |
| return self._charged_evidence_error(tool, arguments, 'RESOURCE_HANDLE_UNOBSERVED', 'inspect a dispatch roster before using its resource handle') |
| elif tool == 'release_resource_assignment' and arguments['assignment_id'] not in self.issued_assignment_handles: |
| return self._charged_evidence_error(tool, arguments, 'ASSIGNMENT_HANDLE_UNOBSERVED', 'release only an assignment returned in the current episode') |
| result = self._emergency_response_permission_successor_dispatch_2(tool, arguments, actor) |
| if actor != 'incident_dispatcher' or result.get('content', {}).get('status') != 'success': |
| return result |
| if tool == 'get_incident_detail': |
| incident = result['content']['data']['incident'] |
| order = next((row for (order_id, row) in self.orders.items() if order_id in self.order_observations and row['incident_id'] == incident['incident_id'])) |
| self.authority_bindings[order['responsibility_domain']] = incident['lead_agency_id'] |
| elif tool == 'assign_resource_to_incident': |
| self.issued_assignment_handles.add(result['content']['data']['assignment_id']) |
| return result |
|
|
| def _emergency_response_permission_successor_init_4(self, source=CASE_DIR / 'raw', snapshot=None): |
| self._emergency_response_permission_successor_init_5(source=source) |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _emergency_dispatch_adapter_custom_read(self, tool, arguments): |
| if tool == 'search_dispatch_orders': |
| code = arguments['request_code'].strip().lower() |
| order_id = self.orders_by_code.get(code) |
| rows = [] if order_id is None else [{'request_code': self.orders[order_id]['request_code'], 'order_id': order_id, 'status': 'open'}] |
| return fn__tool_result(tool, {'total_count': len(rows), 'orders': rows}) |
| if tool == 'get_dispatch_order': |
| order = self.orders.get(arguments['order_id']) |
| if order is None: |
| return self._error(tool, 'DISPATCH_ORDER_NOT_FOUND', 'no active dispatch order matches order_id') |
| fields = ('request_code', 'order_id', 'incident_id', 'incident_type', 'mission_class', 'required_capability', 'mission', 'lead_agency_id', 'dispatch_priority', 'roster_id') |
| return fn__tool_result(tool, {'order': {field: order[field] for field in fields}}) |
| if tool == 'inspect_dispatch_roster': |
| candidates = self.rosters.get(arguments['roster_id']) |
| if candidates is None: |
| return self._error(tool, 'DISPATCH_ROSTER_NOT_FOUND', 'no active dispatch roster matches roster_id') |
| fields = ('resource_id', 'owning_agency_id', 'owning_agency_type', 'resource_type', 'capability_tags', 'status', 'current_incident_id', 'staging_location', 'fuel_or_supply_percent') |
| return fn__tool_result(tool, {'candidates': [{field: row[field] for field in fields} for row in candidates]}) |
| incident_type = arguments['incident_type'] |
| mission_class = arguments['mission_class'] |
| return fn__tool_result(tool, {'incident_type': incident_type, 'mission_class': mission_class, 'authorized_owner_type': self._policy(incident_type, mission_class), 'policy_version': self.policy_version}) |
|
|
| def _emergency_response_permission_successor_snapshot_2(self): |
| snapshot = self._emergency_response_permission_successor_snapshot_3() |
| snapshot['schema'] = 'rescopebench-emergency-response-permission-snapshot/v7.3' |
| snapshot['schedule_version'] = 'emergency-response-permission-v7.3' |
| snapshot['permission']['tool_surface_sha256'] = '93712b33cffcabf42d15afc865efe4b0f33b89f46c323071cdda22fe2b0b41b2' |
| return snapshot |
|
|
| def _emergency_response_permission_successor_init_5(self, source=CASE_DIR / 'raw', snapshot=None): |
| source = ext_Path(source).resolve() |
| self._stream_bootstrap = False |
| self._activated_tasks = [] |
| self.server = fn__isolated_server(source) |
| self.manager = self.server.get_state_manager() |
| self.manager.db._flush = lambda _entity_type: None |
| self.initial_budget = 74 |
| self.remaining = 74 |
| self.receipts = [] |
| self.applied_boundary_events = set() |
| self.policy_version = 'fixed' |
| self.active_task_id = '' |
| self.orders = {} |
| self.orders_by_code = {} |
| self.rosters = {} |
| self._active_receipt_start = 0 |
| self.responsibility_changed = False |
| self.order_observations: set[str] = set() |
| self.incident_observations: set[str] = set() |
| self.confirmed_authority_atoms: set[str] = set() |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _emergency_response_permission_successor_snapshot_3(self): |
| value = self._emergency_response_permission_successor_snapshot_4() |
| value['schema'] = 'rescopebench-emergency-response-permission-snapshot/v7' |
| value['schedule_version'] = 'emergency-response-permission-v7.1' |
| value['permission']['tool_surface_sha256'] = 'c6f98989b4f91cb55f32b9131cd9c858dc2fc4d3f21b7078227adfe8f508bd48' |
| value['permission']['authority_revalidation'] = dict(sorted(self.authority_revalidation.items())) |
| return value |
|
|
| def _emergency_response_permission_successor_snapshot_4(self): |
| value = self._emergency_response_permission_successor_snapshot_5() |
| value['schema'] = 'rescopebench-emergency-response-permission-snapshot/v6' |
| value['schedule_version'] = 'emergency-response-permission-v6' |
| value['permission']['tool_surface_sha256'] = 'fea5842206db73dbf129acb407adb35767f35e3e37e12c9bb2613ed3f56cb66e' |
| value['permission']['resolved_order_handles'] = sorted(self.resolved_order_handles) |
| value['permission']['issued_resource_handles'] = sorted(self.issued_resource_handles) |
| value['permission']['issued_assignment_handles'] = sorted(self.issued_assignment_handles) |
| value['permission']['authority_bindings'] = dict(sorted(self.authority_bindings.items())) |
| return value |
|
|
| def _emergency_response_permission_successor_snapshot_5(self): |
| value = self._emergency_response_permission_successor_snapshot_6() |
| value['schema'] = 'rescopebench-emergency-response-permission-snapshot/v4' |
| value['schedule_version'] = 'emergency-response-permission-v4' |
| value['permission']['roster_observations'] = sorted(self.roster_observations) |
| value['permission']['resource_observations'] = sorted(self.resource_observations) |
| return value |
|
|
| def _emergency_response_permission_successor_snapshot_6(self): |
| value = self._emergency_response_permission_successor_snapshot_7() |
| value['schema'] = 'rescopebench-emergency-response-permission-snapshot/v3' |
| value['schedule_version'] = 'emergency-response-permission-v3' |
| return value |
|
|
| def _emergency_response_permission_successor_snapshot_7(self): |
| value = self._persistent_emergency_dispatch_adapter_snapshot() |
| value['schema'] = 'rescopebench-emergency-response-permission-snapshot/v2' |
| value['permission'] = {'responsibility_changed': self.responsibility_changed, 'order_observations': sorted(self.order_observations), 'incident_observations': sorted(self.incident_observations), 'confirmed_authority_atoms': sorted(self.confirmed_authority_atoms), 'tool_surface_sha256': fn_digest(DATA_PROVIDER_TOOLS_2)} |
| return value |
|
|
| def _persistent_emergency_dispatch_adapter_snapshot(self): |
| value = self._emergency_dispatch_adapter_snapshot() |
| value.update({'schema': 'rescopebench-emergency-response-stream-snapshot/v1', 'activated_tasks': list(self._activated_tasks), 'active_receipt_start': self._active_receipt_start}) |
| return value |
|
|
| def _emergency_dispatch_adapter_snapshot(self): |
| return {'raw': mod_copy.deepcopy(self.manager.snapshot()), 'db_id_counters': mod_copy.deepcopy(self.manager.db._id_counters), 'remaining': self.remaining, 'receipts': mod_copy.deepcopy(self.receipts), 'applied_boundary_events': sorted(self.applied_boundary_events), 'policy_version': self.policy_version, 'active_task_id': self.active_task_id} |
|
|
