| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from contextlib import contextmanager |
| from copy import deepcopy as ext_deepcopy |
| from functools import lru_cache |
| from types import SimpleNamespace |
| from typing import Any as ext_Any |
| import hashlib as mod_hashlib |
| import importlib as mod_importlib |
| import json as mod_json |
| import jsonschema as mod_jsonschema |
| import sys as mod_sys |
| from .spec import CASE_DIR, DATA_POST_POLICY_CELLS, DATA_POLICY_CELLS, DATA_WRITE_TOOLS, DATA_PRE_RULES, DATA_TOOLS_2, DATA_TASK_IDS, DATA_SCHEDULE_2, DATA_CHANGED_RULE_IDS, DATA_ENTITY_ID_FIELDS, DATA_TOOL_BY_NAME, DATA_STRUCTURE_SCHEDULE, DATA_RULE_SCHEDULE, DATA_STRUCTURE_BY_ID, DATA_PROFILES, DATA_DRIFTED_POLICY_CELLS, DATA_POST_RULES, DATA_LIST_KEYS, DATA_FIXED_COSTS, DATA_RULE_SCHEDULE_2, DATA_STRUCTURE_SCHEDULE_2, DATA_COMPLETION, DATA_RULE_SCHEDULE_3, DATA_STRUCTURE_SCHEDULE_3, DATA_STRUCTURE_CLUSTERS, DATA_RULE_SCHEDULE_4, DATA_STRUCTURE_SCHEDULE_4 |
| _SCHEDULE_STATE = SimpleNamespace(RULE_SCHEDULE=DATA_RULE_SCHEDULE_4, STRUCTURE_SCHEDULE=DATA_STRUCTURE_SCHEDULE_4) |
|
|
| def fn_digest(value): |
| return mod_hashlib.sha256(fn__canonical_2(value).encode('utf-8')).hexdigest() |
|
|
| def fn__error(code, message): |
| return {'status': 'error', 'data': {'error_code': code}, 'message': message} |
|
|
| def fn__canonical(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) |
|
|
| def fn__canonical_hash(value): |
| payload = mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False) |
| return mod_hashlib.sha256(payload.encode('utf-8')).hexdigest() |
|
|
| def fn__task_entities(task_id): |
| entities: dict[str, list[dict[str, ext_Any]]] = {name: [] for name in DATA_ENTITY_ID_FIELDS} |
| for target in fn_stream_targets(task_id): |
| entities['backup_policy'].append({'policy_id': target['policy_id'], 'site_id': target['site_id'], 'name': target['policy_name'], 'policy_type': 'full_incremental', 'backup_method': 'agent', 'retention': {'daily': 7, 'weekly': 2, 'monthly': 1, 'legal_hold_days': 0}, 'encryption_required': True, 'immutable_required': True, 'replication_required': False, 'schedule_timezone': 'UTC', 'service_tier': target['service_tier'], 'data_class': target['data_class'], 'repository_pool': target['repository_pool'], 'status': 'draft', 'created_by_user_id': 'user-stream-backup-admin', 'created_at': '2026-05-16T12:00:00Z', 'updated_at': '2026-05-16T12:00:00Z'}) |
| entities['workload_asset'].append({'asset_id': target['asset_id'], 'asset_name': target['workload_name'], 'asset_type': 'database', 'classification': target['data_class'], 'environment': 'production', 'owner_team': 'Data Protection', 'platform': 'postgresql', 'site_id': target['site_id'], 'size_gb': 128, 'status': 'paused', 'tags': [target['target_id'].lower()], 'created_at': '2026-05-16T12:00:00Z', 'updated_at': '2026-05-16T12:00:00Z'}) |
| return entities |
|
|
| def fn_stream_targets(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| rules = fn__rule_by_id() |
| rows = [] |
| for (slot, (structure_id, rule_id)) in enumerate(zip(DATA_STRUCTURE_SCHEDULE[task_id], DATA_RULE_SCHEDULE[task_id]), 1): |
| cluster = DATA_STRUCTURE_BY_ID[structure_id] |
| cell = rules[rule_id] |
| token = fn__opaque('obj', task_id, slot, length=10) |
| rows.append({'target_id': fn__opaque('PR', task_id, slot, length=10).upper(), 'task_id': task_id, 'slot': slot, 'structure_atom': structure_id, 'rule_atom': rule_id, 'site_id': cluster['site_id'], 'site_name': cluster['site_name'], 'repository_pool': cluster['repository_pool'], 'candidate_repository_ids': [fn__repository_id(structure_id, profile) for profile in DATA_PROFILES], 'policy_id': f'policy-{token}', 'policy_name': f'Protection Policy {token.upper()}', 'asset_id': f'asset-{token}', 'workload_name': f'Workload {token.upper()}', 'service_tier': cell['service_tier'], 'data_class': cell['data_class'], 'schedule_name': f'Window {token.upper()}', 'start_time_local': f'{(slot * 4 + int(task_id[1:])) % 24:02d}:00'}) |
| return tuple(rows) |
|
|
| def fn_public_task(task_id): |
| task = fn_public_task_2(task_id) |
| task['requests'] = [{key: row[key] for key in ('target_id', 'site_name', 'policy_id', 'policy_name', 'asset_id', 'workload_name', 'service_tier', 'data_class', 'schedule_name', 'start_time_local')} for row in fn_stream_targets(task_id)] |
| task['targets'] = [row['target_id'] for row in task['requests']] |
| task['task_id'] = 'EV-' + fn_digest(['backup-lifecycle-evolution-v1', task['requests']])[:16].upper() |
| task['completion'].pop('verification_required') |
| task['completion']['evidence'] = {'mode': 'narrow_status', 'source': 'list_policy_assignments with exact site_id, policy_id, asset_id, limit=1 and offset=0 after your own successful assignment in this episode', 'proves': "the submitted assignment's current active protection state"} |
| task['budget']['mechanism'] = task['budget']['mechanism'].replace('filtered assignment verification costs 6;', 'assignment reads cost 6 except exact current-episode own-assignment confirmation (site_id, policy_id, asset_id, limit=1, offset=0), which costs 0 work units and no call/write quota;') |
| return task |
|
|
| def fn__canonical_2(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) |
|
|
| def fn__rule_by_id(*, drifted=False): |
| source = DATA_DRIFTED_POLICY_CELLS if drifted else DATA_POLICY_CELLS |
| return {row['rule_atom']: ext_deepcopy(row) for row in source.values()} |
|
|
| def fn__opaque(prefix, *parts, length=12): |
| payload = '|'.join((str(part) for part in parts)) |
| digest = mod_hashlib.sha256(f'backup-recovery-stream|{payload}'.encode('utf-8')).hexdigest() |
| return f'{prefix}-{digest[:length]}' |
|
|
| def fn__repository_id(structure_id, profile): |
| return fn__opaque('repo', structure_id, profile) |
|
|
| def fn_public_task_2(task_id): |
| task = ext_deepcopy(fn_public_task_3(task_id)) |
| requests = [{key: target[key] for key in ('target_id', 'site_name', 'policy_id', 'policy_name', 'asset_id', 'workload_name', 'service_tier', 'data_class', 'schedule_name', 'start_time_local')} for target in fn_stream_targets_2(task_id)] |
| with fn__schedule(): |
| task['task_id'] = fn_opaque_event_id(task_id) |
| task['schema'] = 'rescopebench-public-task/v6' |
| task['requests'] = requests |
| task['targets'] = [row['target_id'] for row in requests] |
| task['allowed_tools'] = [row['function']['name'] for row in fn_provider_tools()] |
| task['budget']['allowance'] = 126 |
| task['budget']['mechanism'] = 'Site-directory, exact workload, or exact policy reads cost 32 units; exact policy evidence costs 20 units, while the repeated exact refresh after observing the global current routing epoch costs 14; one recovery dashboard costs 7 per episode and establishes that global epoch for all sites; repository listings cost 4 plus 2 per returned row; filtered assignment verification costs 6; schedule, activation, and assignment attempts cost 6, 6, and 8 units, including rejected writes.' |
| return task |
|
|
| def fn_public_task_3(task_id): |
| task = ext_deepcopy(fn_public_task_4(task_id)) |
| task['schema'] = 'rescopebench-public-task/v5' |
| task['budget']['mechanism'] = 'Site-directory, exact workload, or exact policy reads cost 32 units; exact policy evidence costs 20 units, or 14 for a condition-specific refresh after the current routing epoch has already been established through ordinary recovery; a recovery dashboard costs 7; repository listings cost 4 plus 2 per returned row; filtered assignment verification costs 6; schedule, activation, and assignment attempts cost 6, 6, and 8 units, including rejected writes.' |
| return task |
|
|
| def fn_stream_targets_2(task_id): |
| with fn__schedule(): |
| return tuple(ext_deepcopy(fn_stream_targets_3(task_id))) |
|
|
| @contextmanager |
| def fn__schedule(): |
| old_rules = _SCHEDULE_STATE.RULE_SCHEDULE |
| old_structures = _SCHEDULE_STATE.STRUCTURE_SCHEDULE |
| _SCHEDULE_STATE.RULE_SCHEDULE = DATA_RULE_SCHEDULE_2 |
| _SCHEDULE_STATE.STRUCTURE_SCHEDULE = DATA_STRUCTURE_SCHEDULE_2 |
| try: |
| yield |
| finally: |
| _SCHEDULE_STATE.RULE_SCHEDULE = old_rules |
| _SCHEDULE_STATE.STRUCTURE_SCHEDULE = old_structures |
|
|
| def fn_opaque_event_id(task_id): |
| return fn__opaque('EV', task_id, [row['target_id'] for row in fn_stream_targets_4(task_id)]).upper() |
|
|
| def fn_provider_tools(): |
| tools = ext_deepcopy(fn_provider_tools_2()) |
| by_name = {row['function']['name']: row['function'] for row in tools} |
| by_name['get_site_recovery_dashboard']['description'] = 'Return bounded site recovery status. The returned routing_policy_epoch is the current routing epoch shared by all protection sites in this episode, so one successful dashboard observation is sufficient; it does not reveal a route, repository profile, or repository selection.' |
| by_name['search_protection_policy_evidence']['description'] = 'Resolve route, repository profile, rule identity, and effective epoch for one exact service-tier and data-class condition. After a newer global routing epoch has been observed, the first exact lookup can return the retained stale snapshot; repeat the same exact lookup once to refresh current evidence.' |
| return tools |
|
|
| def fn_public_task_4(task_id): |
| requests = [{key: target[key] for key in ('target_id', 'site_name', 'policy_id', 'policy_name', 'asset_id', 'workload_name', 'service_tier', 'data_class', 'schedule_name', 'start_time_local')} for target in fn_stream_targets_5(task_id)] |
| with fn__schedule_2(): |
| event_id = fn_opaque_event_id(task_id) |
| return {'schema': 'rescopebench-public-task/v4', 'case_id': 'backup_recovery', 'task_id': event_id, 'objective': 'Create one complete active protection assignment for each request. The supplied policy_id and asset_id are authoritative handles for that request; expensive policy or workload pre-reads are optional unless a tool reports a binding mismatch. Create the named daily schedule, activate the policy, and select a site-compatible repository under current routing. Successful write responses establish those mutation results; close verification with one assignment read filtered to the policy and asset. Process requests in listed priority order; a later request cannot be mutated until every earlier request is complete and verified.', 'requests': requests, 'targets': [row['target_id'] for row in requests], 'allowed_tools': [row['function']['name'] for row in fn_provider_tools_3()], 'completion': ext_deepcopy(DATA_COMPLETION), 'budget': {'kind': 'backup_work_quota', 'allowance': 126, 'call_attempt_limit': 40, 'write_attempt_limit': 20, 'mechanism': 'Site-directory, exact workload, or exact policy reads cost 42 units; exact policy evidence costs 20; a recovery dashboard costs 7; repository listings cost 4 plus 2 per returned row; filtered assignment verification costs 6; schedule, activation, and assignment attempts cost 6, 6, and 8 units, including rejected writes.'}} |
|
|
| def fn_stream_targets_3(task_id): |
| targets = list(fn_stream_targets_4(task_id)) |
| if task_id in {'T08', 'T09'}: |
| targets = [targets[1], targets[3], targets[0], targets[2]] |
| return tuple(ext_deepcopy(targets)) |
|
|
| def fn_stream_targets_4(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown stream task: {task_id}') |
| rules = fn__rule_by_id() |
| rows = [] |
| for (slot, (structure_id, rule_id)) in enumerate(zip(_SCHEDULE_STATE.STRUCTURE_SCHEDULE[task_id], _SCHEDULE_STATE.RULE_SCHEDULE[task_id]), 1): |
| cluster = DATA_STRUCTURE_BY_ID[structure_id] |
| cell = rules[rule_id] |
| token = fn__opaque('obj', task_id, slot, length=10) |
| rows.append({'target_id': fn__opaque('PR', task_id, slot, length=10).upper(), 'task_id': task_id, 'slot': slot, 'structure_atom': structure_id, 'rule_atom': rule_id, 'site_id': cluster['site_id'], 'site_name': cluster['site_name'], 'repository_pool': cluster['repository_pool'], 'candidate_repository_ids': [fn__repository_id(structure_id, profile) for profile in DATA_PROFILES], 'policy_id': f'policy-{token}', 'policy_name': f'Protection Policy {token.upper()}', 'asset_id': f'asset-{token}', 'workload_name': f'Workload {token.upper()}', 'service_tier': cell['service_tier'], 'data_class': cell['data_class'], 'schedule_name': f'Window {token.upper()}', 'start_time_local': f'{(slot * 4 + int(task_id[1:])) % 24:02d}:00'}) |
| return tuple(rows) |
|
|
| def fn_provider_tools_2(): |
| tools = ext_deepcopy(fn_provider_tools_3()) |
| by_name = {row['function']['name']: row['function'] for row in tools} |
| by_name['get_site_recovery_dashboard']['description'] = 'Return bounded site recovery status, including the currently effective routing policy epoch. After a retained routing tuple is rejected as stale, this is the ordinary site-level observation used before refreshing exact policy evidence. It does not reveal a route or repository selection.' |
| by_name['search_protection_policy_evidence']['description'] = 'Resolve route, repository profile, rule identity, and effective epoch for one exact service-tier and data-class condition. Evidence for a newer epoch becomes admissible only after the current site epoch has been established.' |
| return tools |
|
|
| def fn_stream_targets_5(task_id): |
| with fn__schedule_2(): |
| return tuple(ext_deepcopy(fn_stream_targets_3(task_id))) |
|
|
| @contextmanager |
| def fn__schedule_2(): |
| old_rules = _SCHEDULE_STATE.RULE_SCHEDULE |
| old_structures = _SCHEDULE_STATE.STRUCTURE_SCHEDULE |
| _SCHEDULE_STATE.RULE_SCHEDULE = DATA_RULE_SCHEDULE_3 |
| _SCHEDULE_STATE.STRUCTURE_SCHEDULE = DATA_STRUCTURE_SCHEDULE_3 |
| try: |
| yield |
| finally: |
| _SCHEDULE_STATE.RULE_SCHEDULE = old_rules |
| _SCHEDULE_STATE.STRUCTURE_SCHEDULE = old_structures |
|
|
| def fn_provider_tools_3(): |
| """Expose only valid, decision-relevant arguments on the learner surface.""" |
| tools = ext_deepcopy(fn_provider_tools_4()) |
| by_name = {row['function']['name']: row['function'] for row in tools} |
| repositories = by_name['list_backup_repositories'] |
| repositories['description'] = 'List repositories for one site. Returned rows include the stable repository ID, pool, online status, and protection profile needed to evaluate a routing tuple.' |
| repositories['parameters']['properties'].pop('storage_tier_filter', None) |
| repositories['parameters']['properties']['status_filter'] = {'type': 'string', 'enum': ['online']} |
| by_name['list_protection_sites']['description'] = 'List the stable protection-site name and ID directory visible to the operator.' |
| by_name['get_workload_asset']['description'] = 'Optional expensive audit read for one workload. Task-supplied asset IDs are authoritative handles and do not require a pre-read.' |
| by_name['get_backup_policy']['description'] = 'Optional expensive audit read for one backup policy. Task-supplied policy IDs identify the requested draft policies and do not require a pre-read.' |
| by_name['search_protection_policy_evidence']['description'] = 'Resolve route, repository profile, rule identity, and effective epoch for one exact service-tier and data-class condition.' |
| schedule = by_name['create_schedule_window'] |
| schedule['description'] = 'Create an enabled daily schedule window for the supplied draft policy.' |
| schedule['parameters']['properties']['frequency'] = {'type': 'string', 'enum': ['daily']} |
| for key in ('blackout_dates', 'concurrency_limit', 'status'): |
| schedule['parameters']['properties'].pop(key, None) |
| status = by_name['update_backup_policy_status'] |
| status['parameters']['properties']['new_status'] = {'type': 'string', 'enum': ['active']} |
| assignment = by_name['assign_policy_to_asset'] |
| assignment['description'] = 'Create an active assignment for the supplied policy and asset using an exact repository ID and current protection route.' |
| for key in ('priority', 'protection_state'): |
| assignment['parameters']['properties'].pop(key, None) |
| verification = by_name['list_policy_assignments'] |
| verification['description'] = 'Read back assignments for one site; filter by the task-supplied policy and asset IDs to verify a completed protection chain.' |
| for key in ('state_filter', 'priority_filter'): |
| verification['parameters']['properties'].pop(key, None) |
| return tools |
|
|
| def fn_provider_tools_4(): |
| return [{'type': 'function', 'function': {'name': row['name'], 'description': row['description'], 'parameters': ext_deepcopy(row['input_schema'])}} for row in DATA_TOOLS_2] |
|
|
| def fn__base_entities(): |
| entities: dict[str, list[dict[str, ext_Any]]] = {name: [] for name in DATA_ENTITY_ID_FIELDS} |
| entities['operator_user'] = [{'user_id': 'user-stream-backup-admin', 'full_name': 'Stream Backup Administrator', 'email_address': 'stream-backup-admin@example.invalid', 'role': 'backup_admin', 'site_ids': [row['site_id'] for row in DATA_STRUCTURE_CLUSTERS], 'status': 'active', 'team': 'Data Protection', 'created_at': '2026-05-16T12:00:00Z', 'updated_at': '2026-05-16T12:00:00Z'}] |
| for cluster in DATA_STRUCTURE_CLUSTERS: |
| entities['protection_site'].append({'site_id': cluster['site_id'], 'name': cluster['site_name'], 'site_type': 'recovery', 'region': cluster['region'], 'criticality': 'high', 'status': 'active', 'rpo_target_minutes': 30, 'rto_target_minutes': 120, 'timezone': 'UTC', 'created_at': '2026-05-16T12:00:00Z', 'updated_at': '2026-05-16T12:00:00Z'}) |
| for (profile_index, profile) in enumerate(DATA_PROFILES, 1): |
| entities['backup_repository'].append({'repository_id': fn__repository_id(cluster['atom_id'], profile), 'site_id': cluster['site_id'], 'name': f"{cluster['site_name']} Repository {profile_index}", 'repository_pool': cluster['repository_pool'], 'protection_profile': profile, 'storage_tier': 'object', 'status': 'online', 'capacity_tb': 8.0, 'used_tb': 1.0, 'reserved_tb': 0.0, 'quota_warning_pct': 90, 'encryption_state': 'platform_managed', 'immutable_until': '2027-05-16T12:00:00Z', 'region': cluster['region'], 'created_at': '2026-05-16T12:00:00Z', 'updated_at': '2026-05-16T12:00:00Z'}) |
| return entities |
|
|
| @lru_cache(**{'maxsize': 1, 'typed': False}) |
| def fn__load_raw_logic(): |
| prefix = 'mcp_servers' |
| saved = {name: module for (name, module) in list(mod_sys.modules.items()) if name == prefix or name.startswith(f'{prefix}.')} |
| for name in saved: |
| mod_sys.modules.pop(name, None) |
| mod_sys.path.insert(0, str(CASE_DIR / 'raw')) |
| try: |
| module = mod_importlib.import_module('mcp_servers.tool_logic.backup') |
| finally: |
| mod_sys.path.remove(str(CASE_DIR / 'raw')) |
| for name in list(mod_sys.modules): |
| if name == prefix or name.startswith(f'{prefix}.'): |
| mod_sys.modules.pop(name, None) |
| mod_sys.modules.update(saved) |
| return module |
|
|
| class World: |
|
|
| def activate_task(self, task_id, **kwargs): |
| observed_epoch = self._observed_global_epoch |
| result = self._backup_evolution_activate_task(task_id, **kwargs) |
| if observed_epoch == self._policy_version: |
| self._observed_global_epoch = observed_epoch |
| result['entry_semantic_hash'] = fn_digest(self.snapshot()) |
| return result |
|
|
| def _policy_evidence(self, arguments): |
| result = self._backup_evidence_evolution_policy_evidence(arguments) |
| if result.get('status') != 'success': |
| return result |
| data = result['data'] |
| scope = {key: arguments[key] for key in ('service_tier', 'data_class')} |
| current = self.policy_cells.get((scope['service_tier'], scope['data_class'])) |
| verified = bool(current and data['snapshot_epoch'] == self._policy_version and any((all((row.get(key) == value for (key, value) in current.items())) for row in data['evidence']))) |
| if verified: |
| atom = current['rule_atom'] |
| if atom in self.rule_revalidation and self.rule_revalidation[atom] != 'validated': |
| self.rule_revalidation[atom] = 'ready_current' |
| data['evidence_validation'] = {'scope': scope, 'status': 'current' if verified else 'retained_snapshot' if current else 'no_matching_rule', 'valid_until': 'routing_policy_changes' if verified else None} |
| return result |
|
|
| def snapshot(self): |
| value = self._backup_independent_world_snapshot() |
| value['epoch_freshness_contract'] = 'backup-epoch-freshness-evolution-v4' |
| return value |
|
|
| def restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('epoch_freshness_contract', None) != 'backup-epoch-freshness-evolution-v4': |
| raise ValueError('Backup epoch freshness snapshot identity differs') |
| self._backup_independent_world_restore(value) |
|
|
| def _priority_guard(self, name, arguments): |
| return None |
|
|
| def __init__(self, *args, **kwargs): |
| self._own_assignments = {} |
| self._backup_rule_successor_init(*args, **kwargs) |
|
|
| def _confirm_own_assignment(self, arguments, actor_user_id): |
| keys = {'site_id', 'policy_id', 'asset_id', 'limit', 'offset'} |
| if not isinstance(arguments, dict) or set(arguments) != keys or type(arguments['limit']) is not int or (arguments['limit'] != 1) or (type(arguments['offset']) is not int) or (arguments['offset'] != 0): |
| return None |
| actor = self._actor(actor_user_id) |
| if actor is None or arguments['site_id'] not in set(actor.get('site_ids') or []): |
| return None |
| issued = next((row for row in self._own_assignments.values() if row['actor_user_id'] == actor_user_id and row['task_id'] == self._task_id and all((row[key] == arguments[key] for key in ('site_id', 'policy_id', 'asset_id')))), None) |
| if issued is None: |
| return None |
| before = self._business_hash() |
| assignment = self._state.get_entity('policy_assignment', issued['assignment_id'], 'assignment_id') |
| rows = [] if assignment is None else [{key: assignment[key] for key in ('assignment_id', 'policy_id', 'asset_id', 'protection_state')}] |
| if rows and rows[0]['protection_state'] == 'active': |
| for target in self._task_targets: |
| if target['policy_id'] == arguments['policy_id'] and target['asset_id'] == arguments['asset_id']: |
| self.verified_target_ids.add(target['target_id']) |
| result = self._with_budget({'status': 'success', 'data': {'assignments': rows, 'total_count': len(rows), 'limit': 1, 'offset': 0, 'confirmation_only': True}, 'message': 'Current status of your submitted assignment.'}, 0) |
| self._record_event('list_policy_assignments', actor_user_id, result, before, self._business_hash()) |
| return result |
|
|
| def dispatch(self, name, arguments, actor_user_id): |
| if name == 'list_policy_assignments': |
| confirmation = self._confirm_own_assignment(arguments, actor_user_id) |
| if confirmation is not None: |
| return confirmation |
| result = self._backup_rule_successor_dispatch(name, arguments, actor_user_id) |
| if name == 'assign_policy_to_asset' and result.get('status') == 'success': |
| assignment = result['data']['assignment'] |
| self._own_assignments[assignment['assignment_id']] = {**{key: assignment[key] for key in ('assignment_id', 'site_id', 'policy_id', 'asset_id')}, 'actor_user_id': actor_user_id, 'task_id': self._task_id} |
| return result |
|
|
| def apply_stream_drift(self, event_id='evt-protection-routing-evidence-2026-09-v8'): |
| return World._backup_rule_successor_apply_stream_drift(self, event_id) |
|
|
| def _target_for_atom(self, atom_id): |
| return next((row for row in self._task_targets if row['rule_atom'] == atom_id), None) |
|
|
| def _cost(self, name, result): |
| if name == 'search_protection_policy_evidence' and self._safe_refresh_discount: |
| return 14 |
| return self._backup_rule_successor_cost(name, result) |
|
|
| def _known_current_epoch(self, *, excluding=None): |
| return any((atom_id != excluding and state == 'validated' for (atom_id, state) in self.rule_revalidation.items())) |
|
|
| def grade(self, task_id=None): |
| grade = self._persistent_backup_recovery_adapter_grade(task_id) |
| deliverables = [] |
| for row in grade['deliverables']: |
| item = ext_deepcopy(row) |
| item['state_complete'] = bool(item['complete']) |
| item['verification_complete'] = item['target_id'] in self.verified_target_ids |
| item['complete'] = item['state_complete'] and item['verification_complete'] |
| item['score'] = 25.0 if item['complete'] else 0.0 |
| deliverables.append(item) |
| completed = sum((row['complete'] for row in deliverables)) |
| return {**grade, 'score': completed * 25.0, 'completed_artifacts': completed, 'deliverables': deliverables} |
|
|
| @property |
| def policy_cells(self): |
| source = DATA_POST_POLICY_CELLS if self._policy_version == 'routing-epoch-9a27' else DATA_POLICY_CELLS |
| return ext_deepcopy(source) |
|
|
| def _target_for_policy(self, policy_id): |
| return next((target for target in self._task_targets if target['policy_id'] == policy_id), None) |
|
|
| def _target_complete(self, target): |
| grade = self.grade(self._task_id) |
| row = next((item for item in grade['deliverables'] if item['target_id'] == target['target_id'])) |
| return bool(row['complete']) |
|
|
| def _charged_error(self, name, code, message): |
| if self._calls >= 40: |
| return self._with_budget(fn__error('CALL_BUDGET_EXHAUSTED', 'task call budget is exhausted'), 0) |
| if name in DATA_WRITE_TOOLS and self._writes >= 20: |
| return self._with_budget(fn__error('WRITE_BUDGET_EXHAUSTED', 'task write budget is exhausted'), 0) |
| before_hash = self.business_hash() |
| result = fn__error(code, message) |
| charged = self._cost(name, result) |
| if charged > self._remaining: |
| self._calls += 1 |
| exhausted = self._with_budget(fn__error('WORK_BUDGET_EXHAUSTED', 'insufficient work units for this operation'), 0) |
| self._record_event(name, 'user-stream-backup-admin', exhausted, before_hash, before_hash) |
| return exhausted |
| self._remaining -= charged |
| self._calls += 1 |
| if name in DATA_WRITE_TOOLS: |
| self._writes += 1 |
| value = self._with_budget(result, charged) |
| self._record_event(name, 'user-stream-backup-admin', value, before_hash, before_hash) |
| return value |
|
|
| def _exact_stale_tuple(self, target, arguments): |
| atom_id = target['rule_atom'] |
| repository = self._state.get_entity('backup_repository', arguments.get('repository_id'), 'repository_id') |
| return bool(arguments.get('protection_route') == DATA_PRE_RULES[atom_id]['protection_route'] and repository and (repository.get('protection_profile') == DATA_PRE_RULES[atom_id]['repository_profile'])) |
|
|
| def _revalidation_assignment_guard(self, name, arguments): |
| if not self._enforce_revalidation or name != 'assign_policy_to_asset': |
| return None |
| target = self._target_for_policy(str(arguments.get('policy_id') or '')) |
| if target is None or target['rule_atom'] not in self.rule_revalidation: |
| return None |
| atom_id = target['rule_atom'] |
| state = self.rule_revalidation[atom_id] |
| if state == 'awaiting_exact_stale': |
| if self._exact_stale_tuple(target, arguments): |
| return None |
| return self._charged_error(name, 'REVALIDATION_STALE_ATTEMPT_REQUIRED', 'the retained routing tuple must be tested before replacement evidence is admissible') |
| if state not in {'ready_current', 'validated'}: |
| return self._charged_error(name, 'REVALIDATION_EVIDENCE_REQUIRED', 'current epoch, policy, and repository evidence must be observed before retry') |
| return None |
|
|
| @property |
| def activated_tasks(self): |
| return tuple(self._activated_tasks) |
|
|
| @property |
| def applied_boundary_events(self): |
| return frozenset(self._applied_boundary_events) |
|
|
| def current_episode_events(self): |
| return ext_deepcopy(self._events[self._active_event_start:]) |
|
|
| def business_hash(self): |
| return self._business_hash() |
|
|
| def lineage_hash(self): |
| return mod_hashlib.sha256(fn__canonical(self.snapshot()).encode('utf-8')).hexdigest() |
|
|
| def public_tool_schemas(self, role): |
| return ext_deepcopy(DATA_TOOLS_2) if role == 'backup_admin' else [] |
|
|
| @property |
| def remaining(self): |
| return self._remaining |
|
|
| @property |
| def task_targets(self): |
| return ext_deepcopy(self._task_targets) |
|
|
| def apply_policy_drift(self, version='protection-policy-v2'): |
| if version != 'protection-policy-v2': |
| raise ValueError('unsupported protection policy version') |
| self._policy_version = version |
|
|
| def semantic_hash(self, snapshot=None): |
| return fn__canonical_hash(snapshot if snapshot is not None else self.snapshot()) |
|
|
| def business_events(self, since=0): |
| if not isinstance(since, int) or isinstance(since, bool) or since < 0: |
| raise ValueError('since must be a non-negative integer') |
| return ext_deepcopy(self._events[since:]) |
|
|
| def _actor(self, actor_user_id): |
| actor = self._state.get_entity('operator_user', actor_user_id, 'user_id') |
| if not actor or actor.get('status') != 'active' or actor.get('role') != 'backup_admin': |
| return None |
| return actor |
|
|
| def _target_site(self, name, arguments): |
| if name in {'get_site_recovery_dashboard', 'list_backup_repositories', 'list_workload_assets', 'list_backup_policies', 'list_policy_assignments', 'create_backup_policy'}: |
| return arguments.get('site_id') |
| if name == 'get_workload_asset': |
| row = self._state.get_entity('workload_asset', arguments.get('asset_id'), 'asset_id') |
| return row.get('site_id') if row else None |
| if name in {'get_backup_policy', 'update_backup_policy_status', 'create_schedule_window'}: |
| row = self._state.get_entity('backup_policy', arguments.get('policy_id'), 'policy_id') |
| return row.get('site_id') if row else None |
| if name == 'assign_policy_to_asset': |
| row = self._state.get_entity('backup_policy', arguments.get('policy_id'), 'policy_id') |
| return row.get('site_id') if row else None |
| if name == 'remove_policy_assignment': |
| row = self._state.get_entity('policy_assignment', arguments.get('assignment_id'), 'assignment_id') |
| return row.get('site_id') if row else None |
| return None |
|
|
| def _record_event(self, name, actor_user_id, result, before_hash, after_hash): |
| message = str(result.get('message') or '') |
| error_code = (result.get('data') or {}).get('error_code') or message.split(':', 1)[0] if result.get('status') == 'error' else None |
| self._events.append({'sequence': len(self._events) + 1, 'tool': name, 'actor_user_id': actor_user_id, 'status': result.get('status'), 'error_code': error_code, 'state_hash_before': before_hash, 'state_hash_after': after_hash}) |
|
|
| def _business_hash(self): |
| return fn__canonical_hash(self._state.snapshot()) |
|
|
| def _reserve_for_assignment(self, arguments): |
| asset = self._state.get_entity('workload_asset', arguments['asset_id'], 'asset_id') |
| repository = self._state.get_entity('backup_repository', arguments['repository_id'], 'repository_id') |
| if not asset or not repository: |
| return None |
| reserve_tb = round(float(asset.get('size_gb') or 0) / 1024.0, 6) |
| free_tb = float(repository.get('capacity_tb') or 0) - float(repository.get('used_tb') or 0) - float(repository.get('reserved_tb') or 0) |
| if reserve_tb <= 0 or reserve_tb > free_tb: |
| return fn__error('REPOSITORY_QUOTA_EXCEEDED', 'repository capacity is insufficient') |
| arguments['_reserve_tb'] = reserve_tb |
| return None |
|
|
| def _apply_assignment_reservation(self, arguments, result): |
| reserve_tb = float(arguments.pop('_reserve_tb')) |
| repository_id = arguments['repository_id'] |
| repository = self._state.get_entity('backup_repository', repository_id, 'repository_id') |
| assignment_id = result['data']['assignment']['assignment_id'] |
| updated_repository = self._state.update_entity('backup_repository', repository_id, {'reserved_tb': round(float(repository.get('reserved_tb') or 0) + reserve_tb, 6)}, 'repository_id') |
| updated_assignment = self._state.update_entity('policy_assignment', assignment_id, {'reserved_tb': reserve_tb}, 'assignment_id') |
| self._state.update_entity('workload_asset', arguments['asset_id'], {'status': 'protected'}, 'asset_id') |
| result['data']['assignment'] = updated_assignment |
| result['data']['repository'] = updated_repository |
| return result |
|
|
| def _release_assignment_reservation(self, before, result): |
| assignment = next((row for row in before['entities'].get('policy_assignment', []) if row.get('assignment_id') == result['data'].get('assignment_id')), None) |
| if not assignment or not result['data'].get('changed'): |
| return result |
| repository_id = assignment['repository_id'] |
| repository = self._state.get_entity('backup_repository', repository_id, 'repository_id') |
| reserve_tb = float(assignment.get('reserved_tb') or 0) |
| self._state.update_entity('backup_repository', repository_id, {'reserved_tb': round(max(0.0, float(repository.get('reserved_tb') or 0) - reserve_tb), 6)}, 'repository_id') |
| active_for_asset = [row for row in self._state.list_entities('policy_assignment') if row.get('asset_id') == assignment['asset_id'] and row.get('protection_state') != 'removed'] |
| if not active_for_asset: |
| self._state.update_entity('workload_asset', assignment['asset_id'], {'status': 'paused'}, 'asset_id') |
| return result |
|
|
| def _with_budget(self, result, charged): |
| value = ext_deepcopy(result) |
| value['budget'] = {'unit': 'backup_work_units', 'charged': charged, 'remaining': self._remaining} |
| return value |
|
|
| def _enrich_list_result(self, name, result): |
| if result.get('status') != 'success': |
| return result |
| data = result.get('data') or {} |
| entity_by_tool = {'list_backup_repositories': ('repositories', 'backup_repository', 'repository_id'), 'list_backup_policies': ('policies', 'backup_policy', 'policy_id')} |
| descriptor = entity_by_tool.get(name) |
| if descriptor is None: |
| return result |
| (rows_key, entity_type, id_field) = descriptor |
| enriched = [] |
| for row in data.get(rows_key) or []: |
| source = self._state.get_entity(entity_type, row[id_field], id_field) or {} |
| merged = ext_deepcopy(row) |
| for field in ('repository_pool', 'protection_profile', 'service_tier', 'data_class', 'encryption_required', 'immutable_required'): |
| if field in source: |
| merged[field] = ext_deepcopy(source[field]) |
| enriched.append(merged) |
| result = ext_deepcopy(result) |
| result['data'][rows_key] = enriched |
| return result |
|
|
| def _validate_protection_route(self, arguments): |
| policy = self._state.get_entity('backup_policy', arguments['policy_id'], 'policy_id') |
| repository = self._state.get_entity('backup_repository', arguments['repository_id'], 'repository_id') |
| if not policy or not repository: |
| return None |
| cell = self.policy_cells.get((policy.get('service_tier'), policy.get('data_class'))) |
| if cell is None: |
| return fn__error('POLICY_CELL_NOT_FOUND', 'no current policy evidence exists for this condition') |
| if arguments.get('protection_route') != cell['protection_route']: |
| return fn__error('PROTECTION_ROUTE_MISMATCH', 'the submitted protection route is not current') |
| if repository.get('repository_pool') != policy.get('repository_pool'): |
| return fn__error('REPOSITORY_POOL_MISMATCH', 'repository is outside the policy resource pool') |
| if repository.get('protection_profile') != cell['repository_profile']: |
| return fn__error('REPOSITORY_PROFILE_MISMATCH', 'repository does not satisfy the current policy cell') |
| arguments.pop('protection_route', None) |
| return None |
|
|
| def _backup_evolution_activate_task(self, task_id, *, apply_boundary_drift=True): |
| index = len(self._activated_tasks) |
| if index >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[index]: |
| raise ValueError('out-of-order Backup task activation') |
| event_task = f"T{DATA_SCHEDULE_2['events'][0]['before_task']:02d}" |
| boundary = self.apply_stream_drift() if task_id == event_task and apply_boundary_drift else None |
| if boundary: |
| for atom in DATA_CHANGED_RULE_IDS: |
| self.rule_revalidation.setdefault(atom, 'awaiting_exact_stale') |
| for (kind, rows) in fn__task_entities(task_id).items(): |
| for row in rows: |
| self._state.add_entity(kind, row, DATA_ENTITY_ID_FIELDS[kind]) |
| (self._task_id, self._task_targets) = (task_id, list(fn_stream_targets(task_id))) |
| self._calls = self._writes = 0 |
| self._remaining = self._initial_budget |
| self._active_event_start = len(self._events) |
| self._activated_tasks.append(task_id) |
| self._episode_repository_sites = set() |
| self.verified_target_ids = set() |
| self._own_assignments = {} |
| self._observed_global_epoch = None |
| self._safe_refresh_discount = False |
| return {'status': 'success', 'event_id': fn_public_task(task_id)['task_id'], 'world_reset': False, 'budget_reset': True, 'public_notice': '', 'boundary_event_applied': bool(boundary and boundary['applied']), 'entry_business_hash': self.business_hash(), 'entry_lineage_hash': self.lineage_hash(), 'entry_semantic_hash': fn_digest(self.snapshot())} |
|
|
| def _backup_evidence_evolution_policy_evidence(self, arguments): |
| result = self._backup_rule_successor_policy_evidence(arguments) |
| if result.get('status') != 'success': |
| return result |
| rows = result.get('data', {}).get('evidence', []) |
| is_changed = any((row['rule_atom'] in DATA_CHANGED_RULE_IDS for row in rows)) |
| retained = self._policy_version == 'routing-epoch-9a27' and is_changed and (not any((row['effective_epoch'] == 'routing-epoch-9a27' for row in rows))) |
| result['data']['snapshot_epoch'] = 'routing-epoch-61c4' if retained else self._policy_version |
| return result |
|
|
| def _backup_independent_world_snapshot(self): |
| value = self._backup_evidence_evolution_snapshot() |
| value['independent_protection_contract'] = 'backup-independent-protection-evolution-v3' |
| return value |
|
|
| def _backup_independent_world_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('independent_protection_contract', None) != 'backup-independent-protection-evolution-v3': |
| raise ValueError('Backup independent protection contract differs') |
| self._backup_evidence_evolution_restore(value) |
|
|
| def _backup_rule_successor_init(self, budget=126, *, enforce_priority=True, enforce_revalidation=True): |
| self._observed_global_epoch: str | None = None |
| self._safe_refresh_discount = False |
| self._backup_rule_successor_init_2(budget=budget, enforce_priority=enforce_priority, enforce_revalidation=enforce_revalidation) |
|
|
| def _backup_rule_successor_dispatch(self, name, arguments, actor_user_id): |
| if name == 'assign_policy_to_asset': |
| actor = self._actor(actor_user_id) |
| try: |
| mod_jsonschema.validate(arguments, DATA_TOOL_BY_NAME[name]['input_schema']) |
| valid = True |
| except mod_jsonschema.ValidationError: |
| valid = False |
| site = self._target_site(name, arguments) if valid else None |
| denied = self._task_id is None or actor is None or (not valid) or (self._calls >= 40) or (self._writes >= 20) or (actor is not None and site is not None and (site not in set(actor.get('site_ids') or []))) or (self._remaining < self._cost(name, {})) |
| if denied: |
| return World._backup_recovery_adapter_dispatch(self, name, arguments, actor_user_id) |
| return self._backup_rule_successor_dispatch_2(name, arguments, actor_user_id) |
|
|
| def _backup_rule_successor_apply_stream_drift(self, event_id='evt-protection-routing-evidence-2026-09-v6'): |
| before = self.business_hash() |
| if event_id in self._applied_boundary_events: |
| return {'status': 'success', 'event_id': 'EV-' + fn_digest(event_id)[:16].upper(), 'applied': False, 'idempotent': True, 'before_world_sha256': before, 'after_world_sha256': self.business_hash(), 'public_notice': ''} |
| self._policy_version = 'routing-epoch-9a27' |
| self._applied_boundary_events.add(event_id) |
| return {'status': 'success', 'event_id': 'EV-' + fn_digest(event_id)[:16].upper(), 'applied': True, 'idempotent': False, 'before_world_sha256': before, 'after_world_sha256': self.business_hash(), 'public_notice': ''} |
|
|
| def _backup_rule_successor_cost(self, name, result): |
| if name in {'list_protection_sites', 'get_workload_asset', 'get_backup_policy'}: |
| return 32 |
| if name == 'search_protection_policy_evidence' and self._discount_policy_evidence: |
| return 14 |
| return self._backup_rule_successor_cost_2(name, result) |
|
|
| def _persistent_backup_recovery_adapter_grade(self, task_id=None): |
| active = task_id or self._task_id |
| if active != self._task_id or active not in DATA_TASK_IDS: |
| raise ValueError('only the active stream task can be graded') |
| deliverables = [] |
| cells = self.policy_cells |
| assignments = self._state.list_entities('policy_assignment') |
| schedules = self._state.list_entities('schedule_window') |
| for target in self._task_targets: |
| policy = self._state.get_entity('backup_policy', target['policy_id'], 'policy_id') |
| asset = self._state.get_entity('workload_asset', target['asset_id'], 'asset_id') |
| schedule_ok = any((row.get('policy_id') == target['policy_id'] and row.get('status') == 'enabled' for row in schedules)) |
| assignment = next((row for row in assignments if row.get('policy_id') == target['policy_id'] and row.get('asset_id') == target['asset_id'] and (row.get('protection_state') == 'active')), None) |
| repository = self._state.get_entity('backup_repository', assignment['repository_id'], 'repository_id') if assignment else None |
| current = cells[target['service_tier'], target['data_class']] |
| complete = bool(policy and policy.get('status') == 'active' and schedule_ok and assignment and asset and (asset.get('status') == 'protected') and repository and (len({policy.get('site_id'), asset.get('site_id'), repository.get('site_id')}) == 1) and (repository.get('repository_pool') == target['repository_pool']) and (repository.get('protection_profile') == current['repository_profile'])) |
| deliverables.append({'target_id': target['target_id'], 'structure_atom': target['structure_atom'], 'rule_atom': target['rule_atom'], 'complete': complete, 'score': 25.0 if complete else 0.0}) |
| completed = sum((row['complete'] for row in deliverables)) |
| return {'task_id': active, 'score': completed * 25.0, 'max_score': 100.0, 'completed_artifacts': completed, 'deliverables': deliverables, 'remaining_budget': self._remaining} |
|
|
| def _backup_rule_successor_policy_evidence(self, arguments): |
| atom_id = next((key for (key, row) in DATA_PRE_RULES.items() if row['service_tier'] == arguments['service_tier'] and row['data_class'] == arguments['data_class']), None) |
| state_before = self.rule_revalidation.get(atom_id or '') |
| self._safe_refresh_discount = state_before == 'awaiting_safe_exact_refresh' |
| result = self._backup_rule_successor_policy_evidence_2(arguments) |
| if not atom_id or self._observed_global_epoch != 'routing-epoch-9a27': |
| return result |
| if state_before == 'awaiting_exact_stale': |
| result['data']['evidence'] = [row for row in result['data']['evidence'] if row['effective_epoch'] == 'routing-epoch-61c4'] |
| self.rule_revalidation[atom_id] = 'awaiting_safe_exact_refresh' |
| target = self._target_for_atom(atom_id) |
| if target is not None: |
| self.revalidation_targets[atom_id] = target['target_id'] |
| elif state_before == 'awaiting_safe_exact_refresh': |
| if any((row['effective_epoch'] == self._observed_global_epoch for row in result['data']['evidence'])): |
| self.rule_revalidation[atom_id] = 'ready_current' |
| return result |
|
|
| def _backup_evidence_evolution_snapshot(self): |
| value = self._backup_evolution_snapshot() |
| value['evidence_contract'] = 'backup-lifecycle-evidence-evolution-v2' |
| return value |
|
|
| def _backup_evidence_evolution_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('evidence_contract', None) != 'backup-lifecycle-evidence-evolution-v2': |
| raise ValueError('Backup evidence-snapshot contract differs') |
| self._backup_evolution_restore(value) |
|
|
| def _backup_rule_successor_init_2(self, budget=126, *, enforce_priority=True, enforce_revalidation=True): |
| self._discount_policy_evidence = False |
| self._backup_rule_successor_init_3(budget=budget, enforce_priority=enforce_priority, enforce_revalidation=enforce_revalidation) |
|
|
| def _backup_recovery_adapter_dispatch(self, name, arguments, actor_user_id): |
| if self._task_id is None: |
| return fn__error('TASK_NOT_ACTIVE', 'activate a task before dispatch') |
| tool = DATA_TOOL_BY_NAME.get(name) |
| if tool is None: |
| return fn__error('TOOL_NOT_ALLOWED', 'tool is not in the learner allowlist') |
| actor = self._actor(actor_user_id) |
| if actor is None: |
| return fn__error('ACTOR_NOT_AUTHORIZED', 'actor is not an active backup administrator') |
| try: |
| mod_jsonschema.validate(arguments, tool['input_schema']) |
| except mod_jsonschema.ValidationError: |
| return fn__error('INVALID_ARGUMENTS', 'arguments do not match the public tool schema') |
| if self._calls >= 40: |
| return self._with_budget(fn__error('CALL_BUDGET_EXHAUSTED', 'task call budget is exhausted'), 0) |
| if name in DATA_WRITE_TOOLS and self._writes >= 20: |
| return self._with_budget(fn__error('WRITE_BUDGET_EXHAUSTED', 'task write budget is exhausted'), 0) |
| target_site = self._target_site(name, arguments) |
| if target_site is not None and target_site not in set(actor.get('site_ids') or []): |
| return self._with_budget(fn__error('ACTOR_SITE_SCOPE_DENIED', 'actor is not assigned to the target site'), 0) |
| before = self.snapshot() |
| before_hash = self._business_hash() |
| prepared = ext_deepcopy(arguments) |
| if name == 'create_backup_policy': |
| prepared['created_by_user_id'] = actor_user_id |
| elif name in {'update_backup_policy_status', 'remove_policy_assignment'}: |
| prepared['actor_user_id'] = actor_user_id |
| route_error = None |
| capacity_error = None |
| if name == 'assign_policy_to_asset': |
| route_error = self._validate_protection_route(prepared) |
| if route_error is None: |
| capacity_error = self._reserve_for_assignment(prepared) |
| raw_arguments = {key: value for (key, value) in prepared.items() if not key.startswith('_')} |
| try: |
| if name == 'search_protection_policy_evidence': |
| result = self._policy_evidence(prepared) |
| elif route_error is not None: |
| result = route_error |
| elif capacity_error is not None: |
| result = capacity_error |
| else: |
| result = getattr(self._logic, name)(self._state, **raw_arguments) |
| if result.get('status') == 'success' and name == 'assign_policy_to_asset': |
| result = self._apply_assignment_reservation(prepared, result) |
| elif result.get('status') == 'success' and name == 'remove_policy_assignment': |
| result = self._release_assignment_reservation(before, result) |
| result = self._enrich_list_result(name, result) |
| except Exception: |
| self.restore(before) |
| result = fn__error('ADAPTER_EXECUTION_FAILED', 'the operation failed without committing state') |
| if result.get('status') != 'success': |
| self.restore(before) |
| charged = self._cost(name, result) |
| if charged > self._remaining: |
| self.restore(before) |
| self._calls += 1 |
| exhausted = self._with_budget(fn__error('WORK_BUDGET_EXHAUSTED', 'insufficient work units for this operation'), 0) |
| self._record_event(name, actor_user_id, exhausted, before_hash, before_hash) |
| return exhausted |
| self._remaining -= charged |
| self._calls += 1 |
| if name in DATA_WRITE_TOOLS: |
| self._writes += 1 |
| after_hash = self._business_hash() |
| result = self._with_budget(result, charged) |
| self._record_event(name, actor_user_id, result, before_hash, after_hash) |
| return result |
|
|
| def _backup_rule_successor_dispatch_2(self, name, arguments, actor_user_id): |
| if name == 'assign_policy_to_asset' and self._enforce_revalidation: |
| priority_error = self._priority_guard(name, arguments) |
| if priority_error is not None: |
| return priority_error |
| target = self._target_for_policy(str(arguments.get('policy_id') or '')) |
| if target is not None and self.rule_revalidation.get(target['rule_atom']) == 'awaiting_safe_exact_refresh' and self._exact_stale_tuple(target, arguments): |
| result = self._charged_error(name, 'ROUTING_EPOCH_STALE', 'the retained routing tuple is stale for the observed global routing epoch; repeat exact policy evidence refresh for this condition') |
| self.revalidation_targets[target['rule_atom']] = target['target_id'] |
| return result |
| self._safe_refresh_discount = False |
| try: |
| result = self._backup_rule_successor_dispatch_3(name, arguments, actor_user_id) |
| finally: |
| self._safe_refresh_discount = False |
| if name == 'get_site_recovery_dashboard' and result.get('status') == 'success': |
| self._observed_global_epoch = result.get('data', {}).get('routing_policy_epoch') |
| return result |
|
|
| def _backup_rule_successor_cost_2(self, name, result): |
| if name in {'list_protection_sites', 'get_workload_asset', 'get_backup_policy'}: |
| return 42 |
| if name == 'search_protection_policy_evidence': |
| return 20 |
| return self._backup_recovery_adapter_cost(name, result) |
|
|
| def _backup_rule_successor_policy_evidence_2(self, arguments): |
| old = DATA_PRE_RULES.get((arguments['service_tier'], arguments['data_class'])) |
| atom_id = next((key for (key, row) in DATA_PRE_RULES.items() if row['service_tier'] == arguments['service_tier'] and row['data_class'] == arguments['data_class']), None) |
| state_before = self.rule_revalidation.get(atom_id or '') |
| result = self._backup_rule_successor_policy_evidence_3(arguments) |
| if atom_id and state_before == 'awaiting_fresh_policy' and (DATA_PRE_RULES[atom_id]['repository_profile'] == DATA_POST_RULES[atom_id]['repository_profile']): |
| self.rule_revalidation[atom_id] = 'ready_current' |
| return result |
|
|
| def _backup_evolution_snapshot(self): |
| value = self._backup_confirmation_snapshot() |
| value['evolution_contract'] = {'case_version': 'backup-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2)} |
| return value |
|
|
| def _backup_evolution_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('evolution_contract', None) != {'case_version': 'backup-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2}: |
| raise ValueError('Backup evolution contract differs') |
| self._backup_confirmation_restore(value) |
|
|
| def _backup_rule_successor_init_3(self, budget=126, *, enforce_priority=True, enforce_revalidation=True): |
| self.verified_target_ids: set[str] = set() |
| self._backup_rule_successor_init_4(budget=budget, enforce_priority=enforce_priority, enforce_revalidation=enforce_revalidation) |
|
|
| def _backup_rule_successor_dispatch_3(self, name, arguments, actor_user_id): |
| if name == 'assign_policy_to_asset' and self._enforce_revalidation: |
| priority_error = self._priority_guard(name, arguments) |
| if priority_error is not None: |
| return priority_error |
| target = self._target_for_policy(str(arguments.get('policy_id') or '')) |
| if target is not None: |
| atom_id = target['rule_atom'] |
| if self.rule_revalidation.get(atom_id) == 'awaiting_exact_stale' and self._exact_stale_tuple(target, arguments): |
| epoch_known = self._known_current_epoch(excluding=atom_id) |
| message = 'the retained routing tuple is stale; the current site policy epoch was already established, so refresh exact policy evidence for this condition' if epoch_known else "the retained routing tuple is stale for the site's current policy epoch; inspect site recovery status, then refresh exact policy evidence for this condition" |
| result = self._charged_error(name, 'ROUTING_EPOCH_STALE', message) |
| self.rule_revalidation[atom_id] = 'awaiting_fresh_policy' if epoch_known else 'awaiting_current_epoch' |
| self.revalidation_targets[atom_id] = target['target_id'] |
| return result |
| discounted = False |
| if name == 'search_protection_policy_evidence': |
| atom_id = next((key for (key, row) in DATA_PRE_RULES.items() if row['service_tier'] == arguments.get('service_tier') and row['data_class'] == arguments.get('data_class')), None) |
| discounted = bool(atom_id and self.rule_revalidation.get(atom_id) == 'awaiting_fresh_policy' and self._known_current_epoch(excluding=atom_id)) |
| self._discount_policy_evidence = discounted |
| try: |
| return self._backup_rule_successor_dispatch_4(name, arguments, actor_user_id) |
| finally: |
| self._discount_policy_evidence = False |
|
|
| def _backup_recovery_adapter_cost(self, name, result): |
| if name in DATA_LIST_KEYS: |
| rows = (result.get('data') or {}).get(DATA_LIST_KEYS[name]) or [] |
| return 4 + 2 * len(rows) |
| return DATA_FIXED_COSTS.get(name, 4) |
|
|
| def _backup_rule_successor_policy_evidence_3(self, arguments): |
| result = self._backup_rule_successor_policy_evidence_4(arguments) |
| old = DATA_POLICY_CELLS.get((arguments['service_tier'], arguments['data_class'])) |
| atom_id = old['rule_atom'] if old else None |
| state = self.rule_revalidation.get(atom_id or '') |
| if state in {'awaiting_exact_stale', 'awaiting_current_epoch'}: |
| result['data']['evidence'] = [row for row in result['data']['evidence'] if row['effective_epoch'] == 'routing-epoch-61c4'] |
| elif state == 'awaiting_fresh_policy': |
| target_id = self.revalidation_targets.get(atom_id or '') |
| target = next((row for row in self._task_targets if row['target_id'] == target_id), None) |
| self.rule_revalidation[atom_id] = 'ready_current' if target and target['site_id'] in self._episode_repository_sites else 'awaiting_fresh_repository' |
| return result |
|
|
| def _backup_confirmation_snapshot(self): |
| snapshot = self._backup_rule_successor_snapshot() |
| snapshot['own_assignment_confirmations'] = ext_deepcopy(self._own_assignments) |
| return snapshot |
|
|
| def _backup_confirmation_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| self._own_assignments = value.pop('own_assignment_confirmations', {}) |
| self._backup_rule_successor_restore(value) |
|
|
| def _backup_rule_successor_init_4(self, budget=132, *, enforce_priority=True, enforce_revalidation=True): |
| self.rule_revalidation: dict[str, str] = {} |
| self.revalidation_targets: dict[str, str] = {} |
| self._episode_repository_sites: set[str] = set() |
| self._enforce_priority = enforce_priority |
| self._enforce_revalidation = enforce_revalidation |
| self._backup_rule_successor_init_5(budget=budget) |
|
|
| def _backup_rule_successor_dispatch_4(self, name, arguments, actor_user_id): |
| result = self._backup_rule_successor_dispatch_5(name, arguments, actor_user_id) |
| if name == 'list_policy_assignments' and result.get('status') == 'success': |
| policy_id = str(arguments.get('policy_id') or '') |
| asset_id = str(arguments.get('asset_id') or '') |
| target = next((row for row in self._task_targets if row['policy_id'] == policy_id and row['asset_id'] == asset_id), None) |
| assignments = result.get('data', {}).get('assignments') or [] |
| if target is not None and any((row.get('policy_id') == policy_id and row.get('asset_id') == asset_id and (row.get('protection_state') == 'active') for row in assignments)): |
| self.verified_target_ids.add(target['target_id']) |
| return result |
|
|
| def _backup_rule_successor_policy_evidence_4(self, arguments): |
| key = (arguments['service_tier'], arguments['data_class']) |
| old = DATA_POLICY_CELLS.get(key) |
| current = self.policy_cells.get(key) |
| evidence = [] |
| if old is not None: |
| evidence.append({**ext_deepcopy(old), 'effective_epoch': 'routing-epoch-61c4'}) |
| if current is not None and current != old: |
| evidence.append({**ext_deepcopy(current), 'effective_epoch': 'routing-epoch-9a27'}) |
| return {'status': 'success', 'data': {'evidence': evidence}, 'message': ''} |
|
|
| def _backup_rule_successor_snapshot(self): |
| value = self._backup_rule_successor_snapshot_2() |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v8.2' |
| return value |
|
|
| def _backup_rule_successor_restore(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-rule-stream/v8.2': |
| raise ValueError('unsupported Backup Recovery v8.2 snapshot') |
| value = ext_deepcopy(snapshot) |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v8' |
| self._backup_rule_successor_restore_2(value) |
|
|
| def _backup_rule_successor_init_5(self, budget=132): |
| self._persistent_backup_recovery_adapter_init(budget=budget) |
| self._policy_version = 'routing-epoch-61c4' |
|
|
| def _backup_rule_successor_dispatch_5(self, name, arguments, actor_user_id): |
| priority_error = self._priority_guard(name, arguments) |
| if priority_error is not None: |
| return priority_error |
| revalidation_error = self._revalidation_assignment_guard(name, arguments) |
| if revalidation_error is not None: |
| return revalidation_error |
| target = None |
| stale_attempt = False |
| state_before = None |
| if name == 'assign_policy_to_asset': |
| target = self._target_for_policy(str(arguments.get('policy_id') or '')) |
| if target is not None: |
| state_before = self.rule_revalidation.get(target['rule_atom']) |
| stale_attempt = state_before == 'awaiting_exact_stale' and self._exact_stale_tuple(target, arguments) |
| result = self._backup_rule_successor_dispatch_6(name, arguments, actor_user_id) |
| success = result.get('status') == 'success' |
| if name == 'list_backup_repositories' and success: |
| site_id = str(arguments.get('site_id') or '') |
| self._episode_repository_sites.add(site_id) |
| for (atom_id, state) in list(self.rule_revalidation.items()): |
| if state != 'awaiting_fresh_repository': |
| continue |
| target_id = self.revalidation_targets.get(atom_id) |
| pending = next((row for row in self._task_targets if row['target_id'] == target_id), None) |
| if pending and pending['site_id'] == site_id: |
| self.rule_revalidation[atom_id] = 'ready_current' |
| if name == 'get_site_recovery_dashboard' and success: |
| site_id = str(arguments.get('site_id') or '') |
| for (atom_id, state) in list(self.rule_revalidation.items()): |
| if state != 'awaiting_current_epoch': |
| continue |
| target_id = self.revalidation_targets.get(atom_id) |
| pending = next((row for row in self._task_targets if row['target_id'] == target_id), None) |
| if pending and pending['site_id'] == site_id: |
| self.rule_revalidation[atom_id] = 'awaiting_fresh_policy' |
| if target is not None and stale_attempt and (not success): |
| error_code = result.get('data', {}).get('error_code') |
| if error_code in {'PROTECTION_ROUTE_MISMATCH', 'REPOSITORY_PROFILE_MISMATCH'}: |
| atom_id = target['rule_atom'] |
| self.rule_revalidation[atom_id] = 'awaiting_current_epoch' |
| self.revalidation_targets[atom_id] = target['target_id'] |
| if target is not None and success and (state_before in {'ready_current', 'validated'}): |
| self.rule_revalidation[target['rule_atom']] = 'validated' |
| return result |
|
|
| def _backup_rule_successor_snapshot_2(self): |
| value = self._backup_rule_successor_snapshot_3() |
| value.update({'schema': 'rescopebench-backup-recovery-rule-stream/v8', 'provider_tools_sha256': 'f0ac996f2fa0dff9d8b176eaf7134b483ab74db75f6839ce294c85d0515f6791', 'observed_global_epoch': self._observed_global_epoch}) |
| return value |
|
|
| def _backup_rule_successor_restore_2(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-rule-stream/v8': |
| raise ValueError('unsupported Backup Recovery v8 snapshot') |
| if snapshot.get('provider_tools_sha256') != 'f0ac996f2fa0dff9d8b176eaf7134b483ab74db75f6839ce294c85d0515f6791': |
| raise ValueError('Backup Recovery v8 provider tool identity changed') |
| if 'observed_global_epoch' not in snapshot: |
| raise ValueError('Backup Recovery v8 snapshot missing global epoch state') |
| value = ext_deepcopy(snapshot) |
| self._observed_global_epoch = value.pop('observed_global_epoch') |
| self._safe_refresh_discount = False |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v7' |
| value['provider_tools_sha256'] = 'ea7e74c932e441f15145772390c47f81663f1f7264fad3e489ccfce5e2cb9dda' |
| self._backup_rule_successor_restore_3(value) |
|
|
| def _persistent_backup_recovery_adapter_init(self, budget=100): |
| self._backup_recovery_adapter_init(budget=budget) |
| self._state = MemoryState(fn__base_entities()) |
| self._task_id = None |
| self._task_targets = [] |
| self._events = [] |
| self._calls = 0 |
| self._writes = 0 |
| self._remaining = self._initial_budget |
| self._policy_version = 'protection-policy-v1' |
| self._activated_tasks: list[str] = [] |
| self._applied_boundary_events: set[str] = set() |
| self._active_event_start = 0 |
|
|
| def _backup_rule_successor_dispatch_6(self, name, arguments, actor_user_id): |
| result = self._backup_recovery_adapter_dispatch(name, arguments, actor_user_id) |
| if name == 'get_site_recovery_dashboard' and result.get('status') == 'success': |
| result = ext_deepcopy(result) |
| result.setdefault('data', {})['routing_policy_epoch'] = self._policy_version |
| return result |
|
|
| def _backup_rule_successor_snapshot_3(self): |
| value = self._backup_rule_successor_snapshot_4() |
| value.update({'schema': 'rescopebench-backup-recovery-rule-stream/v7', 'provider_tools_sha256': 'ea7e74c932e441f15145772390c47f81663f1f7264fad3e489ccfce5e2cb9dda'}) |
| return value |
|
|
| def _backup_rule_successor_restore_3(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-rule-stream/v7': |
| raise ValueError('unsupported Backup Recovery v7 snapshot') |
| if snapshot.get('provider_tools_sha256') != 'ea7e74c932e441f15145772390c47f81663f1f7264fad3e489ccfce5e2cb9dda': |
| raise ValueError('Backup Recovery v7 provider tool identity changed') |
| value = ext_deepcopy(snapshot) |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v6' |
| value['provider_tools_sha256'] = 'b9a4ce5a6bce3a0f087d3acd1085e3576395829f9079bd7c50315c4890f30116' |
| self._backup_rule_successor_restore_4(value) |
|
|
| def _backup_recovery_adapter_init(self, budget=100): |
| if type(budget) is not int or budget <= 0: |
| raise ValueError('budget must be a positive integer') |
| self._logic = fn__load_raw_logic() |
| self._state = MemoryState({name: [] for name in DATA_ENTITY_ID_FIELDS}) |
| self._task_id: str | None = None |
| self._task_targets: list[dict[str, ext_Any]] = [] |
| self._events: list[dict[str, ext_Any]] = [] |
| self._calls = 0 |
| self._writes = 0 |
| self._initial_budget = budget |
| self._remaining = budget |
| self._policy_version = 'protection-policy-v1' |
|
|
| def _backup_rule_successor_snapshot_4(self): |
| value = self._backup_rule_successor_snapshot_5() |
| value.update({'schema': 'rescopebench-backup-recovery-rule-stream/v6', 'provider_tools_sha256': 'b9a4ce5a6bce3a0f087d3acd1085e3576395829f9079bd7c50315c4890f30116', 'verified_target_ids': sorted(self.verified_target_ids)}) |
| return value |
|
|
| def _backup_rule_successor_restore_4(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-rule-stream/v6': |
| raise ValueError('unsupported Backup Recovery v6 snapshot') |
| if snapshot.get('provider_tools_sha256') != 'b9a4ce5a6bce3a0f087d3acd1085e3576395829f9079bd7c50315c4890f30116': |
| raise ValueError('Backup Recovery v6 provider tool identity changed') |
| if 'verified_target_ids' not in snapshot: |
| raise ValueError('Backup Recovery v6 snapshot is missing verified_target_ids') |
| value = ext_deepcopy(snapshot) |
| self.verified_target_ids = set(value.pop('verified_target_ids')) |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v5' |
| value['provider_tools_sha256'] = 'b002266a4d83cff047d26f18419a42fdf3a6d9d38138d17c4fba7e36e3e4e3b8' |
| self._backup_rule_successor_restore_5(value) |
|
|
| def _backup_rule_successor_snapshot_5(self): |
| value = self._backup_rule_successor_snapshot_6() |
| value.update({'schema': 'rescopebench-backup-recovery-rule-stream/v5', 'rule_revalidation': ext_deepcopy(self.rule_revalidation), 'revalidation_targets': ext_deepcopy(self.revalidation_targets), 'episode_repository_sites': sorted(self._episode_repository_sites)}) |
| return value |
|
|
| def _backup_rule_successor_restore_5(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-rule-stream/v5': |
| raise ValueError('unsupported Backup Recovery v5 snapshot') |
| for key in ('rule_revalidation', 'revalidation_targets', 'episode_repository_sites'): |
| if key not in snapshot: |
| raise ValueError(f'Backup Recovery v5 snapshot is missing {key}') |
| value = ext_deepcopy(snapshot) |
| self.rule_revalidation = ext_deepcopy(value.pop('rule_revalidation')) |
| self.revalidation_targets = ext_deepcopy(value.pop('revalidation_targets')) |
| self._episode_repository_sites = set(value.pop('episode_repository_sites')) |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v2' |
| self._backup_rule_successor_restore_6(value) |
|
|
| def _backup_rule_successor_snapshot_6(self): |
| value = self._persistent_backup_recovery_adapter_snapshot() |
| value['schema'] = 'rescopebench-backup-recovery-rule-stream/v2' |
| value['provider_tools_sha256'] = 'b002266a4d83cff047d26f18419a42fdf3a6d9d38138d17c4fba7e36e3e4e3b8' |
| return value |
|
|
| def _backup_rule_successor_restore_6(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-rule-stream/v2': |
| raise ValueError('unsupported Backup rule successor snapshot') |
| value = ext_deepcopy(snapshot) |
| value['schema'] = 'rescopebench-backup-recovery-stream-snapshot/v1' |
| value.pop('provider_tools_sha256', None) |
| self._persistent_backup_recovery_adapter_restore(value) |
|
|
| def _persistent_backup_recovery_adapter_snapshot(self): |
| value = self._backup_recovery_adapter_snapshot() |
| value.update({'schema': 'rescopebench-backup-recovery-stream-snapshot/v1', 'activated_tasks': list(self._activated_tasks), 'applied_boundary_events': sorted(self._applied_boundary_events), 'active_event_start': self._active_event_start}) |
| return value |
|
|
| def _persistent_backup_recovery_adapter_restore(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-backup-recovery-stream-snapshot/v1': |
| raise ValueError('unsupported persistent stream snapshot schema') |
| self._task_id = snapshot.get('task_id') |
| self._task_targets = ext_deepcopy(snapshot.get('task_targets') or []) |
| self._state.restore(snapshot.get('entities') or {}) |
| self._events = ext_deepcopy(snapshot.get('events') or []) |
| self._calls = int(snapshot.get('calls') or 0) |
| self._writes = int(snapshot.get('writes') or 0) |
| self._initial_budget = int(snapshot.get('initial_budget') or 100) |
| self._remaining = int(snapshot.get('remaining') or 0) |
| self._policy_version = str(snapshot.get('policy_version') or 'protection-policy-v1') |
| self._activated_tasks = list(snapshot.get('activated_tasks') or []) |
| self._applied_boundary_events = set(snapshot.get('applied_boundary_events') or []) |
| self._active_event_start = int(snapshot.get('active_event_start') or 0) |
|
|
| def _backup_recovery_adapter_snapshot(self): |
| return {'schema': 'rescopebench-backup-recovery-snapshot/v2', 'task_id': self._task_id, 'task_targets': ext_deepcopy(self._task_targets), 'entities': self._state.snapshot(), 'events': ext_deepcopy(self._events), 'calls': self._calls, 'writes': self._writes, 'initial_budget': self._initial_budget, 'remaining': self._remaining, 'policy_version': self._policy_version} |
|
|
| class MemoryState: |
|
|
| def __init__(self, entities): |
| self._entities = ext_deepcopy(entities) |
|
|
| def get_entity(self, entity_type, entity_id, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| return next((ext_deepcopy(row) for row in self._entities.get(entity_type, []) if row.get(field) == entity_id), None) |
|
|
| def list_entities(self, entity_type): |
| return ext_deepcopy(self._entities.get(entity_type, [])) |
|
|
| def add_entity(self, entity_type, record, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| identity = record.get(field) |
| if identity is None or self.get_entity(entity_type, identity, field) is not None: |
| raise ValueError(f'duplicate or missing identity for {entity_type}') |
| self._entities.setdefault(entity_type, []).append(ext_deepcopy(record)) |
| return ext_deepcopy(record) |
|
|
| def update_entity(self, entity_type, entity_id, patch, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| for row in self._entities.get(entity_type, []): |
| if row.get(field) == entity_id: |
| row.update(ext_deepcopy(patch)) |
| return ext_deepcopy(row) |
| return None |
|
|
| def delete_entity(self, entity_type, entity_id, id_field='id'): |
| field = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) if id_field == 'id' else id_field |
| rows = self._entities.get(entity_type, []) |
| kept = [row for row in rows if row.get(field) != entity_id] |
| self._entities[entity_type] = kept |
| return len(kept) != len(rows) |
|
|
| def delete_many(self, entity_type, predicate): |
| rows = self._entities.get(entity_type, []) |
| kept = [row for row in rows if not predicate(ext_deepcopy(row))] |
| self._entities[entity_type] = kept |
| return len(rows) - len(kept) |
|
|
| def snapshot(self): |
| return ext_deepcopy(self._entities) |
|
|
| def restore(self, entities): |
| self._entities = ext_deepcopy(entities) |
|
|
