| """Released environment operations and snapshot validation.""" |
| from __future__ import annotations |
| from contextlib import contextmanager |
| from contextvars import ContextVar |
| from copy import deepcopy as ext_deepcopy |
| from datetime import datetime as ext_datetime |
| from datetime import timedelta as ext_timedelta |
| from datetime import timezone as ext_timezone |
| from pathlib import Path as ext_Path |
| from rescopebench.raw_module_isolation import isolated_package_namespace as ext_isolated_package_namespace |
| from rescopebench.public_projection import assert_hard_public_projection as ext_assert_hard_public_projection |
| 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 math as mod_math |
| import re as _re |
| import re as mod_re |
| import shutil as mod_shutil |
| import sys as mod_sys |
| import tempfile as mod_tempfile |
| from .spec import CASE_DIR, DATA_BUSINESS_CALL_LIMITS, DATA_ZONE_ADJACENCY, DATA_ORDERED_MUTATIONS, DATA_CONTRACT, DATA_ORDER_INDEX_BLUEPRINT, DATA_EPISODE_BUDGETS, DATA_TOOLS_2, DATA_TASK_IDS, DATA_SCHEDULE_2, DATA_EPISODE_BUDGETS_2, DATA_CHANGED_HANDLING_ATOMS, DATA_ID_FIELDS, DATA_STATE_TABLES, DATA_ORDER_INDEX_BLUEPRINT_2, DATA_TOOLS_3, DATA__TRAVERSE_PARAMETERS, DATA_TRANSFER_PROFILES, DATA__TOOL_BY_NAME, DATA__ID_FIELDS, DATA_ORDER_INDEX_BLUEPRINT_3, DATA_TOOLS_4, DATA_TOOLS_5, DATA__SNAPSHOT_FIELDS, DATA_TOOLS_6, DATA_INTAKE_CODES, DATA_HANDLING_CODES, DATA__SNAPSHOT_FIELDS_2, DATA__TRANSFER_EVIDENCE_FIELDS, DATA_REVALIDATION_STATES, DATA__PRIVATE_KEYS, DATA_TOOLS_7, DATA__SNAPSHOT_TABLES |
| _BOUNDARY_TIME = ContextVar('robot_boundary_timestamp', default=None) |
|
|
| def fn_scoped_staging_result(result, target_group): |
|
|
| def visit(value): |
| if isinstance(value, list): |
| return [visit(item) for item in value] |
| if not isinstance(value, dict): |
| return value |
| row = {key: visit(child) for (key, child) in value.items()} |
| if 'access_state' in row and 'storage_handle' in row and ('stock_group' in row) and (row['stock_group'] != target_group): |
| row.pop('stock_group') |
| row.pop('calibration_records', None) |
| row['objects'] = [] |
| row['matches_pending_stock_group'] = False |
| row['scope'] = 'current_priority_order' |
| return row |
| scoped = visit(result) |
| if scoped.get('data', {}).get('outcome') == 'retained_source_unavailable' and scoped.get('message') == 'OK': |
| scoped['message'] = 'RETAINED_SOURCE_UNAVAILABLE: requested parcel is absent from the supplied source' |
| return scoped |
|
|
| def fn_episode_spec(task_id): |
| episode = next((row for row in mod_json.loads((CASE_DIR / 'data/world/private/config.json').read_text())['episodes'] if row['episode_id'] == task_id)) |
| if int(task_id[1:]) >= 9: |
| for order in episode['orders']: |
| order['source'] = fn_destinations().get(order['stock_group'], order['source']) |
| return episode |
|
|
| def fn_destinations(): |
| return mod_json.loads((CASE_DIR / 'data/assets/design.json').read_text())['destinations'] |
|
|
| def fn_prepare_episode(case, state_dir, episode_id): |
| (case, state_dir) = (ext_Path(case).resolve(), ext_Path(state_dir).resolve()) |
| config = fn_read(case / 'private/config.json') |
| requested = fn__episode(config, episode_id) |
| episode_budget = fn__episode_budget(config, episode_id) |
| sm = fn_open_state(case / 'private/world', state_dir) |
| facility = sm.get_entity('facility', config['facility_id'], id_field='facility_id') |
| current = facility.get('experience_active_episode') if facility else None |
| boundary_config = ext_deepcopy(config) |
| boundary_config['budget'] = episode_budget |
| if current == episode_id: |
| receipt = fn__advance_boundary(sm, boundary_config, current, episode_id) |
| else: |
| if current is None: |
| previous_episode_id = None |
| if episode_id != 'T01': |
| raise ValueError('a fresh state can only prepare T01') |
| else: |
| current_episode = fn__episode(config, current) |
| if current_episode['next_episode_id'] != episode_id: |
| raise ValueError('persistent state cannot skip or rewind episodes') |
| previous_episode_id = current |
| receipt = fn__advance_boundary(sm, boundary_config, previous_episode_id, episode_id) |
| return (fn_restore_adapter(case, state_dir, episode_id), receipt) |
|
|
| def fn_public_task(task_id): |
| task = fn_public_task_2(task_id) |
| by_index = {row['order_index']: row['work_order'] for row in fn_episode_spec_3(task_id)['orders']} |
| ordered = [by_index[index] for index in DATA_ORDER_INDEX_BLUEPRINT[task_id]] |
| marker = '\n\nUse the work-order and local observation tools' |
| (heading, remainder) = task['query'].split(marker, 1) |
| task['work_orders'] = ordered |
| task['query'] = heading.split('\n- ', 1)[0] + '\n- ' + '\n- '.join(ordered) + marker + remainder |
| task['query'] = mod_re.sub('The starting battery is \\d+ units', f'The starting battery is {DATA_EPISODE_BUDGETS[task_id]} units', task['query'], count=1) |
| task['query'] = task['query'].replace('and at most one previously unseen stock binding can be authorized in this episode. ', 'and each newly verified binding remains provisional until its own order closes. ') |
| task['budget'] = {'battery_units': DATA_EPISODE_BUDGETS[task_id], 'business_call_limit': DATA_BUSINESS_CALL_LIMITS[task_id]} |
| return task |
|
|
| def fn__zone_for_room_id(room_id): |
| if not isinstance(room_id, str): |
| return None |
| for (token, zone) in (('-ground-', 'Zone-Ground'), ('-level-one-', 'Zone-Level-One'), ('-level-two-', 'Zone-Level-Two'), ('-mezzanine-', 'Zone-Mezzanine')): |
| if token in room_id: |
| return zone |
| return None |
|
|
| def fn__profiles(): |
| prepare = next((row for row in DATA_TOOLS_2 if row['function']['name'] == 'prepare_transfer')) |
| return tuple(prepare['function']['parameters']['properties']['profile']['enum']) |
|
|
| def fn_checkpoint_state(adapter, state_dir): |
| return fn_checkpoint_state_2(adapter, state_dir) |
|
|
| def fn_load_config(): |
| return mod_json.loads((CASE_DIR / 'data/world/private/config.json').read_text(encoding='utf-8')) |
|
|
| def fn_episode_spec_2(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown Robot stream task: {task_id}') |
| return ext_deepcopy(next((row for row in fn_load_config()['episodes'] if row['episode_id'] == task_id))) |
|
|
| def fn_restore_adapter(case, state_dir, task_id, **kwargs): |
| adapter = fn_adapter_for(case, state_dir, task_id, **kwargs) |
| ledger = kwargs.get('observation_ledger') |
| path = ext_Path(state_dir) / 'observation-ledger.json' |
| if ledger is None and path.is_file(): |
| ledger = mod_json.loads(path.read_text()) |
| if ledger is not None: |
| fn_retain_observed_identities(adapter, ledger, task_id) |
| return adapter |
|
|
| def fn_scoped_storage_diagnostics(value, object_name): |
| """A failed compound action must not return the underlying unfiltered store.""" |
| if isinstance(value, dict): |
| return {key: [fn_scoped_storage_diagnostics(row, object_name) for row in child if isinstance(row, dict) and row.get('display_name') == object_name] if key == 'objects' and isinstance(child, list) else fn_scoped_storage_diagnostics(child, object_name) for (key, child) in value.items()} |
| if isinstance(value, list): |
| return [fn_scoped_storage_diagnostics(child, object_name) for child in value] |
| return value |
|
|
| def fn_read(path): |
| return fn_read_2(path) |
|
|
| def fn__episode(config, episode_id): |
| row = next((item for item in config['episodes'] if item['episode_id'] == episode_id), None) |
| if row is None: |
| raise ValueError(f'unknown episode: {episode_id}') |
| return row |
|
|
| def fn__episode_budget(config, episode_id): |
| episode = fn__episode(config, episode_id) |
| value = episode.get('budget', config.get('budget')) |
| if type(value) is not int or value <= 0: |
| raise ValueError(f'invalid budget for {episode_id}: {value!r}') |
| return value |
|
|
| def fn_open_state(world_dir, state_dir): |
| """Open persistent stream state, seeding it from the world only once.""" |
| world_dir = ext_Path(world_dir).resolve() |
| state_dir = ext_Path(state_dir).resolve() |
| environment = world_dir / 'environment' |
| source_database = environment / 'data' / 'database' |
| if not source_database.is_dir(): |
| raise FileNotFoundError(source_database) |
| state_dir.mkdir(parents=True, exist_ok=True) |
| state_database = state_dir / 'database' |
| if not state_database.exists(): |
| mod_shutil.copytree(source_database, state_database) |
| elif not state_database.is_dir(): |
| raise NotADirectoryError(state_database) |
| environment_path = str(environment) |
| if environment_path in mod_sys.path: |
| mod_sys.path.remove(environment_path) |
| mod_sys.path.insert(0, environment_path) |
| from mcp_servers.state.state_manager import StateManager |
| return StateManager(db_path=str(state_dir)) |
|
|
| def fn__advance_boundary(sm, config, previous_episode_id, next_episode_id): |
| token = _BOUNDARY_TIME.set(fn__logical_boundary_time(fn_semantic_state(sm))) |
| try: |
| return fn_advance_boundary(sm, config, previous_episode_id, next_episode_id) |
| finally: |
| _BOUNDARY_TIME.reset(token) |
|
|
| def fn_public_task_2(task_id): |
| task = fn_public_task_3(task_id) |
| budget = DATA_EPISODE_BUDGETS_2[task_id] |
| (query, count) = mod_re.subn('The starting battery is \\d+ units', f'The starting battery is {budget} units', task['query'], count=1) |
| if count != 1: |
| raise ValueError(f'Robot {task_id} public budget sentence changed upstream') |
| task['query'] = query.rstrip() + f' Use locate_order_zone for the first pending listed order before cold search. Search is target-scoped: unrelated cabinets do not reveal their stock group or parcel identities, and at most one previously unseen stock binding can be authorized in this episode. The external business-tool limit is {32} calls, including rejected calls. Prefer execute_transfer_attempt once explicit route handles and an exact profile candidate are available. Benchmark credit is awarded only for fully closed work orders; partial milestones are diagnostics.' |
| task['budget'] = {'battery_units': budget, 'business_call_limit': 32, 'new_stock_binding_limit': 1} |
| task['scoring'] = {'complete_work_order_points': 25.0, 'partial_milestones': 'diagnostic_only'} |
| return task |
|
|
| def fn_episode_spec_3(task_id): |
| return ext_deepcopy(fn_episode_spec_4(task_id)) |
|
|
| def fn_checkpoint_state_2(adapter, state_dir): |
| ledger = adapter.export_observation_ledger() |
| path = fn__ledger_path(ext_Path(state_dir)) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(mod_json.dumps(ledger, indent=2, sort_keys=True, ensure_ascii=True) + '\n', encoding='utf-8') |
| return {'ledger': ledger, 'sha256': fn_digest(ledger), 'path': str(path.resolve())} |
|
|
| def fn_adapter_for(case, state_dir, episode_id, *, observation_ledger=None, rule_epoch_override=None, public_policy_version_override=None): |
| (case, state_dir) = (ext_Path(case).resolve(), ext_Path(state_dir).resolve()) |
| config = fn_read_3(case / 'private/config.json') |
| episode = fn__episode_3(config, episode_id) |
| sm = fn_open_state(case / 'private/world', state_dir) |
| facility = sm.get_entity('facility', config['facility_id'], id_field='facility_id') |
| if facility is None or facility.get('experience_active_episode') != episode_id: |
| raise ValueError('episode has not been prepared in this persistent state') |
| rule_epoch = rule_epoch_override or episode['rule_epoch'] |
| private_version = public_policy_version_override or episode['public_policy_version'] |
| rule_table = config['pre_rule_table'] if rule_epoch == 'pre' else config['post_rule_table'] |
| adapter = RobotExperienceStreamAdapter(sm, robot_id=config['robot_id'], handle_seed=config['handle_seed'], task_ids=[row['task_id'] for row in episode['orders']], rubric=fn__rubric(config, episode), rule_table=rule_table, active_object_ids={row['object_id'] for row in episode['orders']}, public_policy_version=private_version, expected_rule_epoch=rule_epoch, facility_id=config['facility_id']) |
| adapter._construction_environment = str((case / 'private/world/environment').resolve()) |
| ledger = observation_ledger |
| ledger_path = fn__ledger_path(state_dir) |
| if ledger is None and ledger_path.is_file(): |
| ledger = fn_read_3(ledger_path) |
| if ledger is not None: |
| adapter.import_observation_ledger(ledger) |
| return adapter |
|
|
| def fn_retain_observed_identities(adapter, ledger, task_id): |
| """Past visibility survives relocation; current action permissions do not change.""" |
| requested = ledger.get('object_handles', []) |
| if not isinstance(requested, list) or not all((isinstance(h, str) for h in requested)): |
| raise ValueError('object_handles must be a list of strings') |
| position = int(task_id[1:]) |
| prefix = {f'T{i:02d}' for i in range(1, position + 1)} |
| objects = {row['object_id'] for row in adapter._all('object_item')} |
| past = {row.get('object_id') for row in adapter._all('service_task') if row.get('experience_episode_id') in prefix} |
| allowed = {adapter._handle('object', key) for key in objects & past} |
| if not set(requested) <= allowed: |
| raise ValueError('Observed identity must belong to an existing prefix object') |
| adapter.issued_object_handles.update(requested) |
|
|
| def fn_public_retained_source_evidence(evidence): |
| """Project retained source evidence onto fields safe for the learner.""" |
| return {key: str(evidence[key]) for key in ('station', 'storage_handle', 'zone') if isinstance(evidence.get(key), str)} |
|
|
| def fn_read_2(path): |
| return fn_read_4(path) |
|
|
| def fn__logical_boundary_time(state): |
| timestamps = [] |
| for rows in state.values(): |
| for row in rows: |
| for field in ('created_at', 'updated_at', 'completed_at', 'released_at', 'accepted_at'): |
| value = row.get(field) |
| if not isinstance(value, str) or not value: |
| continue |
| parsed = ext_datetime.fromisoformat(value.replace('Z', '+00:00')) |
| timestamps.append(parsed.replace(tzinfo=ext_timezone.utc) if parsed.tzinfo is None else parsed) |
| if not timestamps: |
| raise ValueError('Robot boundary requires a timestamped source state') |
| return (max(timestamps).astimezone(ext_timezone.utc) + ext_timedelta(seconds=1)).strftime('%Y-%m-%dT%H:%M:%SZ') |
|
|
| def fn_semantic_state(sm): |
| return {table: sorted((ext_deepcopy(row) for row in sm.list_entities(table)), key=lambda row: str(row.get(DATA_ID_FIELDS[table], ''))) for table in DATA_STATE_TABLES} |
|
|
| def fn_advance_boundary(sm, config, previous_episode_id, next_episode_id): |
| """Advance persistent state without announcing the private rule epoch.""" |
| facility = sm.get_entity('facility', config['facility_id'], id_field='facility_id') |
| if facility is None: |
| raise ValueError('stream facility is missing') |
| if facility.get('experience_active_episode') == next_episode_id: |
| return fn__repeat_boundary(sm, config, previous_episode_id, next_episode_id) |
| before_policy = fn__policy_state(sm, config) |
| raw = fn_advance_boundary_2(sm, config, previous_episode_id, next_episode_id) |
| after_policy = fn__policy_state(sm, config) |
| drift = None |
| if raw.get('drift') is not None: |
| drift = fn__drift_receipt(config, before_policy, after_policy, duplicate=False) |
| raw['drift'] = drift |
| raw['activation'] = fn_activation_receipt(fn__episode_4(config, next_episode_id)) |
| raw['schema'] = 'robot-experience-stream-boundary/v4' |
| raw['public_notice'] = fn__public_notice(config, previous_episode_id, raw['activation']['event_id']) |
| fn_public_boundary_projection(raw) |
| return raw |
|
|
| def fn_public_task_3(task_id): |
| task = fn_public_task_4(task_id) |
| if task_id != 'T09': |
| by_index = {row['order_index']: row['work_order'] for row in fn_episode_spec_6(task_id)['orders']} |
| indices = DATA_ORDER_INDEX_BLUEPRINT_2.get(task_id, tuple(sorted(by_index))) |
| ordered = [by_index[index] for index in indices] |
| marker = '\n\nUse the work-order and local observation tools' |
| (heading, remainder) = task['query'].split(marker, 1) |
| task['work_orders'] = ordered |
| task['query'] = heading.split('\n- ', 1)[0] + '\n- ' + '\n- '.join(ordered) + marker + remainder |
| if task_id == 'T01': |
| before = task['query'] |
| task['query'] = before.replace(f'The starting battery is {93} units', f'The starting battery is {72} units') |
| if task['query'] == before: |
| raise ValueError('Robot T01 public budget sentence changed upstream') |
| return task |
|
|
| def fn_episode_spec_4(task_id): |
| spec = fn_episode_spec_5(task_id) |
| spec['budget'] = DATA_EPISODE_BUDGETS_2[task_id] |
| return spec |
|
|
| def fn__ledger_path(state_dir): |
| return ext_Path(state_dir) / 'observation-ledger.json' |
|
|
| def fn_digest(value): |
| return fn_digest_3(value) |
|
|
| def fn_read_3(path): |
| return fn_read_2(path) |
|
|
| def fn__episode_3(config, episode_id): |
| row = next((item for item in config['episodes'] if item['episode_id'] == episode_id), None) |
| if row is None: |
| raise ValueError(f'unknown episode: {episode_id}') |
| return row |
|
|
| def fn__rubric(config, episode): |
| return {'version': 'robot-experience-rubric/v1', 'policy_version': 'PV-18', 'home_room_id': config['home_room_id'], 'orders': [{'work_order': row['work_order'], 'task_id': row['task_id'], 'object_id': row['object_id'], 'destination_room_id': row['target']} for row in episode['orders']]} |
|
|
| def fn_episode_spec_5(task_id): |
| return fn_episode_spec_6(task_id) |
|
|
| def fn_load_config_2(): |
| config = fn_load_config_3() |
| config['episode_budgets']['T01'] = 72 |
| return config |
|
|
| def fn_digest_2(value): |
| return mod_hashlib.sha256(fn__canonical(value)).hexdigest() |
|
|
| def fn_read_4(path): |
| return fn_read_5(path) |
|
|
| def fn__repeat_boundary(sm, config, previous_episode_id, next_episode_id): |
| if previous_episode_id != next_episode_id: |
| raise ValueError('an idempotent replay must name the active episode') |
| episode = fn__episode_4(config, next_episode_id) |
| activation = fn_activation_receipt(episode) |
| before_state = fn_semantic_state(sm) |
| before_policy = fn__policy_state(sm, config) |
| drift = None |
| if next_episode_id == config['drift']['effective_episode_id']: |
| prior_policy = {**before_policy, 'experience_rule_epoch': config['drift']['from_rule_epoch'], 'experience_policy_version': config['drift']['from_policy_version'], 'experience_policy_event_seq': before_policy['experience_policy_event_seq'] - 1} |
| if prior_policy['experience_policy_event_seq'] < 0: |
| raise ValueError('drift event sequence is inconsistent') |
| drift = fn__drift_receipt(config, prior_policy, before_policy, duplicate=True) |
| receipt = {'schema': 'robot-experience-stream-boundary/v4', 'previous_episode_id': previous_episode_id, 'next_episode_id': next_episode_id, 'already_prepared': True, 'before_sha256': fn__digest(before_state), 'after_sha256': fn__digest(before_state), 'closed': {'closed_orders': [], 'cancelled_assignments': []}, 'supervisor_recovery': {'performed': False}, 'drift': drift, 'activation': activation, 'public_notice': fn__public_notice(config, None if next_episode_id == config['episodes'][0]['episode_id'] else 'prior', activation['event_id']), 'changes': [], 'preservation_contract': {'world_reset': False, 'opened_storage_preserved': True, 'completed_records_preserved': True, 'unrelated_object_locations_preserved': True, 'payload_parking_is_not_delivery': True}} |
| fn_public_boundary_projection(receipt) |
| return receipt |
|
|
| def fn__policy_state(sm, config): |
| facility = sm.get_entity('facility', config['facility_id'], id_field='facility_id') |
| if facility is None: |
| raise ValueError('stream facility is missing') |
| return {'experience_rule_epoch': facility.get('experience_rule_epoch'), 'experience_policy_version': facility.get('experience_policy_version'), 'experience_policy_event_seq': int(facility.get('experience_policy_event_seq', 0))} |
|
|
| def fn_advance_boundary_2(sm, config, previous_episode_id, next_episode_id): |
| """Close one episode and activate the next without resetting world state.""" |
| previous_episode = fn__episode_5(config, previous_episode_id) |
| next_episode = fn__episode_5(config, next_episode_id) |
| if next_episode is None: |
| raise ValueError('unknown next episode') |
| if previous_episode_id is not None and previous_episode is None: |
| raise ValueError('unknown previous episode') |
| if previous_episode is not None: |
| expected = previous_episode['next_episode_id'] |
| if expected != next_episode_id: |
| raise ValueError('episode boundary is not sequential') |
| before = fn_semantic_state_2(sm) |
| closed = fn__close_previous(sm, previous_episode) |
| recovery = fn__recover_robot(sm, budget=config['budget']) |
| drift = fn__apply_drift(sm, config, next_episode_id) |
| activation = fn__activate_next(sm, config, next_episode) |
| after = fn_semantic_state_2(sm) |
| changes = fn_state_diff(before, after) |
| notice = f"Episode {next_episode_id} is active. The supervisor placed the robot at the service hub with {config['budget']} battery units and activated the new work orders." |
| if previous_episode_id is not None: |
| notice += ' Any payload left from the prior episode was parked at its actual terminal room without delivery credit; other world state and completed records were preserved.' |
| if drift is not None: |
| notice += ' ' + drift['public_notice'] |
| return {'schema': 'robot-experience-stream-boundary/v2', 'previous_episode_id': previous_episode_id, 'next_episode_id': next_episode_id, 'before_sha256': fn__digest_2(before), 'after_sha256': fn__digest_2(after), 'closed': closed, 'supervisor_recovery': recovery, 'drift': drift, 'activation': activation, 'public_notice': notice, 'changes': changes, 'preservation_contract': {'world_reset': False, 'opened_storage_preserved': True, 'completed_records_preserved': True, 'unrelated_object_locations_preserved': True, 'payload_parking_is_not_delivery': True}} |
|
|
| def fn__drift_receipt(config, before, after, *, duplicate): |
| drift = config['drift'] |
| if after != {'experience_rule_epoch': drift['to_rule_epoch'], 'experience_policy_version': drift['to_policy_version'], 'experience_policy_event_seq': before['experience_policy_event_seq'] + 1}: |
| raise ValueError('drift receipt does not match the expected policy transition') |
| return {'schema': 'robot-experience-drift-application/v1', 'event_id': fn__drift_event_id(config), 'event_type': 'external_policy_update', 'receipt_kind': 'duplicate_application' if duplicate else 'first_application', 'status': 'already_applied' if duplicate else 'applied', 'applied_now': not duplicate, 'duplicate_noop': duplicate, 'exactly_once': True, 'application_before_sha256': fn__digest(before), 'application_after_sha256': fn__digest(after), 'call_before_sha256': fn__digest(after if duplicate else before), 'call_after_sha256': fn__digest(after), 'state_unchanged': duplicate, 'effective_episode_id': drift['effective_episode_id'], 'publicly_announced': False, 'policy_version_before': drift['from_policy_version'], 'policy_version_after': drift['to_policy_version'], 'changed_cell_count': len(drift['changed_cells'])} |
|
|
| def fn_activation_receipt(episode): |
| """Project an active private episode into the exact public receipt.""" |
| orders = episode.get('orders') |
| if not isinstance(episode.get('episode_id'), str) or not episode['episode_id']: |
| raise ValueError('episode must define a non-empty episode_id') |
| if not isinstance(orders, list) or not orders: |
| raise ValueError('episode must define active work orders') |
| work_orders = [row.get('work_order') for row in orders if isinstance(row, dict)] |
| if len(work_orders) != len(orders) or any((not isinstance(value, str) or not value for value in work_orders)) or len(set(work_orders)) != len(work_orders): |
| raise ValueError('episode work orders must be unique non-empty strings') |
| return {'schema': 'robot-experience-activation-public/v4', 'event_type': 'work_order_activation', 'event_id': fn_opaque_event_id(work_orders), 'work_orders': sorted(work_orders), 'created_object_ids': [], 'world_reset': False} |
|
|
| def fn__episode_4(config, episode_id): |
| episode = next((row for row in config.get('episodes', []) if row.get('episode_id') == episode_id), None) |
| if episode is None: |
| raise ValueError('unknown next episode') |
| return episode |
|
|
| def fn__public_notice(config, previous_episode_id, event_id): |
| notice = f"Work-order event {event_id} is active. The supervisor placed the robot at the service hub with {config['budget']} battery units and activated the new work orders." |
| if previous_episode_id is not None: |
| notice += ' Any payload left from the prior episode was parked at its actual terminal room without delivery credit; other business state and completed records were preserved.' |
| return notice |
|
|
| def fn_public_boundary_projection(receipt): |
| """Return only the boundary fields admitted to a learner/provider request.""" |
| activation = receipt.get('activation') |
| notice = receipt.get('public_notice') |
| if not isinstance(activation, dict) or not isinstance(notice, str): |
| raise ValueError('boundary receipt is missing its public fields') |
| projection = {'schema': 'robot-experience-stream-boundary-public/v2', 'event_id': activation.get('event_id'), 'activation': ext_deepcopy(activation), 'public_notice': notice} |
| encoded = mod_json.dumps(projection, sort_keys=True, ensure_ascii=True).casefold() |
| forbidden = ('pv-', 'policy_version', 'rule_epoch', 'drift', 'policy update', 'transfer policy', 'changed cell', 'rule change', 'environment change', 'prior compatibility', 'selective revision') |
| if any((token in encoded for token in forbidden)): |
| raise ValueError('learner-visible boundary exposes a private transition marker') |
| fn_assert_opaque_learner_surface(projection, surface='public boundary') |
| return projection |
|
|
| def fn_public_task_4(task_id): |
| task = fn_public_task_5(task_id) |
| if task_id != 'T09': |
| by_index = {row['order_index']: row['work_order'] for row in fn_episode_spec_6(task_id)['orders']} |
| indices = DATA_ORDER_INDEX_BLUEPRINT_3.get(task_id, tuple(sorted(by_index))) |
| ordered = [by_index[index] for index in indices] |
| marker = '\n\nUse the work-order and local observation tools' |
| (heading, remainder) = task['query'].split(marker, 1) |
| task['work_orders'] = ordered |
| task['query'] = heading.split('\n- ', 1)[0] + '\n- ' + '\n- '.join(ordered) + marker + remainder |
| sentence = ' Process the work orders in the listed priority order: do not start a later order until every earlier listed order has been fully closed.' |
| if sentence.strip() not in task['query']: |
| task['query'] = task['query'].rstrip() + sentence |
| task['completion'] = {'mode': 'ordered_independent', 'subset_allowed': True, 'priority_order': 'listed', 'started_item_must_close': True, 'verification_required': True} |
| return task |
|
|
| def fn_episode_spec_6(task_id): |
| return fn_episode_spec_2(task_id) |
|
|
| def fn_digest_3(value): |
| return fn_digest_4(value) |
|
|
| def fn__error(code, message, data=None): |
| return {'status': 'error', 'data': data or {}, 'message': f'{code}: {message}'} |
|
|
| def fn__code(result): |
| message = str(result.get('message') or '') |
| return message.split(':', 1)[0] if ':' in message else 'OK' if result.get('status') == 'success' else 'ERROR' |
|
|
| def fn__success(data, message='OK'): |
| return {'status': 'success', 'data': data, 'message': message} |
|
|
| def fn__timestamp(): |
| return ext_datetime.now(ext_timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') |
|
|
| def fn_load_config_3(): |
| config = fn_load_config() |
| config['episode_budgets']['T01'] = 93 |
| return config |
|
|
| def fn__canonical(value): |
| return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False).encode('ascii') |
|
|
| def fn__validate_snapshot_extensions(snapshot): |
| if not isinstance(snapshot, dict) or set(snapshot) != DATA__SNAPSHOT_FIELDS: |
| raise ValueError('Robot v8 snapshot fields are incomplete or unexpected') |
| if type(snapshot.get('business_call_count')) is not int: |
| raise ValueError('Robot v8 business_call_count must be an integer') |
| if snapshot['business_call_count'] < 0: |
| raise ValueError('Robot v8 business_call_count must be non-negative') |
| authorized = snapshot.get('authorized_new_stock_group') |
| if authorized is not None and (not isinstance(authorized, str) or not authorized): |
| raise ValueError('Robot v8 authorized stock group must be null or a string') |
| provisional = snapshot.get('provisional_stock_groups') |
| verified = snapshot.get('verified_stock_groups') |
| if not isinstance(provisional, dict): |
| raise ValueError('Robot v8 provisional_stock_groups must be an object') |
| if not isinstance(verified, dict): |
| raise ValueError('Robot v8 verified_stock_groups must be an object') |
| if len(provisional) > 1: |
| raise ValueError('Robot v8 provisional stock bindings exceed the task limit') |
| if set(provisional) & set(verified): |
| raise ValueError('Robot v8 stock evidence cannot be both provisional and verified') |
| required = {'task_id', 'station', 'storage_handle', 'zone'} |
| for (stock_group, evidence) in {**verified, **provisional}.items(): |
| if not isinstance(stock_group, str) or not stock_group: |
| raise ValueError('Robot v8 verified stock-group keys must be strings') |
| if not isinstance(evidence, dict) or set(evidence) != required: |
| raise ValueError('Robot v8 verified stock evidence is malformed') |
| if any((not isinstance(evidence[field], str) or not evidence[field] for field in required)): |
| raise ValueError('Robot v8 verified stock evidence values must be strings') |
| if evidence['task_id'] not in DATA_TASK_IDS: |
| raise ValueError('Robot v8 verified stock evidence has an invalid task') |
| if any((evidence['task_id'] != snapshot.get('task_id') for evidence in provisional.values())): |
| raise ValueError('Robot v8 provisional stock evidence crossed a task boundary') |
| visible_handles = snapshot.get('visible_object_handles') |
| if not isinstance(visible_handles, list) or any((not isinstance(handle, str) or not handle for handle in visible_handles)) or len(visible_handles) != len(set(visible_handles)): |
| raise ValueError('Robot v8 visible object handles must be unique strings') |
|
|
| def fn_read_5(path): |
| return mod_json.loads(ext_Path(path).read_text(encoding='utf-8')) |
|
|
| def fn__digest(value): |
| return mod_hashlib.sha256(mod_json.dumps(value, sort_keys=True, ensure_ascii=True, separators=(',', ':'), allow_nan=False).encode('ascii')).hexdigest() |
|
|
| def fn__episode_5(config, episode_id): |
| if episode_id is None: |
| return None |
| return next((row for row in config['episodes'] if row['episode_id'] == episode_id), None) |
|
|
| def fn_semantic_state_2(sm): |
| return {table: sorted((ext_deepcopy(row) for row in sm.list_entities(table)), key=lambda row: str(row.get(DATA_ID_FIELDS[table], ''))) for table in DATA_STATE_TABLES} |
|
|
| def fn__close_previous(sm, episode): |
| if episode is None: |
| return {'closed_orders': [], 'cancelled_assignments': []} |
| (closed, cancelled) = ([], []) |
| task_ids = {row['task_id'] for row in episode['orders']} |
| for spec in episode['orders']: |
| task = sm.get_entity('service_task', spec['task_id'], id_field='task_id') |
| obj = sm.get_entity('object_item', spec['object_id'], id_field='object_id') |
| if task is None or obj is None: |
| raise ValueError('previous episode records are missing') |
| task_changes = {'experience_activation_state': 'closed', 'updated_at': fn__boundary_timestamp()} |
| if task.get('status') != 'completed': |
| task_changes.update(status='paused', assigned_robot_id=None, failure_reason='episode_closed_by_supervisor') |
| fn__update(sm, 'service_task', spec['task_id'], task_changes) |
| fn__update(sm, 'object_item', spec['object_id'], {'experience_activation_state': 'closed', 'updated_at': fn__boundary_timestamp()}) |
| closed.append(spec['work_order']) |
| for assignment in sm.list_entities('task_assignment'): |
| if assignment.get('task_id') in task_ids and assignment.get('status') == 'active': |
| fn__update(sm, 'task_assignment', assignment['assignment_id'], {'status': 'cancelled', 'completed_at': fn__boundary_timestamp()}) |
| cancelled.append(assignment['assignment_id']) |
| return {'closed_orders': sorted(closed), 'cancelled_assignments': sorted(cancelled)} |
|
|
| def fn__recover_robot(sm, *, budget): |
| robot = sm.get_entity('robot_unit', 'robot-porter-atlas-north-one', id_field='robot_id') |
| if robot is None: |
| raise ValueError('controlled robot is missing') |
| parked = None |
| payload_id = robot.get('payload_object_id') |
| if payload_id is not None: |
| payload = sm.get_entity('object_item', payload_id, id_field='object_id') |
| if payload is None or payload.get('held_by_robot_id') != 'robot-porter-atlas-north-one': |
| raise ValueError('robot payload custody is inconsistent at the boundary') |
| parked = {'object_id': payload_id, 'room_id': robot.get('current_room_id'), 'delivery_receipt_created': False} |
| fn__update(sm, 'object_item', payload_id, {'current_room_id': robot.get('current_room_id'), 'held_by_robot_id': None, 'handling_state': 'stored', 'updated_at': fn__boundary_timestamp()}) |
| before = {key: ext_deepcopy(robot.get(key)) for key in ('current_room_id', 'battery_percent', 'payload_object_id', 'operational_status', 'active_task_id')} |
| fn__update(sm, 'robot_unit', 'robot-porter-atlas-north-one', {'current_room_id': 'room-atlas-north-level-one-central-return-sort', 'battery_percent': budget, 'payload_object_id': None, 'operational_status': 'available', 'active_task_id': None, 'updated_at': fn__boundary_timestamp()}) |
| after_row = sm.get_entity('robot_unit', 'robot-porter-atlas-north-one', id_field='robot_id') |
| return {'before': before, 'after': {key: ext_deepcopy(after_row.get(key)) for key in before}, 'parked_payload': parked} |
|
|
| def fn__apply_drift(sm, config, next_episode_id): |
| drift = config['drift'] |
| if next_episode_id != drift['effective_episode_id']: |
| return None |
| facility = sm.get_entity('facility', config['facility_id'], id_field='facility_id') |
| if facility is None: |
| raise ValueError('stream facility is missing') |
| if facility.get('experience_rule_epoch') != drift['from_rule_epoch']: |
| raise ValueError('drift must be applied exactly once from the pre-drift epoch') |
| before = {'experience_rule_epoch': facility.get('experience_rule_epoch'), 'experience_policy_version': facility.get('experience_policy_version')} |
| fn__update(sm, 'facility', config['facility_id'], {'experience_rule_epoch': 'post', 'experience_policy_version': 'PV-19', 'experience_policy_event_seq': int(facility.get('experience_policy_event_seq', 0)) + 1}) |
| return {'event_type': 'external_policy_update', 'effective_episode_id': next_episode_id, 'publicly_announced': True, 'policy_version_before': before['experience_policy_version'], 'policy_version_after': 'PV-19', 'changed_cell_count': len(drift['changed_cells']), 'public_notice': f"Transfer policy {'PV-19'} is effective for {next_episode_id}. Current work-order records show the active policy version; prior compatibility experience may need selective revision."} |
|
|
| def fn__activate_next(sm, config, episode): |
| facility = sm.get_entity('facility', config['facility_id'], id_field='facility_id') |
| if facility is None: |
| raise ValueError('stream facility is missing') |
| if facility.get('experience_rule_epoch') != episode['rule_epoch']: |
| raise ValueError('next episode expects a different rule epoch') |
| activated = [] |
| for spec in episode['orders']: |
| task = sm.get_entity('service_task', spec['task_id'], id_field='task_id') |
| obj = sm.get_entity('object_item', spec['object_id'], id_field='object_id') |
| if task is None or obj is None: |
| raise ValueError('next episode records are missing') |
| if task.get('experience_activation_state') != 'inactive': |
| raise ValueError('next service task is not inactive') |
| if obj.get('experience_activation_state') != 'inactive': |
| raise ValueError('next parcel is not inactive') |
| fn__update(sm, 'service_task', spec['task_id'], {'experience_activation_state': 'active', 'updated_at': fn__boundary_timestamp()}) |
| fn__update(sm, 'object_item', spec['object_id'], {'experience_activation_state': 'active', 'updated_at': fn__boundary_timestamp()}) |
| activated.append(spec['work_order']) |
| fn__update(sm, 'facility', config['facility_id'], {'experience_active_episode': episode['episode_id']}) |
| return {'schema': 'robot-experience-activation-public/v2', 'event_type': 'work_order_activation', 'episode_id': episode['episode_id'], 'work_orders': sorted(activated), 'policy_version': episode['public_policy_version'], 'created_object_ids': [], 'world_reset': False} |
|
|
| def fn_state_diff(before, after): |
| changes = [] |
| for table in DATA_STATE_TABLES: |
| (left, right) = (fn__row_index(before, table), fn__row_index(after, table)) |
| for identifier in sorted(set(left) | set(right)): |
| if left.get(identifier) != right.get(identifier): |
| changes.append({'table': table, 'id': identifier, 'before': ext_deepcopy(left.get(identifier)), 'after': ext_deepcopy(right.get(identifier))}) |
| return changes |
|
|
| def fn__digest_2(value): |
| payload = mod_json.dumps(value, sort_keys=True, ensure_ascii=True, separators=(',', ':')).encode('utf-8') |
| return mod_hashlib.sha256(payload).hexdigest() |
|
|
| def fn__drift_event_id(config): |
| drift = config['drift'] |
| payload = {'schema': 'robot-experience-drift-application/v1', 'facility_id': config['facility_id'], 'from_rule_epoch': drift['from_rule_epoch'], 'to_rule_epoch': drift['to_rule_epoch'], 'from_policy_version': drift['from_policy_version'], 'to_policy_version': drift['to_policy_version'], 'changed_cells': drift['changed_cells']} |
| return 'evt-' + fn__digest(payload)[:20] |
|
|
| def fn_opaque_event_id(work_orders): |
| """Derive a stable, non-sequential public ID from the public order set.""" |
| if not isinstance(work_orders, list) or not work_orders or any((not isinstance(value, str) or not value for value in work_orders)) or (len(set(work_orders)) != len(work_orders)): |
| raise ValueError('opaque event IDs require unique non-empty work orders') |
| payload = mod_json.dumps(['robot-final-public-event/v1', *sorted(work_orders)], ensure_ascii=True, separators=(',', ':')).encode('ascii') |
| return 'evt-' + mod_hashlib.sha256(payload).hexdigest()[:20] |
|
|
| def fn_assert_opaque_learner_surface(value, *, surface): |
| hits = fn_leakage_hits(value) |
| present = {name: rows for (name, rows) in hits.items() if rows} |
| if present: |
| raise ValueError(f'{surface} exposes private lifecycle metadata: {present}') |
| try: |
| ext_assert_hard_public_projection(value) |
| except ValueError as error: |
| raise ValueError(f'{surface} exposes private lifecycle metadata: {error}') from error |
|
|
| def fn_public_task_5(task_id): |
| task = fn_public_task_6(task_id) |
| if task_id == 'T01': |
| before = task['query'] |
| task['query'] = before.replace('The starting battery is 98 units', f'The starting battery is {93} units') |
| if task['query'] == before: |
| raise ValueError('Robot T01 public budget sentence changed upstream') |
| return task |
|
|
| def fn_digest_4(value): |
| return mod_hashlib.sha256(mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True).encode()).hexdigest() |
|
|
| def fn__validate_snapshot_extensions_2(snapshot): |
| if not isinstance(snapshot, dict) or set(snapshot) != DATA__SNAPSHOT_FIELDS_2: |
| raise ValueError('Robot v7 snapshot fields are incomplete or unexpected') |
| evidence = snapshot.get('transfer_evidence') |
| revalidation = snapshot.get('rule_revalidation') |
| if not isinstance(evidence, dict) or not isinstance(revalidation, dict): |
| raise ValueError('Robot v7 snapshot extensions must be objects') |
| profiles = set(fn__profiles()) |
| for (cell, row) in evidence.items(): |
| (handling, intake) = fn__validate_cell(cell) |
| if not isinstance(row, dict) or set(row) != DATA__TRANSFER_EVIDENCE_FIELDS: |
| raise ValueError(f'Robot v7 transfer evidence is malformed for {cell}') |
| if any((not isinstance(row[field], str) or not row[field] for field in row)): |
| raise ValueError(f'Robot v7 transfer evidence values must be strings for {cell}') |
| if row['task_id'] not in DATA_TASK_IDS or row['cell'] != cell: |
| raise ValueError(f'Robot v7 transfer evidence identity mismatch for {cell}') |
| if row['handling_code'] != handling or row['intake_code'] != intake: |
| raise ValueError(f'Robot v7 transfer evidence crosses exact cells for {cell}') |
| if row['profile'] not in profiles: |
| raise ValueError(f'Robot v7 transfer evidence profile is invalid for {cell}') |
| for (cell, state) in revalidation.items(): |
| fn__validate_cell(cell) |
| if cell not in evidence or state not in DATA_REVALIDATION_STATES: |
| raise ValueError(f'Robot v7 revalidation state is invalid for {cell}') |
|
|
| def fn__boundary_timestamp(): |
| return _BOUNDARY_TIME.get() |
|
|
| def fn__update(sm, table, identifier, changes): |
| sm.update_entity(table, identifier, changes, id_field=DATA_ID_FIELDS[table]) |
|
|
| def fn__row_index(state, table): |
| field = DATA_ID_FIELDS[table] |
| return {str(row[field]): row for row in state[table]} |
|
|
| def fn_leakage_hits(value): |
| """Report private lifecycle labels in a learner/provider-visible value.""" |
| encoded = mod_json.dumps(value, ensure_ascii=True, sort_keys=True, allow_nan=False) |
| private_keys: set[str] = set() |
|
|
| def visit(item): |
| if isinstance(item, dict): |
| private_keys.update((str(key) for key in item if key in DATA__PRIVATE_KEYS)) |
| for nested in item.values(): |
| visit(nested) |
| elif isinstance(item, list): |
| for nested in item: |
| visit(nested) |
| visit(value) |
| return {'private_episode_ids': sorted(set(_re.compile('(?<![A-Za-z0-9])T(?:0[1-9]|1[0-6])(?![A-Za-z0-9]|:[0-5][0-9])', 34).findall(encoded))), 'arm_labels': sorted(set(_re.compile('(?<![A-Za-z0-9])(?:native|reset|reflect)\\d{2}(?![A-Za-z0-9])', 34).findall(encoded))), 'run_paths': sorted(set(_re.compile('(?:benchmark_outputs[/\\\\]robot|robot-final-v\\d+[/\\\\]20\\d{6}-\\d{6})', 34).findall(encoded))), 'private_keys': sorted(private_keys)} |
|
|
| def fn_public_task_6(task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown Robot stream task: {task_id}') |
| return mod_json.loads((CASE_DIR / 'data/world' / f'public/tasks/{task_id}.json').read_text(encoding='utf-8')) |
|
|
| def fn__validate_rule_table(value): |
| table = ext_deepcopy(value if value is not None else fn_default_rule_table()) |
| expected = {f'{handling}:{intake}' for handling in DATA_HANDLING_CODES for intake in DATA_INTAKE_CODES} |
| if set(table) != expected or any((profile not in DATA_TRANSFER_PROFILES for profile in table.values())): |
| raise ValueError('rule_table must define every handling:intake cell') |
| return table |
|
|
| def fn__validate_cell(cell): |
| if not isinstance(cell, str) or cell.count(':') != 1: |
| raise ValueError('transfer evidence key must be an exact handling:intake cell') |
| (handling, intake) = cell.split(':', 1) |
| if not handling or not intake: |
| raise ValueError('transfer evidence cell components must be non-empty') |
| return (handling, intake) |
|
|
| def fn_default_rule_table(): |
| """Return the private finite relation used by the first candidate.""" |
| handling_rank = (2, 0, 3, 1) |
| intake_rank = (1, 3, 0, 2) |
| return {f'{handling}:{intake}': DATA_TRANSFER_PROFILES[(handling_rank[handling_index] + intake_rank[intake_index]) % len(DATA_TRANSFER_PROFILES)] for (handling_index, handling) in enumerate(DATA_HANDLING_CODES) for (intake_index, intake) in enumerate(DATA_INTAKE_CODES)} |
|
|
| def fn__strip_volatile(value): |
| if isinstance(value, dict): |
| return {key: fn__strip_volatile(item) for (key, item) in sorted(value.items()) if not key.endswith('_at')} |
| if isinstance(value, list): |
| return [fn__strip_volatile(item) for item in value] |
| return ext_deepcopy(value) |
|
|
| class World: |
|
|
| def __init__(self): |
| self.runtime = RobotSourceScopeRuntime() |
| self.t01_boundary = self.runtime.activate_task('T01') |
| self.t01_pending = True |
|
|
| def snapshot(self): |
| return {'schema': 'rescopebench-robot-rule-formal-world/v6', 'runtime': self.runtime.snapshot(), 't01_boundary': ext_deepcopy(self.t01_boundary), 't01_pending': self.t01_pending} |
|
|
| def restore(self, snapshot): |
| if not isinstance(snapshot, dict) or set(snapshot) != {'schema', 'runtime', 't01_boundary', 't01_pending'}: |
| raise ValueError('invalid Robot rule-v9 formal snapshot fields') |
| if snapshot.get('schema') != 'rescopebench-robot-rule-formal-world/v6': |
| raise ValueError('unsupported Robot rule-v9 formal snapshot') |
| if not isinstance(snapshot.get('t01_pending'), bool): |
| raise ValueError('Robot rule-v9 pending flag must be boolean') |
| self.runtime.restore(ext_deepcopy(snapshot['runtime'])) |
| self.t01_boundary = ext_deepcopy(snapshot['t01_boundary']) |
| self.t01_pending = snapshot['t01_pending'] |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot rule-v9 formal snapshot did not round trip') |
|
|
| def activate(self, task_id): |
| if task_id == 'T01' and self.t01_pending: |
| self.t01_pending = False |
| return ext_deepcopy(self.t01_boundary) |
| self.t01_pending = False |
| return self.runtime.activate_task(task_id) |
|
|
| def close(self): |
| self.runtime.close() |
|
|
| class RobotSourceScopeRuntime: |
|
|
| def _stage_retained_source(self, arguments): |
| result = self._robot_local_rule_runtime_stage_retained_source(arguments) |
| order = self._task_order(arguments.get('work_order', '')) |
| return fn_scoped_staging_result(result, (order or {}).get('stock_group')) |
|
|
| def _validate_restored_evidence_against_world(self): |
| try: |
| return self._robot_source_runtime_validate_restored_evidence_against_world() |
| except ValueError as error: |
| if str(error) != 'Robot v8 replacement state lacks a stale rejection': |
| raise |
| original = self.rule_revalidation |
| self.rule_revalidation = {cell: 'awaiting_exact_stale' if state == 'awaiting_replacement' else state for (cell, state) in original.items()} |
| try: |
| return self._robot_source_runtime_validate_restored_evidence_against_world() |
| finally: |
| self.rule_revalidation = original |
|
|
| def __init__(self, *args, **kwargs): |
| self._restoring_source = False |
| self._robot_route_runtime_init(*args, **kwargs) |
|
|
| def _task_order(self, work_order): |
| if self.current_task_id is None: |
| return None |
| return next((row for row in fn_episode_spec(self.current_task_id)['orders'] if row['work_order'] == work_order), None) |
|
|
| def activate_task(self, task_id): |
| receipt = self._robot_route_runtime_activate_task(task_id) |
| if int(task_id[1:]) >= 9: |
| with self.isolated_raw(): |
| self._relocate_stock() |
| return receipt |
|
|
| def _relocate_stock(self): |
| (adapter, moves) = (self.adapter, fn_destinations()) |
| facility = next((row for row in adapter._all('facility') if row['facility_id'] == mod_json.loads((CASE_DIR / 'data/assets/config.json').read_text())['facility_id'])) |
| if facility.get('stock_relocation_version') == 'robot-stock-relocation-evolution-v9': |
| return |
| rooms = {row['room_id']: ext_deepcopy(row) for row in adapter._all('room')} |
| stores = {unit['stock_group']: (room['room_id'], ext_deepcopy(unit)) for room in rooms.values() for unit in room.get('storage_units', [])} |
| targets = {} |
| for (group, destination) in moves.items(): |
| (old_room, old_unit) = stores[group] |
| target_group = next((key for key in moves if stores[key][0] == destination)) |
| target_unit = stores[target_group][1] |
| targets[group] = (old_room, old_unit['unit_id'], destination, target_unit['unit_id']) |
| unit = next((row for row in rooms[destination]['storage_units'] if row['unit_id'] == target_unit['unit_id'])) |
| unit['stock_group'] = group |
| unit['calibration_records'] = ext_deepcopy(old_unit['calibration_records']) |
| for destination in set(moves.values()): |
| adapter.sm.update_entity('room', destination, {'storage_units': rooms[destination]['storage_units']}, id_field='room_id') |
| for obj in adapter._all('object_item'): |
| move = targets.get(obj.get('stock_group')) |
| if move and obj.get('current_room_id') == move[0] and (obj.get('storage_unit_id') == move[1]) and (obj.get('handling_state') == 'stored') and (not obj.get('held_by_robot_id')): |
| adapter.sm.update_entity('object_item', obj['object_id'], {'current_room_id': move[2], 'storage_unit_id': move[3]}, id_field='object_id') |
| moved_tasks = {} |
| for task in adapter._all('service_task'): |
| target = moves.get(task.get('stock_group')) |
| position = task.get('experience_episode_id', '') |
| if target and position in {f'T{i:02}' for i in range(9, 17)}: |
| adapter.sm.update_entity('service_task', task['task_id'], {'source_room_id': target}, id_field='task_id') |
| moved_tasks[task['task_id']] = target |
| for step in adapter._all('task_step'): |
| if step['task_id'] in moved_tasks and step['step_type'] in {'navigate', 'pick'}: |
| adapter.sm.update_entity('task_step', step['step_id'], {'room_id': moved_tasks[step['task_id']]}, id_field='step_id') |
| adapter.sm.update_entity('facility', facility['facility_id'], {'stock_relocation_version': 'robot-stock-relocation-evolution-v9'}, id_field='facility_id') |
|
|
| def _open_storage(self, arguments): |
| result = self._robot_rule_successor_open_storage(arguments) |
| data = result.get('data', {}) |
| if result.get('status') == 'success' and data.get('matches_pending_stock_group'): |
| order = self._task_order(self._first_pending_work_order() or '') |
| group = (order or {}).get('stock_group') |
| prior = self.verified_stock_groups.get(group) |
| robot = self.adapter._robot() |
| room = self.adapter._room(robot['current_room_id']) |
| if prior and (prior['station'] != room['name'] or prior['storage_handle'] != arguments['storage_handle']): |
| del self.verified_stock_groups[group] |
| self.authorized_new_stock_group = group |
| self.provisional_stock_groups[group] = {'task_id': self.current_task_id, 'station': room['name'], 'storage_handle': arguments['storage_handle'], 'zone': self._room_zone(room['room_id'])} |
| data['binding_retention_status'] = 'provisional_until_work_order_closed' |
| return result |
|
|
| def snapshot(self): |
| value = self._robot_route_runtime_snapshot() |
| if not self._restoring_source: |
| value['source_relocation_contract'] = {'case_version': 'robot-stock-relocation-evolution-v9', 'design_sha256': mod_hashlib.sha256((CASE_DIR / 'data/assets/design.json').read_bytes()).hexdigest()} |
| return value |
|
|
| def restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'robot-stock-relocation-evolution-v9', 'design_sha256': mod_hashlib.sha256((CASE_DIR / 'data/assets/design.json').read_bytes()).hexdigest()} |
| if value.pop('source_relocation_contract', None) != expected: |
| raise ValueError('Robot source relocation identity differs') |
| self._restoring_source = True |
| try: |
| self._robot_route_runtime_restore(value) |
| finally: |
| self._restoring_source = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot source relocation snapshot did not round trip') |
|
|
| def _locate_order_zone(self, arguments): |
| before = self.authorized_new_stock_group |
| try: |
| response = self._robot_rule_successor_locate_order_zone(arguments) |
| except Exception: |
| self.authorized_new_stock_group = before |
| raise |
| if response.get('status') != 'success': |
| self.authorized_new_stock_group = before |
| return response |
|
|
| def dispatch(self, tool, arguments): |
| if tool == 'observe_self' and arguments == {}: |
| result = RobotSourceScopeRuntime._robot_rule_successor_dispatch(self, tool, arguments) |
| self._annotate_zone_response(tool, result) |
| return self._attach_call_budget(result) |
| if tool == 'read_work_order' and isinstance(arguments, dict) and (set(arguments) == {'work_order'}) and isinstance(arguments['work_order'], str) and (arguments['work_order'] in self._own_closeouts): |
| return self._attach_call_budget({'status': 'success', 'data': {'work_order': arguments['work_order'], 'confirmation_only': True, 'completion_receipt': ext_deepcopy(self._own_closeouts[arguments['work_order']])}, 'message': 'Previously committed closeout from this episode.'}) |
| result = self._robot_rule_successor_dispatch_2(tool, arguments) |
| if result.get('status') == 'success' and tool in {'finalize', 'execute_transfer_attempt'}: |
| receipt = result |
| if tool == 'execute_transfer_attempt': |
| receipt = next((r['result'] for r in result.get('data', {}).get('steps', []) if r['tool'] == 'finalize'), None) |
| if receipt is not None and receipt.get('status') == 'success': |
| self._own_closeouts[arguments['work_order']] = ext_deepcopy(receipt) |
| return result |
|
|
| def _prepare_episode(self, task_id): |
| return fn_prepare_episode(CASE_DIR / 'data/world', self.state_dir, task_id) |
|
|
| def _revalidation_error(self, tool, context): |
| return None |
|
|
| def _listed_orders(self): |
| if self.current_task_id is None: |
| return [] |
| return list(fn_public_task(self.current_task_id)['work_orders']) |
|
|
| def business_call_limit(self): |
| return DATA_BUSINESS_CALL_LIMITS.get(self.current_task_id, 36) |
|
|
| @staticmethod |
| def _valid_retained_arguments(arguments): |
| required = {'work_order', 'source_station', 'storage_handle', 'source_exit_handles'} |
| if set(arguments) != required: |
| return False |
| if not all((isinstance(arguments[key], str) for key in ('work_order', 'source_station', 'storage_handle'))): |
| return False |
| return all((isinstance(arguments[key], list) and len(arguments[key]) <= 16 and all((isinstance(handle, str) for handle in arguments[key])) for key in ('source_exit_handles',))) |
|
|
| def _attach_call_budget(self, result): |
| value = ext_deepcopy(result) |
| value['business_call_budget'] = {'used': self.business_call_count, 'limit': self.business_call_limit(), 'remaining': max(0, self.business_call_limit() - self.business_call_count)} |
| return value |
|
|
| def _first_pending_work_order(self): |
| if self.adapter is None: |
| return None |
| completed = {row['work_order']: bool(row['workflow_completed']) for row in self.adapter.grade()['orders']} |
| return next((work_order for work_order in self._listed_orders() if not completed.get(work_order, False)), None) |
|
|
| def _room_zone(self, room_id): |
| return fn__zone_for_room_id(room_id) |
|
|
| def _station_zone(self, station_name): |
| if self.adapter is None or not isinstance(station_name, str): |
| return None |
| room = next((row for row in self.adapter._all('room') if row.get('name') == station_name), None) |
| return self._room_zone((room or {}).get('room_id')) |
|
|
| def _zone_counts(self): |
| if self.adapter is None: |
| return {} |
| counts = {zone: 0 for zone in DATA_ZONE_ADJACENCY} |
| for room in self.adapter._all('room'): |
| zone = self._room_zone(room.get('room_id')) |
| if zone in counts and room.get('is_robot_accessible') is True: |
| counts[zone] += 1 |
| return counts |
|
|
| def _annotate_zone_response(self, tool, result): |
| if result.get('status') != 'success' or self.adapter is None: |
| return |
| data = result.get('data') or {} |
| if tool == 'observe_self': |
| room = data.get('current_room') or {} |
| room['zone'] = self._station_zone(room.get('name')) |
| return |
| if tool == 'scan_current_room': |
| robot = self.adapter._robot() or {} |
| room_id = robot.get('current_room_id') |
| room = data.get('room') or {} |
| room['zone'] = self._room_zone(room_id) |
| for exit_row in data.get('exits', []): |
| edge_id = self.adapter._edge_by_handle.get(exit_row.get('exit_handle')) |
| edge = self.adapter._get('map_edge', 'edge_id', edge_id) |
| destination_id = self.adapter._edge_destination(edge or {}, room_id) |
| exit_row['destination_zone'] = self._room_zone(destination_id) |
| pending = self._task_order(self._first_pending_work_order() or '') |
| object_name = (pending or {}).get('object_name') |
| data['objects'] = [row for row in data.get('objects', []) if row.get('display_name') == object_name] |
| return |
| if tool == 'traverse_known_exit': |
| for key in ('previous_room', 'current_room'): |
| room = data.get(key) |
| if isinstance(room, dict): |
| room['zone'] = self._station_zone(room.get('name')) |
| for segment in data.get('segments', []): |
| segment_data = segment.get('data') or {} |
| for key in ('previous_room', 'current_room'): |
| room = segment_data.get(key) |
| if isinstance(room, dict): |
| room['zone'] = self._station_zone(room.get('name')) |
|
|
| @staticmethod |
| def _visible_object_handles(value): |
| handles: set[str] = set() |
| if isinstance(value, dict): |
| handle = value.get('object_handle') |
| if isinstance(handle, str): |
| handles.add(handle) |
| for child in value.values(): |
| handles.update(RobotSourceScopeRuntime._visible_object_handles(child)) |
| elif isinstance(value, list): |
| for child in value: |
| handles.update(RobotSourceScopeRuntime._visible_object_handles(child)) |
| return handles |
|
|
| def _revoke_hidden_object_handles(self, before, result): |
| if self.adapter is None: |
| return |
| newly_issued = set(self.adapter.issued_object_handles) - before |
| visible = self._visible_object_handles(result.get('data') or {}) |
| self.adapter.issued_object_handles.difference_update(newly_issued - visible) |
|
|
| def _promote_completed_binding(self, work_order): |
| if self.adapter is None: |
| return |
| order = self._task_order(work_order) |
| if order is None: |
| return |
| completed = next((bool(row.get('workflow_completed')) for row in self.adapter.grade().get('orders', []) if row.get('work_order') == work_order), False) |
| stock_group = order.get('stock_group') |
| if completed and isinstance(stock_group, str): |
| evidence = self.provisional_stock_groups.pop(stock_group, None) |
| if evidence is not None: |
| self.verified_stock_groups.setdefault(stock_group, evidence) |
|
|
| @staticmethod |
| def _valid_execute_arguments(arguments): |
| required = {'work_order', 'object_handle', 'profile', 'delivery_exit_handles', 'closeout_exit_handles'} |
| if set(arguments) != required: |
| return False |
| if not all((isinstance(arguments[key], str) for key in ('work_order', 'object_handle', 'profile'))): |
| return False |
| if arguments['profile'] not in fn__profiles(): |
| return False |
| for key in ('delivery_exit_handles', 'closeout_exit_handles'): |
| value = arguments[key] |
| if not isinstance(value, list) or len(value) > 16 or any((not isinstance(row, str) for row in value)): |
| return False |
| return True |
|
|
| def _execute_transfer_attempt(self, arguments): |
| if not self._valid_execute_arguments(arguments): |
| return {'status': 'error', 'data': {}, 'message': 'INVALID_ARGUMENTS: arguments do not match the tool schema'} |
| work_order = arguments['work_order'] |
| reference = {'work_order': work_order} |
| steps: list[dict[str, ext_Any]] = [] |
| robot = self.adapter._robot() if self.adapter is not None else None |
| order = self.adapter._order(work_order) if self.adapter is not None else None |
| if robot is None or order is None: |
| return {'status': 'error', 'data': {'steps': steps}, 'message': 'WORK_ORDER_UNAVAILABLE: the requested work order is unavailable'} |
| if robot.get('active_task_id') is None: |
| assigned = self._robot_rule_successor_dispatch('assign_work_order', reference) |
| steps.append({'tool': 'assign_work_order', 'result': assigned}) |
| if assigned.get('status') != 'success': |
| return {'status': 'error', 'data': {'steps': steps}, 'message': assigned.get('message')} |
| elif robot.get('active_task_id') != order['task_id']: |
| return {'status': 'error', 'data': {'steps': steps}, 'message': 'ROBOT_BUSY: another work order is active'} |
| prepared = self._robot_rule_successor_dispatch('prepare_transfer', {**reference, 'profile': arguments['profile']}) |
| steps.append({'tool': 'prepare_transfer', 'result': prepared}) |
| if prepared.get('status') != 'success': |
| return {'status': 'error', 'data': {'steps': steps}, 'message': prepared.get('message')} |
| robot = self.adapter._robot() |
| if not robot.get('payload_object_id'): |
| picked = self._robot_rule_successor_dispatch('pickup', {**reference, 'object_handle': arguments['object_handle']}) |
| steps.append({'tool': 'pickup', 'result': picked}) |
| if picked.get('status') != 'success': |
| return {'status': 'error', 'data': {'steps': steps}, 'message': picked.get('message')} |
| delivery_handles = arguments['delivery_exit_handles'] |
| if delivery_handles: |
| moved = self._robot_rule_successor_dispatch('traverse_known_exit', {'exit_handles': delivery_handles}) |
| steps.append({'tool': 'traverse_known_exit', 'result': moved}) |
| if moved.get('status') != 'success': |
| return {'status': 'error', 'data': {'steps': steps}, 'message': moved.get('message')} |
| released = self._robot_rule_successor_dispatch('release', reference) |
| steps.append({'tool': 'release', 'result': released}) |
| if released.get('status') != 'success': |
| recovery = None |
| if delivery_handles: |
| recovery = self._robot_rule_successor_dispatch('traverse_known_exit', {'exit_handles': list(reversed(delivery_handles))}) |
| steps.append({'tool': 'return_to_source', 'result': recovery}) |
| message = str(released.get('message')) |
| if 'EXACT_STALE_TUPLE_REQUIRED' in message: |
| outcome = 'exact_stale_tuple_required' |
| elif 'INTAKE_REJECTED' in message: |
| outcome = 'intake_rejected' |
| else: |
| outcome = 'release_rejected' |
| return {'status': 'error', 'data': {'outcome': outcome, 'returned_to_source': bool(recovery is None or recovery.get('status') == 'success'), 'steps': steps}, 'message': released.get('message')} |
| closeout_handles = arguments['closeout_exit_handles'] |
| if closeout_handles: |
| returned = self._robot_rule_successor_dispatch('traverse_known_exit', {'exit_handles': closeout_handles}) |
| steps.append({'tool': 'traverse_known_exit', 'result': returned}) |
| if returned.get('status') != 'success': |
| return {'status': 'error', 'data': {'outcome': 'delivered_not_closed', 'steps': steps}, 'message': returned.get('message')} |
| finalized = self._robot_rule_successor_dispatch('finalize', reference) |
| steps.append({'tool': 'finalize', 'result': finalized}) |
| if finalized.get('status') != 'success': |
| return {'status': 'error', 'data': {'outcome': 'delivered_not_closed', 'steps': steps}, 'message': finalized.get('message')} |
| self._promote_completed_binding(work_order) |
| return {'status': 'success', 'data': {'outcome': 'workflow_completed', 'work_order': work_order, 'steps': steps}, 'message': 'OK'} |
|
|
| def grade(self): |
| raw = self._robot_rule_successor_grade() |
| completed = sum((bool(row['workflow_completed']) for row in raw['orders'])) |
| result = ext_deepcopy(raw) |
| result['diagnostic_partial_score'] = raw['score'] |
| result['score'] = 25.0 * completed |
| result['score_contract'] = '25 points per fully closed work order' |
| result['partial_milestones'] = 'diagnostic_only' |
| return result |
|
|
| def _priority_error(self, tool, arguments): |
| if tool not in DATA_ORDERED_MUTATIONS or self.adapter is None: |
| return None |
| if not self.adapter._schema_valid(tool, arguments): |
| return None |
| work_order = arguments.get('work_order') |
| listed = self._listed_orders() |
| if work_order not in listed: |
| return None |
| completed = {row['work_order']: bool(row['workflow_completed']) for row in self.adapter.grade()['orders']} |
| requested_index = listed.index(work_order) |
| pending = next((prior for prior in listed[:requested_index] if not completed.get(prior, False)), None) |
| if pending is None: |
| return None |
| return self.adapter._attempt(tool, lambda : {'status': 'error', 'data': {}, 'message': f'PRIORITY_WORK_ORDER_PENDING: an earlier listed work order must be fully closed first ({pending})'}) |
|
|
| def _release_context(self, arguments): |
| if self.adapter is None or not isinstance(arguments.get('work_order'), str): |
| return None |
| order = self.adapter._order(arguments['work_order']) |
| if order is None: |
| return None |
| (task, obj) = self.adapter._work_context(order) |
| if task is None or obj is None: |
| return None |
| handling = obj.get('handling_code') |
| intake = task.get('intake_code') |
| profile = task.get('transfer_profile_submitted') |
| if not all((isinstance(value, str) for value in (handling, intake, profile))): |
| return None |
| storage_handle = None |
| if isinstance(obj.get('storage_unit_id'), str): |
| storage_handle = self.adapter._handle('storage', obj['storage_unit_id']) |
| return {'task_id': self.current_task_id, 'work_order': arguments['work_order'], 'cell': f'{handling}:{intake}', 'handling_code': handling, 'intake_code': intake, 'profile': profile, 'stock_group': task.get('stock_group'), 'source_station': self.adapter._room_name(task.get('source_room_id')), 'destination_station': self.adapter._room_name(task.get('target_room_id')), 'storage_handle': storage_handle, 'object_name': obj.get('display_name')} |
|
|
| def _record_release(self, context, result): |
| if context is None: |
| return |
| cell = context['cell'] |
| state = self.rule_revalidation.get(cell) |
| if state == 'awaiting_exact_stale' and result.get('status') == 'error' and ('INTAKE_REJECTED' in str(result.get('message'))) and (context['profile'] == (self.transfer_evidence.get(cell) or {}).get('profile')): |
| self.rule_revalidation[cell] = 'awaiting_replacement' |
| return |
| if result.get('status') != 'success': |
| return |
| self.transfer_evidence[cell] = ext_deepcopy(context) |
| if state in {'awaiting_exact_stale', 'awaiting_replacement'}: |
| self.rule_revalidation[cell] = 'validated' |
|
|
| @contextmanager |
| def isolated_raw(self): |
| with ext_isolated_package_namespace(CASE_DIR / 'data/world/private/world/environment'): |
| yield |
|
|
| def checkpoint(self): |
| if self.adapter is None: |
| raise RuntimeError('activate a task before checkpointing') |
| with self.isolated_raw(): |
| return ext_deepcopy(fn_checkpoint_state(self.adapter, self.state_dir)) |
|
|
| def raw_database(self): |
| return ext_deepcopy(self.snapshot()['database']) |
|
|
| def close(self): |
| if self._temporary is not None: |
| self._temporary.cleanup() |
| self._temporary = None |
|
|
| def _robot_local_rule_runtime_stage_retained_source(self, arguments): |
| result = self._robot_rule_successor_stage_retained_source(arguments) |
| order = self._task_order(arguments.get('work_order', '')) |
| return fn_scoped_storage_diagnostics(result, (order or {}).get('object_name')) |
|
|
| def _robot_source_runtime_validate_restored_evidence_against_world(self): |
| if self.current_task_id is None or int(self.current_task_id[1:]) < 9: |
| return self._robot_rule_successor_validate_restored_evidence_against_world() |
| fields = ('verified_stock_groups', 'transfer_evidence', 'rule_revalidation', 'provisional_stock_groups') |
| original = {name: getattr(self, name) for name in fields} |
| adapter = self.adapter |
| moved = fn_destinations() |
| old_source = {key for (key, row) in original['verified_stock_groups'].items() if key in moved and row['task_id'] < 'T09'} |
| old_transfer = {key for (key, row) in original['transfer_evidence'].items() if row.get('stock_group') in moved and row['task_id'] < 'T09'} |
| try: |
| for historical in (False, True): |
| self.verified_stock_groups = {key: row for (key, row) in original['verified_stock_groups'].items() if (key in old_source) == historical} |
| self.transfer_evidence = {key: row for (key, row) in original['transfer_evidence'].items() if (key in old_transfer) == historical} |
| self.rule_revalidation = {key: row for (key, row) in original['rule_revalidation'].items() if key in self.transfer_evidence} |
| self.provisional_stock_groups = {} if historical else original['provisional_stock_groups'] |
| self.adapter = HistoricalStorageView(adapter) if historical else adapter |
| self._robot_rule_successor_validate_restored_evidence_against_world() |
| finally: |
| self.adapter = adapter |
| for (name, value) in original.items(): |
| setattr(self, name, value) |
|
|
| def _robot_route_runtime_init(self, *args, **kwargs): |
| self._restoring_route = False |
| self._robot_intake_runtime_init(*args, **kwargs) |
|
|
| def _robot_route_runtime_activate_task(self, task_id): |
| receipt = self._robot_intake_runtime_activate_task(task_id) |
| if int(task_id[1:]) >= DATA_CONTRACT['before_task']: |
| with self.isolated_raw(): |
| edge = next((row for row in self.adapter._all('map_edge') if row['edge_id'] == 'edge-atlas-north-ground-south-specimen-intake-to-level-one-central-return-sort')) |
| if edge['status'] != 'blocked': |
| self.adapter.sm.update_entity('map_edge', 'edge-atlas-north-ground-south-specimen-intake-to-level-one-central-return-sort', {'status': 'blocked'}, id_field='edge_id') |
| return receipt |
|
|
| def _robot_rule_successor_open_storage(self, arguments): |
| if self.adapter is None: |
| raise RuntimeError('activate a task before calling tools') |
| handle = arguments.get('storage_handle') |
| if not isinstance(handle, str): |
| return self._robot_rule_successor_dispatch('open_storage', arguments) |
| pending = self._task_order(self._first_pending_work_order() or '') |
| target_group = (pending or {}).get('stock_group') |
| resolved = self.adapter._storage(handle) |
| actual_group = resolved[1].get('stock_group') if resolved else None |
| authorized = actual_group in self.verified_stock_groups or (actual_group is not None and actual_group == self.authorized_new_stock_group) |
| if actual_group == target_group and (not authorized): |
| return self.adapter._attempt('open_storage', lambda : {'status': 'error', 'data': {}, 'message': 'SEARCH_SCOPE_NOT_AUTHORIZED: call locate_order_zone for the first pending listed order'}) |
| issued_before = set(self.adapter.issued_object_handles) |
| result = self._robot_rule_successor_dispatch('open_storage', arguments) |
| if result.get('status') != 'success': |
| self._revoke_hidden_object_handles(issued_before, result) |
| return result |
| data = result.get('data') or {} |
| if actual_group != target_group: |
| data.pop('stock_group', None) |
| data.pop('calibration_records', None) |
| data['objects'] = [] |
| data['matches_pending_stock_group'] = False |
| data['scope'] = 'current_priority_order' |
| self._revoke_hidden_object_handles(issued_before, result) |
| return result |
| object_name = (pending or {}).get('object_name') |
| data['objects'] = [row for row in data.get('objects', []) if row.get('display_name') == object_name] |
| data['matches_pending_stock_group'] = True |
| data['scope'] = 'current_priority_order' |
| data['binding_retention_status'] = 'retained_verified' if actual_group in self.verified_stock_groups else 'provisional_until_work_order_closed' |
| robot = self.adapter._robot() or {} |
| room = self.adapter._room(robot.get('current_room_id')) or {} |
| if isinstance(actual_group, str): |
| evidence = {'task_id': str(self.current_task_id), 'station': str(room.get('name')), 'storage_handle': handle, 'zone': str(self._room_zone(room.get('room_id')))} |
| if actual_group in self.verified_stock_groups: |
| self.verified_stock_groups.setdefault(actual_group, evidence) |
| else: |
| self.provisional_stock_groups.setdefault(actual_group, evidence) |
| self._revoke_hidden_object_handles(issued_before, result) |
| return result |
|
|
| def _robot_route_runtime_snapshot(self): |
| value = self._robot_intake_runtime_snapshot() |
| if not self._restoring_route: |
| value['route_migration_contract'] = ext_deepcopy(DATA_CONTRACT) |
| return value |
|
|
| def _robot_route_runtime_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| if value.pop('route_migration_contract', None) != DATA_CONTRACT: |
| raise ValueError('Robot route migration identity differs') |
| self._restoring_route = True |
| try: |
| self._robot_intake_runtime_restore(value) |
| finally: |
| self._restoring_route = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot route migration snapshot did not round trip') |
|
|
| def _robot_rule_successor_locate_order_zone(self, arguments): |
| spec = self._task_order(arguments.get('work_order', '')) |
| if spec is not None and spec['stock_group'] not in self.verified_stock_groups: |
| self.authorized_new_stock_group = None |
| result = self._robot_rule_successor_locate_order_zone_2(arguments) |
| if result.get('status') == 'success': |
| data = result.get('data') or {} |
| data.pop('new_stock_binding_limit', None) |
| return result |
|
|
| def _robot_rule_successor_dispatch(self, tool, arguments): |
| if self.adapter is None: |
| raise RuntimeError('activate a task before calling tools') |
| values = ext_deepcopy(arguments) |
| with self.isolated_raw(): |
| priority = self._priority_error(tool, values) |
| if priority is not None: |
| return ext_deepcopy(priority) |
| context = self._release_context(values) if tool == 'release' else None |
| revalidation = self._revalidation_error(tool, context) |
| if revalidation is not None: |
| return ext_deepcopy(revalidation) |
| result = ext_deepcopy(self.adapter.call(tool, values)) |
| if tool == 'release': |
| self._record_release(context, result) |
| return result |
|
|
| def _robot_rule_successor_dispatch_2(self, tool, arguments): |
| if self.adapter is None: |
| raise RuntimeError('activate a task before calling tools') |
| self.business_call_count += 1 |
| if self.business_call_count > self.business_call_limit(): |
| return self._attach_call_budget({'status': 'error', 'data': {}, 'message': 'BUSINESS_CALL_LIMIT_EXHAUSTED: no further business calls are available in this episode'}) |
| values = ext_deepcopy(arguments) |
| if tool == 'stage_retained_source': |
| result = self._stage_retained_source(values) |
| elif tool == 'locate_order_zone': |
| result = self._locate_order_zone(values) |
| elif tool == 'execute_transfer_attempt': |
| result = self._execute_transfer_attempt(values) |
| elif tool == 'open_storage': |
| result = self._open_storage(values) |
| else: |
| issued_before = set(self.adapter.issued_object_handles) if tool == 'scan_current_room' else set() |
| result = RobotSourceScopeRuntime._robot_rule_successor_dispatch(self, tool, values) |
| self._annotate_zone_response(tool, result) |
| if tool == 'scan_current_room': |
| self._revoke_hidden_object_handles(issued_before, result) |
| if tool == 'finalize' and result.get('status') == 'success': |
| work_order = values.get('work_order') |
| if isinstance(work_order, str): |
| self._promote_completed_binding(work_order) |
| self.visible_object_handles.update(self._visible_object_handles(result)) |
| return self._attach_call_budget(result) |
|
|
| def _robot_rule_successor_grade(self): |
| if self.adapter is None: |
| raise RuntimeError('activate a task before grading') |
| with self.isolated_raw(): |
| return ext_deepcopy(self.adapter.grade()) |
|
|
| def _robot_rule_successor_stage_retained_source(self, arguments): |
| if not self._valid_retained_arguments(arguments): |
| return {'status': 'error', 'data': {}, 'message': 'INVALID_ARGUMENTS: arguments do not match the tool schema'} |
| spec = self._task_order(arguments['work_order']) |
| evidence = self.verified_stock_groups.get((spec or {}).get('stock_group')) |
| if spec is None or evidence is None or evidence.get('station') != arguments['source_station'] or (evidence.get('storage_handle') != arguments['storage_handle']): |
| return {'status': 'error', 'data': {'outcome': 'retained_binding_mismatch'}, 'message': 'RETAINED_BINDING_MISMATCH: exact verified source evidence is required'} |
| source_handles = arguments['source_exit_handles'] |
| if source_handles: |
| moved = RobotSourceScopeRuntime._robot_rule_successor_dispatch(self, 'traverse_known_exit', {'exit_handles': source_handles}) |
| if moved.get('status') != 'success': |
| return {'status': 'error', 'data': {'outcome': 'source_route_stale', 'steps': [moved]}, 'message': moved.get('message')} |
| robot = self.adapter._robot() |
| room = self.adapter._room(robot.get('current_room_id')) if robot else None |
| if (room or {}).get('name') != arguments['source_station']: |
| return {'status': 'error', 'data': {'outcome': 'source_route_mismatch'}, 'message': 'SOURCE_ROUTE_MISMATCH: route did not reach retained station'} |
| issued_before = set(self.adapter.issued_object_handles) |
| opened = RobotSourceScopeRuntime._robot_rule_successor_dispatch(self, 'open_storage', {'storage_handle': arguments['storage_handle']}) |
| objects = (opened.get('data') or {}).get('objects') or [] |
| matches = [row for row in objects if row.get('display_name') == spec['object_name']] |
| if opened.get('status') != 'success' or len(matches) != 1: |
| self._revoke_hidden_object_handles(issued_before, {'data': {'objects': matches}}) |
| return {'status': 'error', 'data': {'outcome': 'retained_source_unavailable', 'steps': [opened]}, 'message': opened.get('message') or 'retained source object unavailable'} |
| object_row = matches[0] |
| self._revoke_hidden_object_handles(issued_before, {'data': {'objects': matches}}) |
| inspected = RobotSourceScopeRuntime._robot_rule_successor_dispatch(self, 'inspect_local_object', {'object_handle': object_row['object_handle']}) |
| if inspected.get('status') != 'success': |
| return {'status': 'error', 'data': {'outcome': 'retained_object_unavailable', 'steps': [opened, inspected]}, 'message': inspected.get('message')} |
| return {'status': 'success', 'data': {'outcome': 'retained_source_staged', 'retained_source': fn_public_retained_source_evidence(evidence), 'object': ext_deepcopy(object_row), 'inspection': ext_deepcopy(inspected.get('data') or {}), 'battery_percent': self.adapter._battery()}, 'message': 'OK'} |
|
|
| def _robot_rule_successor_validate_restored_evidence_against_world(runtime): |
| try: |
| RobotSourceScopeRuntime._robot_rule_successor_validate_restored_evidence_against_world_2(runtime) |
| except ValueError as error: |
| if str(error) != 'Robot v8 snapshot contains object handles absent from public evidence': |
| raise |
| current = DATA_TASK_IDS.index(runtime.current_task_id) |
| objects = {row.get('object_id') for row in runtime.adapter._all('object_item')} |
| ids = {row.get('object_id') for row in runtime.adapter._all('service_task') if row.get('experience_episode_id') in DATA_TASK_IDS[:current + 1]} |
| allowed = {runtime.adapter._handle('object', ident) for ident in ids & objects if isinstance(ident, str)} |
| visible = set(runtime.visible_object_handles) |
| if visible != set(runtime.adapter.issued_object_handles) or not visible <= allowed: |
| raise |
|
|
| def _robot_intake_runtime_init(self, *args, **kwargs): |
| self._own_closeouts = {} |
| self._restoring_evolution = False |
| self._robot_rule_successor_init(*args, **kwargs) |
|
|
| def _robot_intake_runtime_activate_task(self, task_id): |
| old = self.current_task_id |
| result = self._robot_rule_successor_activate_task(task_id) |
| if old != self.current_task_id: |
| self._own_closeouts = {} |
| return result |
|
|
| def _robot_intake_runtime_snapshot(self): |
| value = self._robot_rule_successor_snapshot() |
| if not self._restoring_evolution: |
| value['evolution_contract'] = {'case_version': 'robot-scope-reuse-evolution-v12', 'schedule': ext_deepcopy(DATA_SCHEDULE_2), 'config_sha256': mod_hashlib.sha256((CASE_DIR / 'data/world/private/config.json').read_bytes()).hexdigest()} |
| value['own_closeout_receipts'] = ext_deepcopy(self._own_closeouts) |
| return value |
|
|
| def _robot_intake_runtime_restore(self, snapshot): |
| value = ext_deepcopy(snapshot) |
| expected = {'case_version': 'robot-scope-reuse-evolution-v12', 'schedule': DATA_SCHEDULE_2, 'config_sha256': mod_hashlib.sha256((CASE_DIR / 'data/world/private/config.json').read_bytes()).hexdigest()} |
| if value.pop('evolution_contract', None) != expected: |
| raise ValueError('Robot intake-balanced contract differs') |
| receipts = value.pop('own_closeout_receipts') |
| self._restoring_evolution = True |
| try: |
| self._robot_rule_successor_restore(value) |
| finally: |
| self._restoring_evolution = False |
| self._own_closeouts = receipts |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot intake-balanced snapshot did not round trip') |
|
|
| def _robot_rule_successor_locate_order_zone_2(self, arguments): |
| if set(arguments) != {'work_order'} or not isinstance(arguments.get('work_order'), str): |
| return {'status': 'error', 'data': {}, 'message': 'INVALID_ARGUMENTS: arguments do not match the tool schema'} |
| work_order = arguments['work_order'] |
| pending = self._first_pending_work_order() |
| if work_order != pending: |
| return {'status': 'error', 'data': {'first_pending_work_order': pending}, 'message': 'PRIORITY_WORK_ORDER_PENDING: zone lookup is limited to the first pending listed work order'} |
| spec = self._task_order(work_order) |
| if spec is None: |
| return {'status': 'error', 'data': {}, 'message': 'WORK_ORDER_NOT_FOUND: the work-order reference is unknown'} |
| stock_group = spec['stock_group'] |
| retained = stock_group in self.verified_stock_groups |
| if not retained: |
| if self.authorized_new_stock_group is None: |
| self.authorized_new_stock_group = stock_group |
| elif self.authorized_new_stock_group != stock_group: |
| return {'status': 'error', 'data': {'new_stock_bindings_authorized': 1, 'new_stock_binding_limit': 1}, 'message': 'NEW_STOCK_BINDING_LIMIT: this episode already authorized one previously unseen stock binding'} |
| return {'status': 'success', 'data': {'work_order': work_order, 'source_zone': self._room_zone(spec['source']), 'destination_zone': self._room_zone(spec['target']), 'zone_adjacency': ext_deepcopy(DATA_ZONE_ADJACENCY), 'candidate_station_counts': self._zone_counts(), 'binding_status': 'retained_verified' if retained else 'new_authorized', 'exact_source_disclosed': False}, 'message': 'OK'} |
|
|
| def _robot_rule_successor_validate_restored_evidence_against_world_2(self): |
| if self.adapter is None or self.current_task_id is None: |
| raise ValueError('Robot v8 restore did not create an active world') |
| current_index = DATA_TASK_IDS.index(self.current_task_id) |
|
|
| def task_is_in_prefix(task_id): |
| return isinstance(task_id, str) and task_id in DATA_TASK_IDS and (DATA_TASK_IDS.index(task_id) <= current_index) |
| rooms = {row.get('room_id'): row for row in self.adapter._all('room')} |
| objects = {row.get('object_id'): row for row in self.adapter._all('object_item')} |
| service_tasks = self.adapter._all('service_task') |
|
|
| def storage_matches(stock_group, evidence): |
| resolved = self.adapter._storage(evidence['storage_handle']) |
| if resolved is None: |
| return False |
| (room, storage) = resolved |
| return bool(storage.get('stock_group') == stock_group and room.get('name') == evidence['station'] and (self._room_zone(room.get('room_id')) == evidence['zone'])) |
| for (stock_group, evidence) in self.verified_stock_groups.items(): |
| if not task_is_in_prefix(evidence['task_id']): |
| raise ValueError('Robot v8 verified stock evidence is from the future') |
| if not storage_matches(stock_group, evidence): |
| raise ValueError('Robot v8 verified stock evidence does not match storage') |
| completed = any((row.get('experience_episode_id') == evidence['task_id'] and row.get('stock_group') == stock_group and (row.get('status') == 'completed') and ((row.get('source_inspection_receipt') or {}).get('status') == 'verified') and ((rooms.get(row.get('source_room_id')) or {}).get('name') == evidence['station']) for row in service_tasks)) |
| if not completed: |
| raise ValueError('Robot v8 verified stock evidence lacks a completed work order') |
| pending_order = self._task_order(self._first_pending_work_order() or '') |
| for (stock_group, evidence) in self.provisional_stock_groups.items(): |
| if evidence['task_id'] != self.current_task_id: |
| raise ValueError('Robot v8 provisional stock evidence crossed tasks') |
| if stock_group != self.authorized_new_stock_group: |
| raise ValueError('Robot v8 provisional stock evidence lacks matching authorization') |
| if (pending_order or {}).get('stock_group') != stock_group: |
| raise ValueError('Robot v8 provisional stock evidence is not the current target') |
| if not storage_matches(stock_group, evidence): |
| raise ValueError('Robot v8 provisional stock evidence does not match storage') |
| current_groups = {row['stock_group'] for row in fn_episode_spec_5(self.current_task_id)['orders']} |
| if self.authorized_new_stock_group is not None and self.authorized_new_stock_group not in current_groups: |
| raise ValueError('Robot v8 stock authorization is outside the current task') |
| config = fn_load_config_2() |
| rule_epoch = str(self.adapter.snapshot().get('rule_epoch')) |
| rule_table = config['pre_rule_table'] if rule_epoch == config['drift']['from_rule_epoch'] else config['post_rule_table'] |
| for (cell, evidence) in self.transfer_evidence.items(): |
| if not task_is_in_prefix(evidence.get('task_id')): |
| raise ValueError('Robot v8 transfer evidence is from the future') |
| order_spec = next((row for row in fn_episode_spec_5(evidence['task_id'])['orders'] if row.get('work_order') == evidence.get('work_order')), None) |
| task = next((row for row in service_tasks if row.get('task_id') == (order_spec or {}).get('task_id')), None) |
| obj = objects.get((task or {}).get('object_id')) |
| source = rooms.get((task or {}).get('source_room_id')) |
| destination = rooms.get((task or {}).get('target_room_id')) |
| intake_receipt = (task or {}).get('intake_receipt') or {} |
| inspection = (task or {}).get('source_inspection_receipt') or {} |
| storage_ok = storage_matches(evidence.get('stock_group', ''), {'station': str(evidence.get('source_station')), 'storage_handle': str(evidence.get('storage_handle')), 'zone': str(self._room_zone((source or {}).get('room_id'))), 'task_id': str(evidence.get('task_id'))}) |
| if not (task is not None and obj is not None and (order_spec is not None) and (task.get('experience_episode_id') == evidence.get('task_id')) and (task.get('stock_group') == evidence.get('stock_group')) and (task.get('intake_code') == evidence.get('intake_code')) and (source is not None) and (source.get('name') == evidence.get('source_station')) and (destination is not None) and (destination.get('name') == evidence.get('destination_station')) and (obj.get('display_name') == evidence.get('object_name')) and (inspection.get('status') == 'verified') and (inspection.get('handling_code') == evidence.get('handling_code')) and (intake_receipt.get('status') == 'accepted') and (intake_receipt.get('profile') == evidence.get('profile')) and storage_ok): |
| raise ValueError(f'Robot v8 transfer evidence does not match business state for {cell}') |
| action_reasons = {str(row.get('reason')) for row in self.adapter.snapshot().get('action_ledger', [])} |
| for (cell, state) in self.rule_revalidation.items(): |
| evidence = self.transfer_evidence[cell] |
| evidence_task = evidence['task_id'] |
| (handling, intake) = cell.split(':', 1) |
| if current_index < DATA_TASK_IDS.index('T09'): |
| raise ValueError('Robot v8 revalidation state appeared before drift') |
| if state in {'awaiting_exact_stale', 'awaiting_replacement'}: |
| if not (evidence_task < 'T09' and handling in DATA_CHANGED_HANDLING_ATOMS and (config['pre_rule_table'][cell] == evidence['profile'])): |
| raise ValueError('Robot v8 stale revalidation evidence is invalid') |
| if state == 'awaiting_replacement' and 'INTAKE_REJECTED' not in action_reasons: |
| raise ValueError('Robot v8 replacement state lacks a stale rejection') |
| elif state == 'validated': |
| if not (evidence_task >= 'T09' and rule_table[cell] == evidence['profile']): |
| raise ValueError('Robot v8 validated revalidation state is invalid') |
| allowed_object_ids = set() |
| for row in service_tasks: |
| episode_id = row.get('experience_episode_id') |
| if not task_is_in_prefix(episode_id): |
| continue |
| if row.get('status') == 'completed' or (row.get('source_inspection_receipt') or {}).get('status') == 'verified': |
| allowed_object_ids.add(row.get('object_id')) |
| robot = self.adapter._robot() or {} |
| if isinstance(robot.get('payload_object_id'), str): |
| allowed_object_ids.add(robot['payload_object_id']) |
| if pending_order is not None: |
| allowed_object_ids.add(pending_order['object_id']) |
| allowed_handles = {self.adapter._handle('object', object_id) for object_id in allowed_object_ids if isinstance(object_id, str)} |
| issued_handles = set(self.adapter.issued_object_handles) |
| if issued_handles != self.visible_object_handles: |
| raise ValueError('Robot v8 object capability ledger differs from public visibility') |
| hidden_handles = self.visible_object_handles - allowed_handles |
| if hidden_handles: |
| raise ValueError('Robot v8 snapshot contains object handles absent from public evidence') |
|
|
| def _robot_rule_successor_init(self, state_dir=None, *, snapshot=None): |
| self._restoring_v8_snapshot = False |
| self._robot_rule_successor_init_2(state_dir=state_dir, snapshot=snapshot) |
|
|
| def _robot_rule_successor_activate_task(self, task_id): |
| receipt = self._robot_rule_successor_activate_task_2(task_id) |
| if receipt.get('already_prepared') is True: |
| return receipt |
| with self.isolated_raw(): |
| self.adapter._set_battery(170) |
| after = fn_semantic_state(self.adapter.sm) |
| receipt = ext_deepcopy(receipt) |
| recovery = receipt.get('supervisor_recovery') or {} |
| if isinstance(recovery.get('after'), dict): |
| recovery['after']['battery_percent'] = 170 |
| for change in receipt.get('changes', []): |
| if change.get('table') == 'robot_unit' and isinstance(change.get('after'), dict): |
| change['after'] = next((row for row in after['robot_unit'] if row['robot_id'] == change['id'])) |
| receipt['after_sha256'] = fn_digest_2(after) |
| if isinstance(receipt.get('public_notice'), str): |
| receipt['public_notice'] = mod_re.sub('with \\d+ battery units', f'with {170} battery units', receipt['public_notice']) |
| receipt['successor_budget_override'] = {'task_id': task_id, 'battery_units': 170, 'business_call_limit': self.business_call_limit(), 'basis': 'one physical allowance independent of stream position and rule epoch'} |
| return receipt |
|
|
| def _robot_rule_successor_snapshot(self): |
| value = self._robot_rule_successor_snapshot_2() |
| if self._restoring_v8_snapshot: |
| return value |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v9' |
| return value |
|
|
| def _robot_rule_successor_restore(self, snapshot): |
| if not isinstance(snapshot, dict) or snapshot.get('schema') != 'rescopebench-robot-rule-runtime-snapshot/v9': |
| raise ValueError('unsupported Robot rule v9 snapshot') |
| value = ext_deepcopy(snapshot) |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v8' |
| self._restoring_v8_snapshot = True |
| try: |
| self._robot_rule_successor_restore_2(value) |
| finally: |
| self._restoring_v8_snapshot = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot rule v9 snapshot did not round trip') |
|
|
| def _robot_rule_successor_init_2(self, state_dir=None, *, snapshot=None): |
| self.business_call_count = 0 |
| self.authorized_new_stock_group: str | None = None |
| self.provisional_stock_groups: dict[str, dict[str, str]] = {} |
| self.verified_stock_groups: dict[str, dict[str, str]] = {} |
| self.visible_object_handles: set[str] = set() |
| self._restoring_v7_snapshot = False |
| self._robot_rule_successor_init_3(state_dir=state_dir, snapshot=snapshot) |
|
|
| def _robot_rule_successor_activate_task_2(self, task_id): |
| receipt = self._robot_rule_successor_activate_task_3(task_id) |
| if receipt.get('already_prepared') is not True: |
| budget = DATA_EPISODE_BUDGETS[task_id] |
| with self.isolated_raw(): |
| self.adapter._set_battery(budget) |
| receipt = ext_deepcopy(receipt) |
| recovery = receipt.get('supervisor_recovery') or {} |
| if isinstance(recovery.get('after'), dict): |
| recovery['after']['battery_percent'] = budget |
| for change in receipt.get('changes', []): |
| if change.get('table') == 'robot_unit' and isinstance(change.get('after'), dict): |
| change['after']['battery_percent'] = budget |
| notice = receipt.get('public_notice') |
| if isinstance(notice, str): |
| receipt['public_notice'] = mod_re.sub('with \\d+ battery units', f'with {budget} battery units', notice) |
| receipt['successor_budget_override'] = {'task_id': task_id, 'battery_units': budget, 'business_call_limit': self.business_call_limit(), 'basis': 'uniform post-cold physical envelope with public call frontier'} |
| return receipt |
|
|
| def _robot_rule_successor_snapshot_2(self): |
| value = self._robot_rule_successor_snapshot_3() |
| if self._restoring_v7_snapshot: |
| return value |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v8' |
| value['business_call_count'] = self.business_call_count |
| value['authorized_new_stock_group'] = self.authorized_new_stock_group |
| value['provisional_stock_groups'] = ext_deepcopy(self.provisional_stock_groups) |
| value['verified_stock_groups'] = ext_deepcopy(self.verified_stock_groups) |
| value['visible_object_handles'] = sorted(self.visible_object_handles) |
| return value |
|
|
| def _robot_rule_successor_restore_2(self, snapshot): |
| if not isinstance(snapshot, dict) or snapshot.get('schema') != 'rescopebench-robot-rule-runtime-snapshot/v8': |
| raise ValueError('unsupported Robot rule v8 snapshot') |
| fn__validate_snapshot_extensions(snapshot) |
| value = ext_deepcopy(snapshot) |
| self.business_call_count = value.pop('business_call_count') |
| self.authorized_new_stock_group = value.pop('authorized_new_stock_group') |
| self.provisional_stock_groups = value.pop('provisional_stock_groups') |
| self.verified_stock_groups = value.pop('verified_stock_groups') |
| self.visible_object_handles = set(value.pop('visible_object_handles')) |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v7' |
| self._restoring_v7_snapshot = True |
| try: |
| self._robot_rule_successor_restore_3(value) |
| finally: |
| self._restoring_v7_snapshot = False |
| self._validate_restored_evidence_against_world() |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot rule v8 snapshot did not round trip') |
|
|
| def _robot_rule_successor_init_3(self, state_dir=None, *, snapshot=None): |
| self._restoring_v6_snapshot = False |
| self._robot_rule_successor_init_4(state_dir=state_dir, snapshot=snapshot) |
|
|
| def _robot_rule_successor_activate_task_3(self, task_id): |
| receipt = self._robot_rule_successor_activate_task_4(task_id) |
| if receipt.get('already_prepared') is not True: |
| self.business_call_count = 0 |
| self.authorized_new_stock_group = None |
| self.provisional_stock_groups = {} |
| budget = DATA_EPISODE_BUDGETS_2[task_id] |
| with self.isolated_raw(): |
| self.adapter._set_battery(budget) |
| receipt = ext_deepcopy(receipt) |
| recovery = receipt.get('supervisor_recovery') or {} |
| if isinstance(recovery.get('after'), dict): |
| recovery['after']['battery_percent'] = budget |
| for change in receipt.get('changes', []): |
| if change.get('table') == 'robot_unit' and isinstance(change.get('after'), dict): |
| change['after']['battery_percent'] = budget |
| notice = receipt.get('public_notice') |
| if isinstance(notice, str): |
| receipt['public_notice'] = mod_re.sub('with \\d+ battery units', f'with {budget} battery units', notice) |
| receipt['successor_budget_override'] = {'task_id': task_id, 'battery_units': budget, 'business_call_limit': 32, 'new_stock_binding_limit': 1, 'basis': 'full informed replay plus worst-order bounded zone search'} |
| return receipt |
|
|
| def _robot_rule_successor_snapshot_3(self): |
| value = self._robot_rule_successor_snapshot_4() |
| if self._restoring_v6_snapshot: |
| return value |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v7' |
| return value |
|
|
| def _robot_rule_successor_restore_3(self, snapshot): |
| if not isinstance(snapshot, dict) or snapshot.get('schema') != 'rescopebench-robot-rule-runtime-snapshot/v7': |
| raise ValueError('unsupported Robot rule v7 snapshot') |
| fn__validate_snapshot_extensions_2(snapshot) |
| value = ext_deepcopy(snapshot) |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v6' |
| self._restoring_v6_snapshot = True |
| try: |
| self._robot_rule_successor_restore_4(value) |
| finally: |
| self._restoring_v6_snapshot = False |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot rule v7 snapshot did not round trip') |
|
|
| def _robot_rule_successor_init_4(self, state_dir=None, *, snapshot=None): |
| self.transfer_evidence: dict[str, dict[str, ext_Any]] = {} |
| self.rule_revalidation: dict[str, str] = {} |
| self._restoring_parent_snapshot = False |
| self._robot_rule_successor_init_5(state_dir=state_dir, snapshot=snapshot) |
|
|
| def _robot_rule_successor_activate_task_4(self, task_id): |
| receipt = self._robot_rule_successor_activate_task_5(task_id) |
| if task_id != 'T01' or receipt.get('already_prepared') is True: |
| return receipt |
| with self.isolated_raw(): |
| self.adapter._set_battery(72) |
| receipt = ext_deepcopy(receipt) |
| recovery = receipt.get('supervisor_recovery') or {} |
| if isinstance(recovery.get('after'), dict): |
| recovery['after']['battery_percent'] = 72 |
| for change in receipt.get('changes', []): |
| if change.get('table') == 'robot_unit' and isinstance(change.get('after'), dict): |
| change['after']['battery_percent'] = 72 |
| notice = receipt.get('public_notice') |
| if isinstance(notice, str): |
| receipt['public_notice'] = notice.replace(f'with {93} battery units', f'with {72} battery units') |
| receipt['successor_budget_override'] = {'task_id': 'T01', 'battery_units': 72, 'basis': 'provider-free cold cap plus honest weighted cost intervals'} |
| return receipt |
|
|
| def _robot_rule_successor_snapshot_4(self): |
| value = self._robot_rule_successor_snapshot_5() |
| if self._restoring_parent_snapshot: |
| return value |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v6' |
| value['transfer_evidence'] = ext_deepcopy(self.transfer_evidence) |
| value['rule_revalidation'] = ext_deepcopy(self.rule_revalidation) |
| return value |
|
|
| def _robot_rule_successor_restore_4(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-robot-rule-runtime-snapshot/v6': |
| raise ValueError('unsupported Robot rule v6 snapshot') |
| value = ext_deepcopy(snapshot) |
| self.transfer_evidence = ext_deepcopy(value.pop('transfer_evidence', {})) |
| self.rule_revalidation = ext_deepcopy(value.pop('rule_revalidation', {})) |
| value['schema'] = 'rescopebench-robot-rule-runtime-snapshot/v4' |
| self._restoring_parent_snapshot = True |
| try: |
| self._robot_rule_successor_restore_5(value) |
| finally: |
| self._restoring_parent_snapshot = False |
|
|
| def _robot_rule_successor_init_5(self, state_dir=None, *, snapshot=None): |
| self._temporary = None |
| if state_dir is None: |
| self._temporary = mod_tempfile.TemporaryDirectory(prefix='robot-rule-v4-') |
| state_dir = ext_Path(self._temporary.name) / 'state' |
| self.state_dir = ext_Path(state_dir).resolve() |
| self.current_task_id: str | None = None |
| self.adapter = None |
| if snapshot is not None: |
| self.restore(snapshot) |
|
|
| def _robot_rule_successor_activate_task_5(self, task_id): |
| receipt = self._robot_rule_successor_activate_task_6(task_id) |
| if task_id == 'T09': |
| for (cell, evidence) in self.transfer_evidence.items(): |
| handling = cell.split(':', 1)[0] |
| if handling in DATA_CHANGED_HANDLING_ATOMS and evidence.get('task_id', 'T99') < 'T09': |
| self.rule_revalidation.setdefault(cell, 'awaiting_exact_stale') |
| return receipt |
|
|
| def _robot_rule_successor_snapshot_5(self): |
| if self.adapter is None or self.current_task_id is None: |
| raise RuntimeError('activate a task before snapshotting') |
| with self.isolated_raw(): |
| fn_checkpoint_state(self.adapter, self.state_dir) |
| adapter_state = ext_deepcopy(self.adapter.snapshot()) |
| database = {path.name: mod_json.loads(path.read_text(encoding='utf-8')) for path in sorted((self.state_dir / 'database').glob('*.json'))} |
| return {'schema': 'rescopebench-robot-rule-runtime-snapshot/v4', 'task_id': self.current_task_id, 'database': database, 'adapter': adapter_state} |
|
|
| def _robot_rule_successor_restore_5(self, snapshot): |
| if snapshot.get('schema') != 'rescopebench-robot-rule-runtime-snapshot/v4': |
| raise ValueError('unsupported Robot rule successor snapshot') |
| task_id = snapshot.get('task_id') |
| if task_id not in DATA_TASK_IDS or not isinstance(snapshot.get('database'), dict): |
| raise ValueError('invalid Robot rule successor snapshot') |
| if self.state_dir.exists(): |
| mod_shutil.rmtree(self.state_dir) |
| database_dir = self.state_dir / 'database' |
| database_dir.mkdir(parents=True) |
| for (name, value) in snapshot['database'].items(): |
| if ext_Path(name).name != name or not name.endswith('.json'): |
| raise ValueError('snapshot database contains an invalid file name') |
| (database_dir / name).write_text(mod_json.dumps(value, ensure_ascii=True, indent=2, sort_keys=True) + '\n', encoding='utf-8') |
| adapter_state = ext_deepcopy(snapshot.get('adapter') or {}) |
| ledger = adapter_state.get('observation_ledger') |
| if not isinstance(ledger, dict): |
| raise ValueError('snapshot is missing its observation ledger') |
| (self.state_dir / 'observation-ledger.json').write_text(mod_json.dumps(ledger, ensure_ascii=True, indent=2, sort_keys=True) + '\n', encoding='utf-8') |
| with self.isolated_raw(): |
| self.adapter = fn_restore_adapter(CASE_DIR / 'data/world', self.state_dir, task_id) |
| self.adapter._actions = ext_deepcopy(adapter_state.get('action_ledger', [])) |
| self.adapter._next_action_index = 1 + max((int(row.get('index', 0)) for row in self.adapter._actions), default=0) |
| metering = adapter_state.get('episode_metering') or {} |
| self.adapter._scanned_rooms_this_episode = set(metering.get('scanned_room_ids', [])) |
| self.adapter._accessed_storage_this_episode = set(metering.get('accessed_storage_handles', [])) |
| self.current_task_id = task_id |
| if self.snapshot() != snapshot: |
| raise ValueError('Robot rule successor snapshot did not round trip') |
|
|
| def _robot_rule_successor_activate_task_6(self, task_id): |
| receipt = self._robot_rule_successor_activate_task_7(task_id) |
| if task_id != 'T01' or receipt.get('already_prepared') is True: |
| return receipt |
| with self.isolated_raw(): |
| self.adapter._set_battery(93) |
| receipt = ext_deepcopy(receipt) |
| recovery = receipt.get('supervisor_recovery') or {} |
| if isinstance(recovery.get('after'), dict): |
| recovery['after']['battery_percent'] = 93 |
| for change in receipt.get('changes', []): |
| if change.get('table') == 'robot_unit' and isinstance(change.get('after'), dict): |
| change['after']['battery_percent'] = 93 |
| notice = receipt.get('public_notice') |
| if isinstance(notice, str): |
| receipt['public_notice'] = notice.replace('with 98 battery units', f'with {93} battery units') |
| receipt['successor_budget_override'] = {'task_id': 'T01', 'battery_units': 93, 'basis': 'deterministic action-cost frontier'} |
| return receipt |
|
|
| def _robot_rule_successor_activate_task_7(self, task_id): |
| if task_id not in DATA_TASK_IDS: |
| raise ValueError(f'unknown Robot stream task: {task_id}') |
| with self.isolated_raw(): |
| if self.adapter is not None and self.current_task_id != task_id: |
| fn_checkpoint_state(self.adapter, self.state_dir) |
| (self.adapter, receipt) = self._prepare_episode(task_id) |
| self.current_task_id = task_id |
| return ext_deepcopy(receipt) |
|
|
| class HistoricalStorageView: |
|
|
| def __init__(self, adapter): |
| self.adapter = adapter |
| source = CASE_DIR / 'data/assets/rooms.json' |
| self.units = {unit['unit_id']: unit for room in mod_json.loads(source.read_text()) for unit in room.get('storage_units', [])} |
|
|
| def __getattr__(self, name): |
| return getattr(self.adapter, name) |
|
|
| def _storage(self, handle): |
| found = self.adapter._storage(handle) |
| if found is None: |
| return None |
| (room, unit) = found |
| historical = self.units.get(unit['unit_id']) |
| return (room, {**unit, 'stock_group': historical['stock_group']}) if historical else found |
|
|
| class RobotExperienceStreamAdapter: |
|
|
| def __init__(self, *args, **kwargs): |
| self._robot_experience_stream_adapter_init(*args, **kwargs) |
| self.tools = ext_deepcopy(DATA_TOOLS_3) |
|
|
| def traverse_known_exit(self, exit_handle=None, exit_handles=None): |
| if exit_handles is None: |
| return self._robot_state_action_adapter_traverse_known_exit(exit_handle) |
| segments = [] |
| total_cost = 0 |
| for (index, handle) in enumerate(exit_handles, 1): |
| result = self._robot_state_action_adapter_traverse_known_exit(handle) |
| data = ext_deepcopy(result.get('data') or {}) |
| total_cost += int(data.get('battery_cost') or 0) |
| segments.append({'index': index, 'exit_handle': handle, 'status': result.get('status'), 'message': result.get('message'), 'data': data}) |
| if result.get('status') != 'success': |
| return fn__error(fn__code(result), 'known-route execution stopped at the first failed edge', {'requested_segments': len(exit_handles), 'completed_segments': index - 1, 'stopped_at_index': index, 'segments': segments, 'battery_percent': self._battery(), 'battery_cost': total_cost}) |
| return fn__success({'requested_segments': len(exit_handles), 'completed_segments': len(exit_handles), 'stopped_at_index': None, 'segments': segments, 'battery_percent': self._battery(), 'battery_cost': total_cost}) |
|
|
| def call(self, name, arguments): |
| if name != 'traverse_known_exit': |
| return self._robot_experience_adapter_call(name, arguments) |
| try: |
| mod_jsonschema.validate(arguments, DATA__TRAVERSE_PARAMETERS) |
| except mod_jsonschema.ValidationError: |
| return self._finish(name, fn__error('INVALID_ARGUMENTS', 'arguments do not match the tool schema')) |
| has_single = 'exit_handle' in arguments |
| has_batch = 'exit_handles' in arguments |
| if has_single == has_batch: |
| return self._finish(name, fn__error('INVALID_ARGUMENTS', 'provide exactly one of exit_handle or exit_handles')) |
| return self.traverse_known_exit(**ext_deepcopy(arguments)) |
|
|
| def snapshot(self): |
| state = self._robot_experience_stream_adapter_snapshot() |
| state['schema'] = 'robot-experience-stream-snapshot/v4' |
| return state |
|
|
| def _scan_observation(self): |
| robot = self._robot() |
| room = self._room((robot or {}).get('current_room_id')) |
| if not robot or not room: |
| return fn__error('CURRENT_ROOM_NOT_FOUND', 'the controlled robot has no valid current room') |
| room_id = room['room_id'] |
| exits = [] |
| for edge in sorted(self._all('map_edge'), key=lambda row: row.get('edge_id', '')): |
| destination = self._edge_destination(edge, room_id) |
| if not destination: |
| continue |
| handle = self._handle('exit', edge['edge_id']) |
| self.issued_exit_handles.add(handle) |
| exits.append({'exit_handle': handle, 'route_type': edge.get('route_type'), 'distance_m': edge.get('distance_m'), 'status': 'open' if self._edge_usable(edge, destination) else 'blocked'}) |
| units = [] |
| for unit in sorted(room.get('storage_units', []), key=lambda row: row['unit_id']): |
| handle = self._handle('storage', unit['unit_id']) |
| self.issued_storage_handles.add(handle) |
| units.append({'storage_handle': handle, 'display_name': unit.get('display_name') or f'Storage-{handle[-8:].upper()}', 'access_state': 'open' if unit.get('opened') else 'closed'}) |
| objects = [] |
| for obj in sorted(self._all('object_item'), key=lambda row: row.get('object_id', '')): |
| if not self._object_visible_in_room(obj, room_id): |
| continue |
| handle = self._handle('object', obj['object_id']) |
| self.issued_object_handles.add(handle) |
| objects.append({'object_handle': handle, 'display_name': obj.get('display_name'), 'handling_state': obj.get('handling_state'), 'actionable': self._active_handle(handle)}) |
| peers = [] |
| for peer in sorted(self._all('robot_unit'), key=lambda row: row.get('robot_id', '')): |
| if peer.get('robot_id') == self.robot_id or peer.get('current_room_id') != room_id: |
| continue |
| robot_handle = self._handle('robot', peer['robot_id']) |
| self.issued_robot_handles.add(robot_handle) |
| peers.append({'robot_handle': robot_handle, 'display_name': peer.get('display_name'), 'operational_status': peer.get('operational_status')}) |
| obstacles = [{'obstacle_type': row.get('obstacle_type'), 'severity': row.get('severity')} for row in sorted(self._all('obstacle'), key=lambda item: item.get('obstacle_id', '')) if row.get('room_id') == room_id and row.get('status') == 'active'] |
| condition = self._condition(room_id) |
| return fn__success({'room': {'name': room.get('name')}, 'room_state': {'access_state': (condition or {}).get('access_state'), 'occupancy': (condition or {}).get('occupancy')}, 'peers': peers, 'storage_units': units, 'objects': objects, 'active_obstacles': obstacles, 'exits': exits}) |
|
|
| def scan_current_room(self): |
| robot = self._robot() |
| room_id = (robot or {}).get('current_room_id') |
| if not isinstance(room_id, str): |
| return self._finish('scan_current_room', self._scan_observation()) |
| if room_id in self._scanned_rooms_this_episode: |
| result = self._scan_observation() |
| result.setdefault('data', {}).update({'battery_percent': self._battery(), 'battery_cost': 0}) |
| return self._finish('scan_current_room', result) |
| result = self._attempt('scan_current_room', self._scan_observation) |
| if result.get('status') == 'success': |
| self._scanned_rooms_this_episode.add(room_id) |
| return result |
|
|
| def open_storage(self, storage_handle): |
| if not isinstance(storage_handle, str) or storage_handle not in self.issued_storage_handles: |
| return self._finish('open_storage', fn__error('STORAGE_NOT_OBSERVED', 'scan the local room before accessing a storage unit')) |
| resolved = self._storage(storage_handle) |
| robot = self._robot() |
| if resolved is None or not robot or resolved[0].get('room_id') != robot.get('current_room_id'): |
| return self._finish('open_storage', fn__error('STORAGE_NOT_LOCAL', 'the storage unit is not in the current room')) |
|
|
| def access(): |
| current = self._storage(storage_handle) |
| if current is None: |
| return fn__error('STORAGE_NOT_FOUND', 'the storage unit is unavailable') |
| (current_room, current_unit) = current |
| if current_unit.get('opened') is not True: |
| current_unit['opened'] = True |
| current_room['storage_units'] = [current_unit if row.get('unit_id') == current_unit['unit_id'] else row for row in current_room.get('storage_units', [])] |
| self._save('room', current_room) |
| return fn__success(self._storage_view(current_room, current_unit)) |
| if storage_handle in self._accessed_storage_this_episode: |
| result = access() |
| result.setdefault('data', {}).update({'battery_percent': self._battery(), 'battery_cost': 0}) |
| return self._finish('open_storage', result) |
| result = self._attempt('open_storage', access) |
| if result.get('status') == 'success': |
| self._accessed_storage_this_episode.add(storage_handle) |
| return result |
|
|
| def read_work_order(self, work_order): |
| result = self._robot_experience_stream_adapter_read_work_order(work_order) |
| if result.get('status') == 'success': |
| result.get('data', {}).pop('policy_version', None) |
| return result |
|
|
| def public_snapshot(self): |
| """Return a minimal learner-safe projection of current runtime state. |
| |
| This is intentionally not a reload format. In particular, it exposes |
| episode-local metering counts rather than private room IDs or a cache that |
| a later adapter could silently restore. |
| """ |
| robot = self._robot() or {} |
| room = self._room(robot.get('current_room_id')) |
| active_work_order = next((work_order for (work_order, order) in self._orders.items() if order['task_id'] == robot.get('active_task_id')), None) |
| return {'schema': 'robot-experience-stream-public-snapshot/v1', 'robot': {'operational_status': robot.get('operational_status'), 'battery_percent': int(robot.get('battery_percent') or 0), 'current_room_name': (room or {}).get('name'), 'active_work_order': active_work_order, 'carrying_payload': robot.get('payload_object_id') is not None}, 'work_orders': sorted(self._orders), 'episode_metering': {'rooms_scanned': len(self._scanned_rooms_this_episode), 'storage_units_accessed': len(self._accessed_storage_this_episode), 'cache_scope': 'current_adapter_instance'}, 'actions': ext_deepcopy(self._actions)} |
|
|
| def _active_handle(self, object_handle): |
| return isinstance(object_handle, str) and self._object_by_handle.get(object_handle) in self.active_object_ids |
|
|
| def _storage_view(self, room, unit): |
| result = self._robot_experience_adapter_storage_view(room, unit) |
| for row in result['objects']: |
| row['actionable'] = self._active_handle(row['object_handle']) |
| return result |
|
|
| def inspect_local_object(self, object_handle): |
| if not self._active_handle(object_handle): |
| return self._finish('inspect_local_object', fn__error('OBJECT_NOT_IN_ACTIVE_EPISODE', 'the parcel is visible but its private attributes are not actionable now')) |
| return self._robot_experience_adapter_inspect_local_object(object_handle) |
|
|
| def pickup(self, work_order, object_handle): |
| if not self._active_handle(object_handle): |
| return self._finish('pickup', fn__error('OBJECT_NOT_IN_ACTIVE_EPISODE', 'the parcel is visible but cannot be moved in this episode')) |
| return self._robot_experience_adapter_pickup(work_order, object_handle) |
|
|
| def import_observation_ledger(self, ledger): |
| """Restore learned handles without allowing memory to mutate physical state.""" |
| if not isinstance(ledger, dict): |
| raise ValueError('observation ledger must be an object') |
| opened = ledger.get('opened_storage_handles', []) |
| if not isinstance(opened, list) or not all((isinstance(value, str) for value in opened)): |
| raise ValueError('opened_storage_handles must be a list of strings') |
| physically_open = {handle for handle in self._storage_by_handle if (resolved := self._storage(handle)) is not None and resolved[1].get('opened') is True} |
| sanitized = ext_deepcopy(ledger) |
| sanitized['opened_storage_handles'] = sorted(set(opened) & physically_open) |
| counts = self._robot_experience_adapter_import_observation_ledger(sanitized) |
| counts['stale_opened_storage_handles_rejected'] = len(set(opened) - physically_open) |
| return counts |
|
|
| def grade(self): |
| result = self._robot_experience_adapter_grade() |
| result['public_components'] = {f"{row['work_order']}:{name}": {'correct': int(row[name]), 'total': 1} for row in result['orders'] for name in ('source_verified', 'transfer_authorized', 'custody_obtained', 'physical_delivery', 'workflow_completed')} |
| return result |
|
|
| def _storage(self, storage_handle): |
| binding = self._storage_by_handle.get(storage_handle) |
| if binding is None: |
| return None |
| room = self._room(binding[0]) |
| if not room: |
| return None |
| unit = next((row for row in room.get('storage_units', []) if row.get('unit_id') == binding[1]), None) |
| return (room, unit) if unit else None |
|
|
| def _storage_for_object(self, obj): |
| unit_id = obj.get('storage_unit_id') |
| if not unit_id: |
| return None |
| for room in self._all('room'): |
| unit = next((row for row in room.get('storage_units', []) if row.get('unit_id') == unit_id), None) |
| if unit: |
| return (room, unit) |
| return None |
|
|
| def _object_visible_in_room(self, obj, room_id): |
| if obj.get('held_by_robot_id') or obj.get('current_room_id') != room_id: |
| return False |
| storage = self._storage_for_object(obj) |
| if storage is None: |
| return True |
| (storage_room, unit) = storage |
| return storage_room.get('room_id') != room_id or unit.get('opened') is True |
|
|
| @staticmethod |
| def _source_inspection_valid(order, task, obj): |
| receipt = task.get('source_inspection_receipt') or {} |
| return bool(receipt.get('status') == 'verified' and receipt.get('object_id') == order.get('object_id') == obj.get('object_id') and (receipt.get('source_room_id') == task.get('source_room_id')) and (receipt.get('handling_code') == obj.get('handling_code')) and (receipt.get('stock_group') == task.get('stock_group') == obj.get('stock_group'))) |
|
|
| def _source_storage_open(self, task, obj): |
| unit_id = obj.get('storage_unit_id') |
| if not unit_id: |
| return True |
| room = self._room(task.get('source_room_id')) |
| unit = next((row for row in (room or {}).get('storage_units', []) if row.get('unit_id') == unit_id), None) |
| return bool(unit and unit.get('opened') is True) |
|
|
| def assign_work_order(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('assign_work_order', fn__error('WORK_ORDER_NOT_FOUND', 'unknown work order')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor): |
| return fn__error('WORK_ORDER_UNAVAILABLE', 'incomplete work-order records') |
| if task.get('status') != 'queued' or task.get('assigned_robot_id') or self._active_assignments(task_id=task['task_id']): |
| return fn__error('WORK_ORDER_NOT_QUEUED', 'work order is not queued') |
| if actor.get('operational_status') != 'available' or actor.get('active_task_id') or actor.get('payload_object_id') or self._active_assignments(robot_id=self.robot_id): |
| return fn__error('ROBOT_NOT_AVAILABLE', 'the robot is occupied') |
| if actor.get('facility_id') != task.get('facility_id'): |
| return fn__error('FACILITY_MISMATCH', 'robot and work order are in different facilities') |
| if obj.get('requires_gripper') and 'grasp' not in actor.get('capabilities', []): |
| return fn__error('CAPABILITY_MISMATCH', 'required actuator is unavailable') |
| now = fn__timestamp() |
| task.update(status='assigned', assigned_robot_id=self.robot_id, updated_at=now) |
| actor.update(operational_status='busy', active_task_id=task['task_id'], updated_at=now) |
| domain = mod_importlib.import_module('mcp_servers.robot_domain') |
| domain._make_assignment(self.sm, task, actor, note='Metered delivery assignment.') |
| self._save('service_task', task) |
| self._save('robot_unit', actor) |
| return fn__success({'work_order': work_order, 'status': 'assigned'}) |
| return self._attempt('assign_work_order', mutate) |
|
|
| def prepare_transfer(self, work_order, profile): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('prepare_transfer', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| if profile not in DATA_TRANSFER_PROFILES: |
| return self._finish('prepare_transfer', fn__error('INVALID_ARGUMENTS', 'the transfer profile is not declared')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor): |
| return fn__error('WORK_ORDER_UNAVAILABLE', 'the work-order records are incomplete') |
| if task.get('status') not in {'assigned', 'in_progress'}: |
| return fn__error('WORK_ORDER_NOT_CONFIGURABLE', 'the work order is not active') |
| if task.get('assigned_robot_id') != self.robot_id or len(self._active_assignments(task_id=task['task_id'], robot_id=self.robot_id)) != 1 or actor.get('active_task_id') != task['task_id']: |
| return fn__error('ASSIGNMENT_REQUIRED', 'the work order is not actively assigned') |
| if not self._source_inspection_valid(order, task, obj): |
| return fn__error('LOCAL_INSPECTION_REQUIRED', 'inspect the target parcel before configuration') |
| at_source = actor.get('current_room_id') == task.get('source_room_id') |
| unheld_local = obj.get('current_room_id') == actor.get('current_room_id') and (not obj.get('held_by_robot_id')) |
| held_by_actor = actor.get('payload_object_id') == obj['object_id'] and obj.get('held_by_robot_id') == self.robot_id |
| if not at_source or not (unheld_local or held_by_actor): |
| return fn__error('SOURCE_CONFIGURATION_REQUIRED', 'configure this parcel at its opened source storage location') |
| if not self._source_storage_open(task, obj): |
| return fn__error('SOURCE_STORAGE_CLOSED', "open the parcel's local source storage before configuration") |
| now = fn__timestamp() |
| task.update(transfer_profile_submitted=profile, transfer_policy_version=task['policy_version'], transfer_object_id=obj['object_id'], transfer_authorized=False, intake_receipt=None, updated_at=now) |
| self._save('service_task', task) |
| return fn__success({'work_order': work_order, 'transfer_state': 'configured_unverified'}) |
| return self._attempt('prepare_transfer', mutate) |
|
|
| def _configured_profile_valid(self, task, obj): |
| key = f"{obj.get('handling_code')}:{task.get('intake_code')}" |
| return task.get('policy_version') == 'PV-18' and task.get('transfer_policy_version') == task.get('policy_version') and (task.get('transfer_object_id') == obj.get('object_id')) and (task.get('transfer_profile_submitted') == self.rule_table.get(key)) |
|
|
| def release(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('release', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor) or (actor.get('current_room_id') != order['destination_room_id']) or (actor.get('payload_object_id') != obj.get('object_id')) or (obj.get('held_by_robot_id') != self.robot_id): |
| return self._robot_state_action_adapter_release(work_order) |
| if task.get('transfer_profile_submitted') not in DATA_TRANSFER_PROFILES or task.get('transfer_policy_version') != task.get('policy_version') or task.get('transfer_object_id') != obj.get('object_id'): |
| return self._attempt('release', lambda : fn__error('TRANSFER_NOT_CONFIGURED', 'destination intake requires a current parcel-bound configuration')) |
| if not self._configured_profile_valid(task, obj): |
| return self._attempt('release', lambda : fn__error('INTAKE_REJECTED', 'destination intake did not accept the configured transfer')) |
| result = self._robot_state_action_adapter_release(work_order) |
| if result.get('status') == 'success': |
| task = self._get('service_task', 'task_id', order['task_id']) |
| if task: |
| task.update(transfer_authorized=True, intake_receipt={'status': 'accepted', 'object_id': obj['object_id'], 'policy_version': task['policy_version'], 'profile': task['transfer_profile_submitted'], 'destination_room_id': order['destination_room_id'], 'accepted_at': fn__timestamp()}, updated_at=fn__timestamp()) |
| self._save('service_task', task) |
| result.setdefault('data', {})['intake_state'] = 'accepted' |
| return result |
|
|
| def finalize(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('finalize', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| receipt = (task or {}).get('intake_receipt') or {} |
| if not task or not obj or task.get('transfer_authorized') is not True or (receipt.get('status') != 'accepted') or (receipt.get('object_id') != obj.get('object_id')) or (receipt.get('policy_version') != task.get('policy_version')) or (receipt.get('destination_room_id') != order['destination_room_id']): |
| return self._attempt('finalize', lambda : fn__error('INTAKE_RECEIPT_REQUIRED', "closure requires this parcel's current accepted intake receipt")) |
| if not actor or actor.get('current_room_id') != self.home_room_id: |
| return self._attempt('finalize', lambda : fn__error('SERVICE_HUB_REQUIRED', 'return to the service hub before closing the work order')) |
| return self._robot_state_action_adapter_finalize(work_order) |
|
|
| def export_observation_ledger(self): |
| ledger = self._robot_state_action_adapter_export_observation_ledger() |
| ledger['storage_handles'] = sorted(self.issued_storage_handles) |
| ledger['opened_storage_handles'] = sorted((handle for handle in self._storage_by_handle if (resolved := self._storage(handle)) is not None and resolved[1].get('opened') is True)) |
| ledger['inspected_target_object_ids'] = sorted(self._inspected_target_ids) |
| return ledger |
|
|
| def _schema_valid(self, name, arguments): |
| if name not in DATA__TOOL_BY_NAME or not isinstance(arguments, dict): |
| return False |
| schema = DATA__TOOL_BY_NAME[name] |
| properties = schema.get('properties', {}) |
| if set(arguments) - set(properties) or any((key not in arguments for key in schema.get('required', []))): |
| return False |
| for (key, value) in arguments.items(): |
| spec = properties[key] |
| if spec.get('type') == 'string' and (not isinstance(value, str)): |
| return False |
| if spec.get('type') == 'array' and (not isinstance(value, list) or not all((isinstance(item, str) for item in value))): |
| return False |
| if 'enum' in spec and value not in spec['enum']: |
| return False |
| return True |
|
|
| def _handle(self, kind, internal_id): |
| token = mod_hashlib.sha256(f'{self.handle_seed}:{kind}:{internal_id}'.encode('utf-8')).hexdigest()[:16] |
| return f'{kind}-{token}' |
|
|
| def _all(self, entity): |
| return self.sm.list_entities(entity) |
|
|
| def _get(self, entity, id_field, entity_id): |
| if not entity_id: |
| return None |
| return self.sm.get_entity(entity, entity_id, id_field=id_field) |
|
|
| def _save(self, entity, row): |
| return self.sm.replace_entity(entity, row) |
|
|
| def _refresh_plan_handles(self): |
| self._plan_by_handle = {self._handle('plan', row['plan_id']): row['plan_id'] for row in self._all('navigation_plan')} |
|
|
| def _finish(self, tool, result, battery_cost=0): |
| self._actions.append({'index': self._next_action_index, 'tool': tool, 'status': result.get('status'), 'battery_cost': battery_cost, 'reason': fn__code(result)}) |
| self._next_action_index += 1 |
| if len(self._actions) > 256: |
| self._actions = self._actions[-256:] |
| return result |
|
|
| def _robot(self): |
| return self._get('robot_unit', 'robot_id', self.robot_id) |
|
|
| def _room(self, room_id): |
| return self._get('room', 'room_id', room_id) |
|
|
| def _room_name(self, room_id): |
| room = self._room(room_id) |
| return room.get('name') if room else None |
|
|
| def _robot_name(self, robot_id): |
| robot = self._get('robot_unit', 'robot_id', robot_id) |
| return robot.get('display_name') if robot else None |
|
|
| def _order(self, work_order): |
| return self._orders.get(work_order) if isinstance(work_order, str) else None |
|
|
| def _task_steps(self, task_id): |
| return sorted((row for row in self._all('task_step') if row.get('task_id') == task_id), key=lambda row: (row.get('step_order', 0), row.get('step_id', ''))) |
|
|
| def _active_assignments(self, task_id=None, robot_id=None): |
| rows = [] |
| for row in self._all('task_assignment'): |
| if row.get('status') != 'active': |
| continue |
| if task_id is not None and row.get('task_id') != task_id: |
| continue |
| if robot_id is not None and row.get('robot_id') != robot_id: |
| continue |
| rows.append(row) |
| return rows |
|
|
| def _condition(self, room_id): |
| return next((row for row in self._all('room_condition') if row.get('room_id') == room_id), None) |
|
|
| def _room_open(self, room_id): |
| room = self._room(room_id) |
| condition = self._condition(room_id) if room_id else None |
| return bool(room and room.get('is_robot_accessible') and (not condition or condition.get('access_state') != 'closed')) |
|
|
| def _edge_destination(self, edge, room_id): |
| if edge.get('from_room_id') == room_id: |
| return edge.get('to_room_id') |
| if edge.get('is_bidirectional') and edge.get('to_room_id') == room_id: |
| return edge.get('from_room_id') |
| return None |
|
|
| def _active_edge_blockers(self, edge_id): |
| return [row for row in self._all('obstacle') if row.get('status') == 'active' and edge_id in (row.get('affects_edge_ids') or [])] |
|
|
| def _edge_usable(self, edge, destination_id): |
| return bool(edge.get('status') == 'open' and (not self._active_edge_blockers(edge['edge_id'])) and self._room_open(destination_id)) |
|
|
| def _capture_state(self): |
| if hasattr(self.sm, 'get_full_state'): |
| return ext_deepcopy(self.sm.get_full_state()) |
| return {entity: ext_deepcopy(self._all(entity)) for entity in DATA__ID_FIELDS} |
|
|
| def _restore_state(self, state): |
| if hasattr(self.sm, 'database') and isinstance(self.sm.database, dict): |
| self.sm.database = ext_deepcopy(state) |
| return |
| for (entity, rows) in state.items(): |
| id_field = DATA__ID_FIELDS.get(entity) |
| if not id_field: |
| continue |
| if hasattr(self.sm, 'delete_entity'): |
| desired = {row.get(id_field) for row in rows} |
| for current in self._all(entity): |
| entity_id = current.get(id_field) |
| if entity_id not in desired: |
| self.sm.delete_entity(entity, entity_id, id_field=id_field) |
| for row in rows: |
| self._save(entity, ext_deepcopy(row)) |
|
|
| def _battery(self): |
| robot = self._robot() |
| return int((robot or {}).get('battery_percent') or 0) |
|
|
| def _set_battery(self, value): |
| self.sm.update_entity('robot_unit', self.robot_id, {'battery_percent': value}, id_field='robot_id') |
|
|
| def _attempt(self, tool, mutation): |
| starting_battery = self._battery() |
| if starting_battery < 1: |
| return self._finish(tool, fn__error('INSUFFICIENT_BATTERY', 'the controlled robot cannot pay the one-unit attempt cost', {'battery_percent': starting_battery, 'battery_cost': 0}), 0) |
| before = self._capture_state() |
| try: |
| result = mutation() |
| except Exception: |
| self._restore_state(before) |
| raise |
| if result.get('status') != 'success': |
| self._restore_state(before) |
| self._set_battery(starting_battery - 1) |
| result.setdefault('data', {}) |
| result['data'].update({'battery_percent': starting_battery - 1, 'battery_cost': 1}) |
| self._refresh_plan_handles() |
| return self._finish(tool, result, 1) |
|
|
| def _work_context(self, order): |
| task = self._get('service_task', 'task_id', order['task_id']) |
| obj = self._get('object_item', 'object_id', order['object_id']) |
| return (task, obj) |
|
|
| def _required_destination(self, task, obj): |
| pick_done = any((row.get('step_type') == 'pick' and row.get('status') == 'completed' for row in self._task_steps(task['task_id']))) |
| if obj and (obj.get('held_by_robot_id') or pick_done or obj.get('handling_state') in {'in_transit', 'delivered'}): |
| return task.get('target_room_id') |
| return task.get('source_room_id') |
|
|
| def observe_self(self): |
| robot = self._robot() |
| if not robot: |
| return self._finish('observe_self', fn__error('ROBOT_NOT_FOUND', 'the controlled robot is missing')) |
| payload = self._get('object_item', 'object_id', robot.get('payload_object_id')) |
| payload_view = None |
| if payload: |
| handle = self._handle('object', payload['object_id']) |
| self.issued_object_handles.add(handle) |
| payload_view = {'object_handle': handle, 'display_name': payload.get('display_name'), 'handling_state': payload.get('handling_state')} |
| active_order = next((ref for (ref, row) in self._orders.items() if row['task_id'] == robot.get('active_task_id')), None) |
| return self._finish('observe_self', fn__success({'robot': {'display_name': robot.get('display_name'), 'operational_status': robot.get('operational_status'), 'capabilities': ext_deepcopy(robot.get('capabilities') or []), 'battery_percent': int(robot.get('battery_percent') or 0)}, 'current_room': {'name': self._room_name(robot.get('current_room_id'))}, 'payload': payload_view, 'active_work_order': active_order})) |
|
|
| def _route_consistent(self, plan): |
| route = plan.get('route_room_ids') or [] |
| if not route or route[0] != plan.get('origin_room_id') or route[-1] != plan.get('destination_room_id'): |
| return False |
| edges = self._all('map_edge') |
| for (left, right) in zip(route, route[1:]): |
| if not any((edge.get('from_room_id') == left and edge.get('to_room_id') == right or (edge.get('is_bidirectional') and edge.get('from_room_id') == right and (edge.get('to_room_id') == left)) for edge in edges)): |
| return False |
| return True |
|
|
| def _route_currently_usable(self, plan): |
| route = plan.get('route_room_ids') or [] |
| if not self._route_consistent(plan) or not self._room_open(route[0]): |
| return False |
| edges = self._all('map_edge') |
| for (left, right) in zip(route, route[1:]): |
| edge = next((row for row in edges if row.get('from_room_id') == left and row.get('to_room_id') == right or (row.get('is_bidirectional') and row.get('from_room_id') == right and (row.get('to_room_id') == left))), None) |
| if edge is None or not self._edge_usable(edge, right): |
| return False |
| return True |
|
|
| def inspect_plan(self, plan_handle): |
| self._refresh_plan_handles() |
| if not isinstance(plan_handle, str) or plan_handle not in self.issued_plan_handles or plan_handle not in self._plan_by_handle: |
| return self._finish('inspect_plan', fn__error('PLAN_NOT_OBSERVED', 'read the work order before inspecting its plan')) |
| plan = self._get('navigation_plan', 'plan_id', self._plan_by_handle[plan_handle]) |
| if not plan: |
| return self._finish('inspect_plan', fn__error('PLAN_UNAVAILABLE', 'the observed plan no longer exists')) |
| owner = self._get('robot_unit', 'robot_id', plan.get('robot_id')) |
| active_obstacles = {row.get('obstacle_id') for row in self._all('obstacle') if row.get('status') == 'active'} |
| blockers = set(plan.get('blocked_by_obstacle_ids') or []) & active_obstacles |
| order = next((row for row in self._orders.values() if row['task_id'] == plan.get('task_id')), None) |
| task = self._get('service_task', 'task_id', plan.get('task_id')) |
| obj = self._get('object_item', 'object_id', (order or {}).get('object_id')) |
| required = self._required_destination(task, obj) if task else None |
| return self._finish('inspect_plan', fn__success({'plan_handle': plan_handle, 'status': plan.get('status'), 'owner': {'display_name': (owner or {}).get('display_name'), 'operational_status': (owner or {}).get('operational_status')}, 'blocker_count': len(blockers), 'owned_by_controlled_robot': plan.get('robot_id') == self.robot_id, 'origin_is_owner_current_room': bool(owner and plan.get('origin_room_id') == owner.get('current_room_id')), 'destination_matches_unfinished_work': plan.get('destination_room_id') == required, 'route_is_contiguous': self._route_consistent(plan)})) |
|
|
| def handoff_work_order(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('handoff_work_order', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor): |
| return fn__error('WORK_ORDER_UNAVAILABLE', 'the work-order records are incomplete') |
| source_id = task.get('assigned_robot_id') |
| source = self._get('robot_unit', 'robot_id', source_id) |
| active = self._active_assignments(task_id=task['task_id'], robot_id=source_id) |
| if not source or source_id == self.robot_id or len(active) != 1: |
| return fn__error('HANDOFF_SOURCE_INVALID', 'the work order has no coherent peer assignment') |
| if actor.get('operational_status') != 'available' or actor.get('active_task_id') or actor.get('payload_object_id'): |
| return fn__error('CONTROLLED_ROBOT_NOT_AVAILABLE', "finish the controlled robot's current work before handoff") |
| held = obj.get('held_by_robot_id') is not None or source.get('payload_object_id') is not None |
| if held and (not (obj.get('held_by_robot_id') == source_id and source.get('payload_object_id') == obj.get('object_id'))): |
| return fn__error('CUSTODY_INCOHERENT', 'peer and parcel custody records disagree') |
| if held and actor.get('current_room_id') != source.get('current_room_id'): |
| return fn__error('HANDOFF_ROOM_MISMATCH', 'held cargo requires both robots in the same room') |
| source_status = source.get('operational_status') |
| old_steps = self._task_steps(task['task_id']) |
| old_plans = [row for row in self._all('navigation_plan') if row.get('task_id') == task['task_id']] |
| domain = mod_importlib.import_module('mcp_servers.robot_domain') |
| native = domain.execute_task_handoff(self.sm, task_id=task['task_id'], from_robot_id=source_id, to_robot_id=self.robot_id, handoff_room_id=source.get('current_room_id'), handoff_reason='Interrupted work-order recovery.') |
| if native.get('status') != 'success': |
| return fn__error(fn__code(native), 'handoff was rejected') |
| self.sm.update_entity('robot_unit', source_id, {'operational_status': source_status}, id_field='robot_id') |
| for row in old_steps: |
| self._save('task_step', row) |
| for row in old_plans: |
| self._save('navigation_plan', row) |
| current = self._get('service_task', 'task_id', task['task_id']) |
| return fn__success({'work_order': work_order, 'status': (current or {}).get('status'), 'physical_custody_transferred': held, 'former_robot_status': source_status}) |
| return self._attempt('handoff_work_order', mutate) |
|
|
| def _validate_supplied_route(self, handles, start, destination): |
| rooms = [start] |
| distance = 0.0 |
| current = start |
| for handle in handles: |
| edge = self._get('map_edge', 'edge_id', self._edge_by_handle[handle]) |
| nxt = self._edge_destination(edge or {}, current) |
| if not edge or not nxt: |
| return (None, 0.0, 'ROUTE_NOT_CONTIGUOUS') |
| if not self._edge_usable(edge, nxt): |
| return (None, 0.0, 'ROUTE_NOT_TRAVERSABLE') |
| rooms.append(nxt) |
| current = nxt |
| distance += float(edge.get('distance_m') or 1) |
| if current != destination: |
| return (None, 0.0, 'ROUTE_WRONG_DESTINATION') |
| return (rooms, distance, None) |
|
|
| def _new_plan_id(self, task_id): |
| existing = {row.get('plan_id') for row in self._all('navigation_plan')} |
| ordinal = 1 |
| while True: |
| token = mod_hashlib.sha256(f'{self.handle_seed}:recovery-plan:{task_id}:{ordinal}'.encode('utf-8')).hexdigest()[:16] |
| candidate = f'plan-recovery-{token}' |
| if candidate not in existing: |
| return candidate |
| ordinal += 1 |
|
|
| def resolve_work_order(self, work_order, action, route_exit_handles=None): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('resolve_work_order', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| if action not in {'retry', 'reroute'} or (route_exit_handles is not None and (not isinstance(route_exit_handles, list) or not all((isinstance(value, str) for value in route_exit_handles)))): |
| return self._finish('resolve_work_order', fn__error('INVALID_ARGUMENTS', 'action or route handles do not match the tool schema')) |
| handles = list(route_exit_handles or []) |
| if any((handle not in self.issued_exit_handles or handle not in self._edge_by_handle for handle in handles)): |
| return self._finish('resolve_work_order', fn__error('EXIT_NOT_KNOWN', 'every route exit must have been observed locally')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not actor or task.get('status') != 'blocked': |
| return fn__error('WORK_ORDER_NOT_BLOCKED', 'only a blocked work order can be resolved') |
| if task.get('assigned_robot_id') != self.robot_id or len(self._active_assignments(task_id=task['task_id'], robot_id=self.robot_id)) != 1: |
| return fn__error('ASSIGNMENT_REQUIRED', 'the blocked work order is not coherently assigned to the controlled robot') |
| if int(actor.get('battery_percent') or 0) < 10: |
| return fn__error('LOW_BATTERY_PRECONDITION_FAILED', 'robot battery is below the recovery threshold') |
| destination = self._required_destination(task, obj) |
| now = fn__timestamp() |
| plan = None |
| if action == 'retry': |
| if handles: |
| return fn__error('ROUTE_NOT_ALLOWED_FOR_RETRY', 'retry reuses an existing plan') |
| active_obstacles = {row.get('obstacle_id') for row in self._all('obstacle') if row.get('status') == 'active'} |
| candidates = [row for row in self._all('navigation_plan') if row.get('task_id') == task['task_id'] and row.get('robot_id') == self.robot_id and (row.get('status') == 'draft') and (row.get('origin_room_id') == actor.get('current_room_id')) and (row.get('destination_room_id') == destination) and (not set(row.get('blocked_by_obstacle_ids') or []) & active_obstacles) and self._route_currently_usable(row)] |
| if len(candidates) != 1: |
| return fn__error('REUSABLE_PLAN_NOT_FOUND', 'retry requires one current, unblocked, controlled draft plan') |
| plan = candidates[0] |
| plan.update(status='active', updated_at=now) |
| self._save('navigation_plan', plan) |
| else: |
| (route, distance, failure) = self._validate_supplied_route(handles, actor.get('current_room_id'), destination) |
| if failure: |
| return fn__error(failure, 'the supplied observed route cannot resume this work order') |
| plan = {'plan_id': self._new_plan_id(task['task_id']), 'facility_id': task.get('facility_id'), 'robot_id': self.robot_id, 'task_id': task['task_id'], 'origin_room_id': actor.get('current_room_id'), 'destination_room_id': destination, 'route_room_ids': route, 'route_edge_ids': [self._edge_by_handle[value] for value in handles], 'status': 'active', 'blocked_by_obstacle_ids': [], 'estimated_distance_m': round(distance, 2), 'estimated_duration_seconds': max(30, len(handles) * 30), 'created_at': now, 'updated_at': now} |
| self._save('navigation_plan', plan) |
| for step in self._task_steps(task['task_id']): |
| if step.get('status') == 'blocked': |
| step.update(status='in_progress', blocked_reason=None, updated_at=now) |
| self._save('task_step', step) |
| task.update(status='in_progress', failure_reason=None, updated_at=now) |
| actor.update(operational_status='busy', active_task_id=task['task_id'], updated_at=now) |
| self._save('service_task', task) |
| self._save('robot_unit', actor) |
| handle = self._handle('plan', plan['plan_id']) |
| self.issued_plan_handles.add(handle) |
| return fn__success({'work_order': work_order, 'status': 'in_progress', 'action': action, 'plan_handle': handle}) |
| return self._attempt('resolve_work_order', mutate) |
|
|
| def _robot_experience_stream_adapter_init(self, *args, **kwargs): |
| self._scanned_rooms_this_episode: set[str] = set() |
| self._accessed_storage_this_episode: set[str] = set() |
| self._robot_experience_stream_adapter_init_2(*args, **kwargs) |
| self.tools = ext_deepcopy(DATA_TOOLS_5) |
|
|
| def _robot_state_action_adapter_traverse_known_exit(self, exit_handle): |
| if not isinstance(exit_handle, str) or exit_handle not in self.issued_exit_handles or exit_handle not in self._edge_by_handle: |
| return self._finish('traverse_known_exit', fn__error('EXIT_NOT_KNOWN', 'scan the current room before using an exit')) |
| robot = self._robot() |
| edge = self._get('map_edge', 'edge_id', self._edge_by_handle[exit_handle]) |
| destination = self._edge_destination(edge or {}, (robot or {}).get('current_room_id')) |
| if not robot or not edge or (not destination): |
| return self._finish('traverse_known_exit', fn__error('EXIT_CHANGED', 'the observed exit is not adjacent now')) |
| if not self._edge_usable(edge, destination): |
| return self._finish('traverse_known_exit', fn__error('EXIT_BLOCKED', 'the observed exit is not traversable now')) |
| cost = max(1, mod_math.ceil(float(edge.get('distance_m') or 1) / 10)) |
| if int(robot.get('battery_percent') or 0) < cost: |
| return self._finish('traverse_known_exit', fn__error('INSUFFICIENT_BATTERY', 'movement cannot be paid', {'battery_percent': int(robot.get('battery_percent') or 0), 'battery_cost': 0})) |
| previous_name = self._room_name(robot.get('current_room_id')) |
| domain = mod_importlib.import_module('mcp_servers.robot_domain') |
| result = domain.move_robot_to_room(self.sm, robot_id=self.robot_id, destination_room_id=destination, battery_cost_percent=cost) |
| if result.get('status') != 'success': |
| return self._finish('traverse_known_exit', fn__error(fn__code(result), 'movement was rejected', {'battery_percent': self._battery(), 'battery_cost': 0})) |
| now = fn__timestamp() |
| actor = self._robot() |
| active_task_id = (actor or {}).get('active_task_id') |
| task = self._get('service_task', 'task_id', active_task_id) |
| if task: |
| for step in self._task_steps(active_task_id): |
| if step.get('step_type') == 'navigate' and step.get('room_id') == destination and (step.get('status') in {'pending', 'in_progress'}): |
| step.update(status='completed', completed_at=now, blocked_reason=None, updated_at=now) |
| self._save('task_step', step) |
| if task.get('status') == 'assigned': |
| task.update(status='in_progress', updated_at=now) |
| self._save('service_task', task) |
| break |
| for plan in self._all('navigation_plan'): |
| if plan.get('robot_id') == self.robot_id and plan.get('status') == 'active' and (plan.get('destination_room_id') == destination): |
| plan.update(status='completed', updated_at=now) |
| self._save('navigation_plan', plan) |
| return self._finish('traverse_known_exit', fn__success({'previous_room': {'name': previous_name}, 'current_room': {'name': self._room_name(destination)}, 'battery_percent': self._battery(), 'battery_cost': cost}), cost) |
|
|
| def _robot_experience_adapter_call(self, name, arguments): |
| if name not in DATA__TOOL_BY_NAME: |
| return self._finish(str(name), fn__error('UNKNOWN_TOOL', 'tool is not in the public experience profile')) |
| if not self._schema_valid(name, arguments): |
| return self._finish(name, fn__error('INVALID_ARGUMENTS', 'arguments do not match the tool schema')) |
| return getattr(self, name)(**ext_deepcopy(arguments)) |
|
|
| def _robot_experience_stream_adapter_snapshot(self): |
| """Return the complete private checkpoint used for replay and grading.""" |
| state = self._robot_experience_stream_adapter_snapshot_2() |
| state['schema'] = 'robot-experience-stream-snapshot/v3' |
| state['episode_metering'] = {'scanned_room_ids': sorted(self._scanned_rooms_this_episode), 'accessed_storage_handles': sorted(self._accessed_storage_this_episode)} |
| return state |
|
|
| def _robot_experience_stream_adapter_read_work_order(self, work_order): |
| result = self._robot_experience_adapter_read_work_order(work_order) |
| if result.get('status') == 'success': |
| result['data']['policy_version'] = self.public_policy_version |
| return result |
|
|
| def _robot_experience_adapter_storage_view(self, room, unit): |
| objects = [] |
| for obj in sorted(self._all('object_item'), key=lambda row: row.get('object_id', '')): |
| if obj.get('current_room_id') == room['room_id'] and (not obj.get('held_by_robot_id')) and (obj.get('storage_unit_id') == unit['unit_id']): |
| handle = self._handle('object', obj['object_id']) |
| self.issued_object_handles.add(handle) |
| objects.append({'object_handle': handle, 'display_name': obj.get('display_name'), 'handling_state': obj.get('handling_state')}) |
| return {'storage_handle': self._handle('storage', unit['unit_id']), 'display_name': unit.get('display_name') or f"Storage-{self._handle('storage', unit['unit_id'])[-8:].upper()}", 'access_state': 'open', 'stock_group': unit.get('stock_group'), 'objects': objects, 'calibration_records': ext_deepcopy(unit.get('calibration_records', []))} |
|
|
| def _robot_experience_adapter_inspect_local_object(self, object_handle): |
| if not isinstance(object_handle, str) or object_handle not in self.issued_object_handles or object_handle not in self._object_by_handle: |
| return self._finish('inspect_local_object', fn__error('OBJECT_NOT_OBSERVED', 'observe the parcel locally before inspecting it')) |
| robot = self._robot() |
| obj = self._get('object_item', 'object_id', self._object_by_handle[object_handle]) |
| if not robot or not obj or (not self._object_visible_in_room(obj, robot.get('current_room_id'))): |
| return self._finish('inspect_local_object', fn__error('OBJECT_NOT_LOCAL', 'the observed parcel is no longer visible here')) |
| matching_order = next((order for order in self._orders.values() if order['object_id'] == obj['object_id']), None) |
| if matching_order is not None: |
| (task, _) = self._work_context(matching_order) |
| if task and robot.get('current_room_id') == task.get('source_room_id') and (obj.get('current_room_id') == task.get('source_room_id')) and (not obj.get('held_by_robot_id')): |
| task.update(source_inspection_receipt={'status': 'verified', 'object_id': obj['object_id'], 'source_room_id': task.get('source_room_id'), 'handling_code': obj.get('handling_code'), 'stock_group': task.get('stock_group')}, updated_at=fn__timestamp()) |
| self._save('service_task', task) |
| self._inspected_target_ids.add(obj['object_id']) |
| return self._finish('inspect_local_object', fn__success({'object': {'object_handle': object_handle, 'display_name': obj.get('display_name'), 'handling_state': obj.get('handling_state'), 'handling_code': obj.get('handling_code')}})) |
|
|
| def _robot_experience_adapter_pickup(self, work_order, object_handle): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('pickup', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| (task, obj) = self._work_context(order) |
| if not task or not obj or (not self._source_inspection_valid(order, task, obj)) or (task.get('transfer_profile_submitted') not in DATA_TRANSFER_PROFILES) or (task.get('transfer_policy_version') != task.get('policy_version')) or (task.get('transfer_object_id') != obj['object_id']): |
| return self._attempt('pickup', lambda : fn__error('TRANSFER_NOT_CONFIGURED', 'pickup requires a current parcel-bound transfer configuration')) |
| return self._robot_state_action_adapter_pickup(work_order, object_handle) |
|
|
| def _robot_experience_adapter_import_observation_ledger(self, ledger): |
| if not isinstance(ledger, dict): |
| raise ValueError('observation ledger must be an object') |
| storage_handles = ledger.get('storage_handles', []) |
| opened_handles = ledger.get('opened_storage_handles', []) |
| if not isinstance(storage_handles, list) or not all((isinstance(value, str) for value in storage_handles)): |
| raise ValueError('storage_handles must be a list of strings') |
| if not isinstance(opened_handles, list) or not all((isinstance(value, str) for value in opened_handles)): |
| raise ValueError('opened_storage_handles must be a list of strings') |
| accepted_storage = set(storage_handles) & set(self._storage_by_handle) |
| accepted_opened = set(opened_handles) & accepted_storage |
| before_storage = len(self.issued_storage_handles) |
| self.issued_storage_handles.update(accepted_storage) |
| for handle in accepted_opened: |
| resolved = self._storage(handle) |
| if resolved and resolved[1].get('opened') is not True: |
| (room, unit) = resolved |
| unit['opened'] = True |
| room['storage_units'] = [unit if row.get('unit_id') == unit['unit_id'] else row for row in room.get('storage_units', [])] |
| self._save('room', room) |
| allowed_object_handles = set() |
| for (handle, object_id) in self._object_by_handle.items(): |
| obj = self._get('object_item', 'object_id', object_id) |
| storage = self._storage_for_object(obj or {}) if obj else None |
| if not storage or storage[1].get('opened') is True or obj.get('held_by_robot_id'): |
| allowed_object_handles.add(handle) |
| sanitized = ext_deepcopy(ledger) |
| sanitized['object_handles'] = [handle for handle in ledger.get('object_handles', []) if handle in allowed_object_handles] |
| counts = self._robot_state_action_adapter_import_observation_ledger(sanitized) |
| inspected = ledger.get('inspected_target_object_ids', []) |
| if not isinstance(inspected, list) or not all((isinstance(value, str) for value in inspected)): |
| raise ValueError('inspected_target_object_ids must be a list of strings') |
| durable_targets = set() |
| for order in self._orders.values(): |
| (task, obj) = self._work_context(order) |
| if task and obj and self._source_inspection_valid(order, task, obj): |
| durable_targets.add(order['object_id']) |
| before_inspected = len(self._inspected_target_ids) |
| self._inspected_target_ids.update(set(inspected) & durable_targets) |
| counts['storage_handles_imported'] = len(self.issued_storage_handles) - before_storage |
| counts['opened_storage_handles_imported'] = len(accepted_opened) |
| counts['inspected_target_object_ids_imported'] = len(self._inspected_target_ids) - before_inspected |
| return counts |
|
|
| def _robot_experience_adapter_grade(self): |
| rows = [] |
| total = 0.0 |
| for (work_order, order) in self._orders.items(): |
| (task, obj) = self._work_context(order) |
| steps = self._task_steps(order['task_id']) |
| assignments = [row for row in self._all('task_assignment') if row.get('task_id') == order['task_id']] |
| plans = [row for row in self._all('navigation_plan') if row.get('task_id') == order['task_id']] |
| source_verified = bool(task and obj and self._source_inspection_valid(order, task, obj)) |
| receipt = (task or {}).get('intake_receipt') or {} |
| authorized = bool(task and obj and (task.get('transfer_authorized') is True) and (receipt.get('status') == 'accepted') and (receipt.get('object_id') == obj.get('object_id')) and (receipt.get('policy_version') == task.get('policy_version')) and (receipt.get('destination_room_id') == order['destination_room_id'])) |
| custody_obtained = any((row.get('step_type') == 'pick' and row.get('status') == 'completed' for row in steps)) |
| physical = bool(authorized and obj and (obj.get('current_room_id') == order['destination_room_id']) and (not obj.get('held_by_robot_id')) and (obj.get('handling_state') in {'stored', 'delivered'})) |
| workflow = bool(physical and task and (task.get('status') == 'completed') and (obj.get('handling_state') == 'delivered') and steps and all((row.get('status') == 'completed' for row in steps)) and (not any((row.get('status') == 'active' for row in assignments))) and any((row.get('status') == 'completed' for row in assignments)) and (not any((row.get('status') == 'active' for row in plans))) and (not any((row.get('payload_object_id') == order['object_id'] for row in self._all('robot_unit')))) and (not any((row.get('active_task_id') == order['task_id'] for row in self._all('robot_unit'))))) |
| anchors = {'source_verified': 2.5 if source_verified else 0.0, 'transfer_authorized': 5.0 if authorized else 0.0, 'custody_obtained': 5.0 if custody_obtained else 0.0, 'physical_delivery': 5.0 if physical else 0.0, 'workflow_completed': 7.5 if workflow else 0.0} |
| score = sum(anchors.values()) |
| total += score |
| rows.append({'work_order': work_order, **{key: value > 0 for (key, value) in anchors.items()}, 'score': score, 'max_score': 25.0}) |
| components = {f'item_{index}_{name}': {'correct': int(row[name]), 'total': 1} for (index, row) in enumerate(rows, 1) for name in ('source_verified', 'transfer_authorized', 'custody_obtained', 'physical_delivery', 'workflow_completed')} |
| return {'score': total, 'max_score': 100.0, 'orders': rows, 'public_components': components} |
|
|
| def _robot_state_action_adapter_release(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('release', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor): |
| return fn__error('WORK_ORDER_UNAVAILABLE', 'the work-order records are incomplete') |
| if task.get('status') not in {'assigned', 'in_progress'}: |
| return fn__error('WORK_ORDER_NOT_RELEASABLE', 'blocked or terminal work cannot record release') |
| if task.get('assigned_robot_id') != self.robot_id or len(self._active_assignments(task_id=task['task_id'], robot_id=self.robot_id)) != 1: |
| return fn__error('ASSIGNMENT_REQUIRED', "release requires the controlled robot's active assignment") |
| if actor.get('payload_object_id') != obj.get('object_id') or obj.get('held_by_robot_id') != self.robot_id: |
| return fn__error('CUSTODY_MISMATCH', 'the controlled robot does not hold this work-order parcel') |
| if actor.get('current_room_id') != order['destination_room_id']: |
| return fn__error('WRONG_DESTINATION', 'the parcel can only be released at the work-order destination') |
| steps = self._task_steps(task['task_id']) |
| place_index = next((index for (index, row) in enumerate(steps) if row.get('step_type') == 'place'), None) |
| if place_index is None or steps[place_index].get('status') not in {'pending', 'in_progress'} or any((row.get('status') != 'completed' for row in steps[:place_index])): |
| return fn__error('WORKFLOW_NOT_READY_FOR_RELEASE', 'earlier work-order obligations are not complete') |
| domain = mod_importlib.import_module('mcp_servers.robot_domain') |
| native = domain.release_object_at_room(self.sm, object_id=obj['object_id'], robot_id=self.robot_id, room_id=order['destination_room_id'], delivery_state='stored', task_id=task['task_id']) |
| if native.get('status') != 'success': |
| return fn__error(fn__code(native), 'release was rejected') |
| return fn__success({'work_order': work_order, 'destination': {'name': self._room_name(order['destination_room_id'])}, 'physical_state': 'stored'}) |
| return self._attempt('release', mutate) |
|
|
| def _robot_state_action_adapter_finalize(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('finalize', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor): |
| return fn__error('WORK_ORDER_UNAVAILABLE', 'the work-order records are incomplete') |
| if task.get('status') not in {'assigned', 'in_progress'}: |
| return fn__error('WORK_ORDER_NOT_COMPLETABLE', 'the work order is blocked or terminal') |
| steps = self._task_steps(task['task_id']) |
| if not steps or any((row.get('status') != 'completed' for row in steps)): |
| return fn__error('REQUIRED_STEPS_OPEN', 'finalize cannot create or skip execution evidence') |
| if obj.get('current_room_id') != order['destination_room_id'] or obj.get('held_by_robot_id') or obj.get('handling_state') != 'stored': |
| return fn__error('PHYSICAL_DELIVERY_INCOMPLETE', 'the parcel must already be stored unheld at the destination') |
| if any((row.get('payload_object_id') == obj.get('object_id') for row in self._all('robot_unit'))): |
| return fn__error('PAYLOAD_REFERENCE_CONFLICT', 'a robot still references the delivered parcel') |
| active = self._active_assignments(task_id=task['task_id']) |
| if task.get('assigned_robot_id') != self.robot_id or len(active) != 1 or active[0].get('robot_id') != self.robot_id or (actor.get('active_task_id') != task['task_id']) or (actor.get('operational_status') != 'busy'): |
| return fn__error('ASSIGNMENT_INCOHERENT', 'strict completion requires one coherent controlled assignment') |
| now = fn__timestamp() |
| assignment = active[0] |
| assignment.update(status='completed', released_at=now, updated_at=now) |
| self._save('task_assignment', assignment) |
| for plan in self._all('navigation_plan'): |
| if plan.get('task_id') == task['task_id'] and plan.get('robot_id') == self.robot_id and (plan.get('status') in {'active', 'draft'}): |
| plan.update(status='completed', updated_at=now) |
| self._save('navigation_plan', plan) |
| actor.update(operational_status='available', active_task_id=None, payload_object_id=None, updated_at=now) |
| obj.update(handling_state='delivered', held_by_robot_id=None, current_room_id=order['destination_room_id'], updated_at=now) |
| task.update(status='completed', completed_at=now, failure_reason=None, updated_at=now) |
| self._save('robot_unit', actor) |
| self._save('object_item', obj) |
| self._save('service_task', task) |
| return fn__success({'work_order': work_order, 'status': 'completed', 'object_state': 'delivered', 'controlled_robot_status': 'available'}) |
| return self._attempt('finalize', mutate) |
|
|
| def _robot_state_action_adapter_export_observation_ledger(self): |
| return {'exit_handles': sorted(self.issued_exit_handles), 'object_handles': sorted(self.issued_object_handles), 'plan_handles': sorted(self.issued_plan_handles), 'robot_handles': sorted(self.issued_robot_handles), 'work_orders': sorted(self.issued_work_orders)} |
|
|
| def _robot_experience_stream_adapter_init_2(self, sm, *, active_object_ids, public_policy_version, expected_rule_epoch, facility_id, **kwargs): |
| if not isinstance(active_object_ids, set) or len(active_object_ids) != 4: |
| raise ValueError('active_object_ids must contain exactly four objects') |
| if public_policy_version not in {'PV-18', 'PV-19'}: |
| raise ValueError('unknown public policy version') |
| if expected_rule_epoch not in {'pre', 'post'}: |
| raise ValueError('unknown rule epoch') |
| self.active_object_ids = frozenset(active_object_ids) |
| self.public_policy_version = public_policy_version |
| self.expected_rule_epoch = expected_rule_epoch |
| self.facility_id = facility_id |
| self._robot_experience_adapter_init(sm, **kwargs) |
| self.tools = ext_deepcopy(DATA_TOOLS_4) |
| inventory = {row['object_id'] for row in self._all('object_item')} |
| if (missing := (self.active_object_ids - inventory)): |
| raise ValueError(f'active episode references missing objects: {sorted(missing)}') |
| facility = self._get('facility', 'facility_id', facility_id) |
| if facility is None: |
| raise ValueError('stream facility is missing') |
| if facility.get('experience_rule_epoch') != expected_rule_epoch: |
| raise ValueError('physical state rule epoch does not match the requested episode') |
| if facility.get('experience_policy_version') != public_policy_version: |
| raise ValueError('physical state policy version does not match the requested episode') |
| for order in self._orders.values(): |
| (task, obj) = self._work_context(order) |
| if task is None or obj is None: |
| raise ValueError('active episode has an incomplete order') |
| if obj['object_id'] not in self.active_object_ids: |
| raise ValueError('rubric contains a non-active object') |
| if task.get('experience_activation_state') != 'active': |
| raise ValueError('active service task is not activated') |
| if obj.get('experience_activation_state') != 'active': |
| raise ValueError('active parcel is not activated') |
| if task.get('experience_policy_version') != public_policy_version: |
| raise ValueError('service task policy version differs from the episode') |
|
|
| def _robot_experience_stream_adapter_snapshot_2(self): |
| state = self._robot_experience_adapter_snapshot() |
| state['schema'] = 'robot-experience-stream-snapshot/v2' |
| state['active_object_ids'] = sorted(self.active_object_ids) |
| state['public_policy_version'] = self.public_policy_version |
| state['rule_epoch'] = self.expected_rule_epoch |
| return state |
|
|
| def _robot_experience_adapter_read_work_order(self, work_order): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('read_work_order', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| (task, obj) = self._work_context(order) |
| if not task or not obj: |
| return self._finish('read_work_order', fn__error('WORK_ORDER_UNAVAILABLE', 'the work-order records are incomplete')) |
| if (task.get('intake_receipt') or {}).get('status') == 'accepted': |
| transfer_state = 'intake_accepted' |
| elif task.get('transfer_profile_submitted'): |
| transfer_state = 'configured_unverified' |
| else: |
| transfer_state = 'unconfigured' |
| assigned = self._get('robot_unit', 'robot_id', task.get('assigned_robot_id')) |
| return self._finish('read_work_order', fn__success({'work_order': work_order, 'status': task.get('status'), 'destination': {'name': self._room_name(order['destination_room_id'])}, 'object': {'display_name': obj.get('display_name')}, 'stock_group': task.get('stock_group'), 'intake_code': task.get('intake_code'), 'policy_version': task.get('policy_version'), 'transfer_state': transfer_state, 'assigned_robot_display_name': (assigned or {}).get('display_name')})) |
|
|
| def _robot_state_action_adapter_pickup(self, work_order, object_handle): |
| order = self._order(work_order) |
| if not order: |
| return self._finish('pickup', fn__error('WORK_ORDER_NOT_FOUND', 'the work-order reference is unknown')) |
| if not isinstance(object_handle, str) or object_handle not in self.issued_object_handles or object_handle not in self._object_by_handle: |
| return self._finish('pickup', fn__error('OBJECT_NOT_OBSERVED', 'observe the parcel locally before pickup')) |
|
|
| def mutate(): |
| (task, obj) = self._work_context(order) |
| actor = self._robot() |
| if not task or not obj or (not actor): |
| return fn__error('WORK_ORDER_UNAVAILABLE', 'the work-order records are incomplete') |
| if task.get('status') not in {'assigned', 'in_progress'}: |
| return fn__error('WORK_ORDER_NOT_PICKABLE', 'blocked or terminal work cannot record pickup') |
| if task.get('assigned_robot_id') != self.robot_id or len(self._active_assignments(task_id=task['task_id'], robot_id=self.robot_id)) != 1: |
| return fn__error('ASSIGNMENT_REQUIRED', "pickup requires the controlled robot's active assignment") |
| if self._object_by_handle[object_handle] != order['object_id']: |
| return fn__error('WORK_ORDER_OBJECT_MISMATCH', 'the observed parcel does not belong to this work order') |
| if actor.get('payload_object_id') or obj.get('held_by_robot_id') or obj.get('current_room_id') != actor.get('current_room_id') or (actor.get('current_room_id') != task.get('source_room_id')): |
| return fn__error('PICKUP_LOCATION_OR_CUSTODY_INVALID', 'the work-order parcel is not locally pickable') |
| steps = self._task_steps(task['task_id']) |
| pick_index = next((index for (index, row) in enumerate(steps) if row.get('step_type') == 'pick'), None) |
| if pick_index is None or steps[pick_index].get('status') not in {'pending', 'in_progress'}: |
| return fn__error('PICK_STEP_NOT_OPEN', 'the pickup obligation is not open') |
| now = fn__timestamp() |
| for step in steps[:pick_index]: |
| if step.get('step_type') == 'navigate' and step.get('room_id') == actor.get('current_room_id') and (step.get('status') in {'pending', 'in_progress'}): |
| step.update(status='completed', completed_at=now, blocked_reason=None, updated_at=now) |
| self._save('task_step', step) |
| elif step.get('status') != 'completed': |
| return fn__error('PRIOR_STEP_OPEN', 'pickup requires earlier obligations to be complete') |
| domain = mod_importlib.import_module('mcp_servers.robot_domain') |
| native = domain.attach_object_to_robot(self.sm, object_id=obj['object_id'], robot_id=self.robot_id, task_id=task['task_id']) |
| if native.get('status') != 'success': |
| return fn__error(fn__code(native), 'pickup was rejected') |
| task = self._get('service_task', 'task_id', task['task_id']) |
| if task and task.get('status') == 'assigned': |
| task.update(status='in_progress', updated_at=now) |
| self._save('service_task', task) |
| return fn__success({'work_order': work_order, 'object_handle': object_handle, 'handling_state': 'in_transit'}) |
| return self._attempt('pickup', mutate) |
|
|
| def _robot_state_action_adapter_import_observation_ledger(self, ledger): |
| if not isinstance(ledger, dict): |
| raise ValueError('observation ledger must be an object') |
| self._refresh_plan_handles() |
| specs = {'exit_handles': (self.issued_exit_handles, set(self._edge_by_handle)), 'object_handles': (self.issued_object_handles, set(self._object_by_handle)), 'plan_handles': (self.issued_plan_handles, set(self._plan_by_handle)), 'robot_handles': (self.issued_robot_handles, set(self._robot_by_handle)), 'work_orders': (self.issued_work_orders, set(self._orders))} |
| counts = {} |
| for (key, (target, known)) in specs.items(): |
| values = ledger.get(key, []) |
| if not isinstance(values, list) or not all((isinstance(value, str) for value in values)): |
| raise ValueError(f'{key} must be a list of strings') |
| accepted = set(values) & known |
| before = len(target) |
| target.update(accepted) |
| counts[f'{key}_imported'] = len(target) - before |
| return counts |
|
|
| def _robot_experience_adapter_init(self, sm, *, robot_id, handle_seed, task_ids, rubric, rule_table=None): |
| if not isinstance(rubric, dict) or rubric.get('version') != 'robot-experience-rubric/v1': |
| raise ValueError('unsupported robot experience rubric') |
| if rubric.get('policy_version') != 'PV-18': |
| raise ValueError('rubric policy version does not match the adapter') |
| home_room_id = rubric.get('home_room_id') |
| if not isinstance(home_room_id, str) or not home_room_id: |
| raise ValueError('rubric must define a home_room_id') |
| legacy_rubric = {'version': 'robot-state-action-rubric/v1', 'orders': ext_deepcopy(rubric.get('orders'))} |
| self._robot_state_action_adapter_init(sm, robot_id=robot_id, handle_seed=handle_seed, task_ids=task_ids, rubric=legacy_rubric) |
| self.tools = ext_deepcopy(DATA_TOOLS_6) |
| self.home_room_id = home_room_id |
| self.rule_table = fn__validate_rule_table(rule_table) |
| self._rubric_v3 = ext_deepcopy(rubric) |
| self._inspected_target_ids: set[str] = set() |
| self._storage_by_handle: dict[str, tuple[str, str]] = {} |
| seen_unit_ids: set[str] = set() |
| for room in self._all('room'): |
| units = room.get('storage_units', []) |
| if not isinstance(units, list): |
| raise ValueError('room storage_units must be a list') |
| for unit in units: |
| unit_id = unit.get('unit_id') if isinstance(unit, dict) else None |
| if not isinstance(unit_id, str) or not unit_id or unit_id in seen_unit_ids: |
| raise ValueError('storage unit IDs must be unique non-empty strings') |
| if not isinstance(unit.get('stock_group'), str) or not unit['stock_group']: |
| raise ValueError('storage units must define a stock_group') |
| if not isinstance(unit.get('opened'), bool): |
| raise ValueError('storage units must define boolean opened state') |
| if not isinstance(unit.get('calibration_records'), list): |
| raise ValueError('storage calibration_records must be a list') |
| seen_unit_ids.add(unit_id) |
| self._storage_by_handle[self._handle('storage', unit_id)] = (room['room_id'], unit_id) |
| self.issued_storage_handles: set[str] = set() |
| for (work_order, order) in self._orders.items(): |
| (task, obj) = self._work_context(order) |
| if not task or not obj: |
| raise ValueError(f'incomplete records for {work_order}') |
| if task.get('policy_version') != 'PV-18': |
| raise ValueError('task policy version does not match the adapter') |
| if task.get('intake_code') not in DATA_INTAKE_CODES: |
| raise ValueError('task has an unknown intake code') |
| if obj.get('handling_code') not in DATA_HANDLING_CODES: |
| raise ValueError('object has an unknown handling code') |
| if task.get('stock_group') != obj.get('stock_group'): |
| raise ValueError('work order and parcel stock groups differ') |
| if self._source_inspection_valid(order, task, obj): |
| self._inspected_target_ids.add(obj['object_id']) |
|
|
| def _robot_experience_adapter_snapshot(self): |
| state = self._robot_state_action_adapter_snapshot() |
| state['schema'] = 'robot-experience-snapshot/v1' |
| state['inspected_target_object_ids'] = sorted(self._inspected_target_ids) |
| return state |
|
|
| def _robot_state_action_adapter_init(self, sm, *, robot_id, handle_seed, task_ids, rubric): |
| if not isinstance(robot_id, str) or not robot_id: |
| raise ValueError('robot_id must be a non-empty string') |
| if not isinstance(handle_seed, str) or not handle_seed: |
| raise ValueError('handle_seed must be a non-empty string') |
| if not isinstance(task_ids, list) or len(task_ids) != 4 or len(set(task_ids)) != 4 or (not all((isinstance(x, str) and x for x in task_ids))): |
| raise ValueError('task_ids must contain four unique strings') |
| if not isinstance(rubric, dict) or rubric.get('version') != 'robot-state-action-rubric/v1': |
| raise ValueError('unsupported robot state-action rubric') |
| orders = rubric.get('orders') |
| if not isinstance(orders, list) or len(orders) != 4: |
| raise ValueError('rubric must contain exactly four orders') |
| self.sm = sm |
| self.robot_id = robot_id |
| self.handle_seed = handle_seed |
| self.tools = ext_deepcopy(DATA_TOOLS_7) |
| self._task_ids = tuple(task_ids) |
| self._orders: dict[str, dict[str, str]] = {} |
| for row in orders: |
| if not isinstance(row, dict) or any((not isinstance(row.get(key), str) or not row[key] for key in ('work_order', 'task_id', 'object_id', 'destination_room_id'))): |
| raise ValueError('rubric order fields must be non-empty strings') |
| if row['work_order'] in self._orders: |
| raise ValueError('work_order values must be unique') |
| self._orders[row['work_order']] = {key: row[key] for key in ('work_order', 'task_id', 'object_id', 'destination_room_id')} |
| if set(self._task_ids) != {row['task_id'] for row in self._orders.values()}: |
| raise ValueError('task_ids and rubric orders differ') |
| if self._get('robot_unit', 'robot_id', robot_id) is None: |
| raise ValueError('controlled robot does not exist') |
| self._edge_by_handle = {self._handle('exit', row['edge_id']): row['edge_id'] for row in self._all('map_edge')} |
| self._object_by_handle = {self._handle('object', row['object_id']): row['object_id'] for row in self._all('object_item')} |
| self._robot_by_handle = {self._handle('robot', row['robot_id']): row['robot_id'] for row in self._all('robot_unit')} |
| self._plan_by_handle: dict[str, str] = {} |
| self.issued_exit_handles: set[str] = set() |
| self.issued_object_handles: set[str] = set() |
| self.issued_plan_handles: set[str] = set() |
| self.issued_robot_handles: set[str] = set() |
| self.issued_work_orders: set[str] = set(self._orders) |
| self._actions: list[dict[str, ext_Any]] = [] |
| self._next_action_index = 1 |
| self._refresh_plan_handles() |
|
|
| def _robot_state_action_adapter_snapshot(self): |
| state: dict[str, ext_Any] = {'schema': 'robot-state-action-snapshot/v1'} |
| relevant_tasks = set(self._task_ids) |
| for (output_key, (entity, id_field)) in DATA__SNAPSHOT_TABLES.items(): |
| rows = self._all(entity) |
| if entity == 'service_task': |
| rows = [row for row in rows if row.get('task_id') in relevant_tasks] |
| elif entity in {'task_step', 'task_assignment', 'navigation_plan'}: |
| rows = [row for row in rows if row.get('task_id') in relevant_tasks] |
| state[output_key] = [fn__strip_volatile(row) for row in sorted(rows, key=lambda row: str(row.get(id_field) or ''))] |
| state['observation_ledger'] = self.export_observation_ledger() |
| state['action_ledger'] = ext_deepcopy(self._actions) |
| return state |
|
|
