Blame for cases/k8s_operations/runtime.py

"""Released environment operations and snapshot validation."""
from __future__ import annotations
from collections import Counter as ext_Counter
from collections import defaultdict as ext_defaultdict
from copy import deepcopy as ext_deepcopy
from pathlib import Path as ext_Path
from rescopebench.raw_module_isolation import load_isolated_modules as ext_load_isolated_modules
from rescopebench.public_projection import assert_hard_public_projection as ext_assert_hard_public_projection
from rescopebench.agent_runtime.protocol import public_feedback as ext_public_feedback
from typing import Any as ext_Any
import copy as mod_copy
import hashlib as mod_hashlib
import json as mod_json
import re as _re
import re as mod_re
from .spec import CASE_DIR, DATA_TASK_IDS, DATA_CHANGED_S, DATA_PUBLIC_TOOLS, DATA_SCHEMAS, DATA_POST_POLICY, DATA_POLICY_BY_CONDITIONS, DATA_CHANGED_BINDINGS, DATA_ID_FIELDS, DATA_SCHEMAS_2, DATA_SCHEDULE_2, DATA_DONORS, DATA_SCOPE_REPLACEMENTS, DATA_SCOPE_TEMPLATES, DATA_SCHEMAS_3, DATA_LIST_TOOLS, DATA_SCHEMAS_4, DATA_ZONES, DATA_REPLACEMENTS, DATA_SCOPE_SCHEDULE, DATA_CELL_SCHEDULE, DATA_WORKLOAD_CONDITIONS, DATA_SERVICE_CONDITIONS, DATA_ALLOWED_TOOLS, DATA_RECOVERY_SCOPE_TASK_IDS, DATA_RECOVERY_SCOPE_ORDER, DATA_RECOVERY_ZONES, DATA_RECOVERY_CELL_ORDER, DATA_PREFIX_SCOPE_DONORS, DATA_PREFIX_ZONE_SCHEDULE, DATA_TASK_IDS_2, DATA_CELL_SCHEDULE_2, DATA_CELL_SCHEDULE_3, DATA_TASK_BY_ID, DATA__PRIVATE_KEYS

def fn_grade_task(task, initial, final, eligible_nodes):
    (before, after) = (initial['raw']['database'], final['raw']['database'])
    nodes = {row['node_id']: row for row in after['node']}
    initial_nodes = {row['node_id']: row for row in before['node']}
    namespaces = {row['namespace_id']: row for row in after['namespace']}
    initial_namespaces = {row['namespace_id']: row for row in before['namespace']}
    clusters = {row['cluster_id']: row for row in after['cluster']}
    initial_clusters = {row['cluster_id']: row for row in before['cluster']}
    labels = {target['workload']['app_label'] for target in task['targets']}
    target_pods = [pod for pod in after['pod'] if (pod.get('labels') or {}).get('app') in labels and pod.get('phase') == 'Running']
    node_delta = ext_Counter((pod.get('node_id') for pod in target_pods))
    namespace_delta = ext_Counter((pod.get('namespace_id') for pod in target_pods))
    cluster_delta = ext_Counter((pod.get('cluster_id') for pod in target_pods))
    old_deployments = {row['deployment_id'] for row in before['deployment']}
    old_services = {row['service_id'] for row in before['service']}
    new_deployments = [row for row in after['deployment'] if row['deployment_id'] not in old_deployments]
    requested_deployments = {row['deployment_id'] for row in new_deployments if row.get('app_label') in labels}
    extras = [row['deployment_id'] for row in new_deployments if row.get('app_label') not in labels]
    extras.extend((row['service_id'] for row in after['service'] if row['service_id'] not in old_services and row.get('deployment_id') not in requested_deployments))
    artifacts = []
    for target in task['targets']:
        workload = target['workload']
        requested_service = target['service']
        requirements = fn_policy_for_task(task, target)['requirements']
        matching_clusters = [row for row in after['cluster'] if all((row.get(field) == value for (field, value) in target['cluster_selector'].items()))]
        cluster_id = matching_clusters[0]['cluster_id'] if len(matching_clusters) == 1 else None
        matching_namespaces = [row for row in after['namespace'] if row.get('cluster_id') == cluster_id and all((row.get(field) == value for (field, value) in target['namespace_selector'].items()))]
        namespace_id = matching_namespaces[0]['namespace_id'] if len(matching_namespaces) == 1 else None
        matches = [row for row in after['deployment'] if row.get('app_label') == workload['app_label']]
        deployment = matches[0] if len(matches) == 1 else None
        deployment_ok = bool(deployment and deployment.get('namespace_id') == namespace_id and all((deployment.get(field) == workload[field] for field in ('name', 'app_label', 'image', 'image_tag', 'desired_replicas', 'workload_class', 'change_window'))) and (deployment.get('created_by') == target['release_id']) and (deployment.get('placement_class') == target['placement']['placement_class']) and (deployment.get('update_strategy') == requirements['update_strategy']))
        pods = [row for row in after['pod'] if deployment and row.get('deployment_id') == deployment['deployment_id']]
        placements = [row.get('node_id') for row in pods]
        zones = sorted((nodes[node_id].get('zone') for node_id in placements if node_id in nodes))
        pods_ok = bool(deployment_ok and len(pods) == workload['desired_replicas'] and (len(set(placements)) == len(pods)) and (zones == sorted(target['placement']['required_zones'])) and all((row.get('phase') == 'Running' and row.get('readiness') == 'ready' and (row.get('node_id') in eligible_nodes.get(namespace_id, set())) and (nodes[row['node_id']].get('cluster_id') == cluster_id) and (nodes[row['node_id']].get('readiness') == 'ready') and (nodes[row['node_id']].get('schedulable') is True) for row in pods)))
        service_matches = [row for row in after['service'] if deployment and row.get('deployment_id') == deployment['deployment_id']]
        service = service_matches[0] if len(service_matches) == 1 else None
        dns = requested_service['external_dns'] if requirements['external_dns'] == 'required' else None
        service_ok = bool(deployment_ok and service and (service.get('namespace_id') == namespace_id) and (service.get('cluster_id') == cluster_id) and all((service.get(field) == requested_service[field] for field in ('name', 'service_role', 'access_class', 'traffic_class'))) and (service.get('selector_app') == workload['app_label']) and (service.get('service_type') == requirements['service_type']) and (service.get('external_dns') == dns) and (service.get('status') in ({'active', 'pending'} if requirements['service_type'] == 'LoadBalancer' else {'active'})) and fn__ports_match(service.get('ports', []), requested_service['ports'], requirements, cluster_id, after['service'], service['service_id']))
        capacity_ok = bool(deployment_ok and all((node_id in initial_nodes and int(nodes[node_id].get('active_pods') or 0) == int(initial_nodes[node_id].get('active_pods') or 0) + node_delta[node_id] <= int(nodes[node_id].get('allocatable_pods') or nodes[node_id].get('capacity_pods') or 0) for node_id in placements)) and (int(namespaces[namespace_id].get('active_pods') or 0) == int(initial_namespaces[namespace_id].get('active_pods') or 0) + namespace_delta[namespace_id]) and (int(clusters[cluster_id].get('pod_allocated') or 0) == int(initial_clusters[cluster_id].get('pod_allocated') or 0) + cluster_delta[cluster_id]))
        milestones = {'deployment_committed': 5.0 if deployment_ok else 0.0, 'pods_validly_placed': 7.5 if pods_ok else 0.0, 'service_contract_persisted': 7.5 if service_ok else 0.0, 'capacity_conserved': 5.0 if capacity_ok else 0.0}
        if extras:
            milestones = {key: 0.0 for key in milestones}
        score = sum(milestones.values())
        artifacts.append({'release_id': target['release_id'], 'milestones': milestones, 'score': score, 'complete': score == 25.0, 'actual_zones': zones})
    return {'task_id': task['task_id'], 'score': sum((row['score'] for row in artifacts)), 'complete_artifacts': sum((row['complete'] for row in artifacts)), 'artifacts': artifacts, 'objective_state_only': True, 'extra_outputs': extras}

def fn_public_grade(grade, release_ids):
    rows = grade.get('artifacts')
    if not isinstance(rows, list) or len(rows) != len(release_ids):
        raise ValueError('grade must describe every requested release')
    by_id = {row.get('release_id'): row for row in rows if isinstance(row, dict)}
    if set(by_id) != set(release_ids) or len(by_id) != len(rows):
        raise ValueError('grade contains missing, repeated, or foreign release IDs')
    components: dict[str, dict[str, int]] = {}
    for release_id in release_ids:
        milestones = by_id[release_id].get('milestones')
        if not isinstance(milestones, dict) or set(milestones) != {'deployment_committed', 'pods_validly_placed', 'service_contract_persisted', 'capacity_conserved'}:
            raise ValueError('grade has an invalid release milestone set')
        for (milestone, points) in milestones.items():
            if type(points) not in (int, float) or points < 0:
                raise ValueError('grade milestone points must be non-negative numbers')
            components[f'{release_id}:{milestone}'] = {'correct': int(points > 0), 'total': 1}
    result = {'score': grade['score'], 'public_components': components}
    ext_public_feedback(result)
    return result

def fn_private_task(task_id):
    packet = fn_public_task_2(task_id)
    packet.update(task_id=task_id, policy_epoch='post' if int(task_id[1:]) >= 17 else 'pre')
    return packet

def fn_digest(value):
    return mod_hashlib.sha256(fn__canonical(value).encode('ascii')).hexdigest()

def fn_binding_key(namespace_id, zone):
    return namespace_id + '|' + zone

def fn_rekey_database(database, identities):
    """Rewrite declared references, never substrings in learner-authored text."""
    result = ext_deepcopy(database)
    for rows in result.values():
        for row in rows:
            if row.get('namespace_id') in identities:
                row['namespace_id'] = identities[row['namespace_id']]
            if row.get('involved_kind') == 'Namespace' and row.get('involved_id') in identities:
                row['involved_id'] = identities[row['involved_id']]
    return result

def fn__validate_value(value, schema, path):
    if not fn__matches_type(value, schema.get('type', 'object')):
        return f"{path} must be {schema.get('type')}"
    if value is None:
        return None
    if 'enum' in schema and value not in schema['enum']:
        return f'{path} is not an allowed value'
    if isinstance(value, str) and len(value) < schema.get('minLength', 0):
        return f'{path} must not be empty'
    if isinstance(value, (int, float)) and (not isinstance(value, bool)):
        if 'minimum' in schema and value < schema['minimum']:
            return f"{path} must be at least {schema['minimum']}"
        if 'maximum' in schema and value > schema['maximum']:
            return f"{path} must be at most {schema['maximum']}"
    if isinstance(value, list):
        if len(value) < schema.get('minItems', 0):
            return f'{path} has too few items'
        if 'maxItems' in schema and len(value) > schema['maxItems']:
            return f'{path} has too many items'
        item_schema = schema.get('items')
        if item_schema:
            for (index, item) in enumerate(value):
                error = fn__validate_value(item, item_schema, f'{path}[{index}]')
                if error:
                    return error
    if isinstance(value, dict):
        properties = schema.get('properties', {})
        if schema.get('additionalProperties') is False:
            unknown = sorted(set(value) - set(properties))
            if unknown:
                return f"{path} contains unsupported field(s): {', '.join(unknown)}"
        missing = [name for name in schema.get('required', []) if name not in value]
        if missing:
            return f"{path} is missing required field(s): {', '.join(missing)}"
        for (name, item) in value.items():
            if name in properties:
                error = fn__validate_value(item, properties[name], f'{path}.{name}')
                if error:
                    return error
    return None

def fn__sanitize_raw_result(tool, result):
    if not isinstance(result, dict) or not isinstance(result.get('content'), dict):
        return {'type': 'tool_result', 'tool': tool, 'content': {'status': 'error', 'data': {}, 'message': 'UPSTREAM_TOOL_ERROR: invalid raw response'}}
    content = result['content']
    if content.get('status') != 'error':
        return result
    message = str(content.get('message') or 'UPSTREAM_TOOL_ERROR: raw tool failed')
    if message.startswith('TOOL_EXECUTION_ERROR') or message.startswith('INTERNAL_ERROR') or 'traceback' in message.lower():
        message = 'UPSTREAM_TOOL_ERROR: raw tool execution failed'
    return {'type': 'tool_result', 'tool': tool, 'content': {'status': 'error', 'data': {}, 'message': message}}

def fn_public_task(task_id):
    packet = fn_public_task_3(task_id)
    donor = DATA_DONORS.get(task_id, task_id)
    if donor not in DATA_SCOPE_REPLACEMENTS:
        return packet
    for (target, scope_id) in zip(packet['targets'], DATA_SCOPE_REPLACEMENTS[donor], strict=True):
        scope = DATA_SCOPE_TEMPLATES[scope_id]
        for key in ('cluster_selector', 'namespace_selector', 'placement'):
            target[key] = ext_deepcopy(scope[key])
    identity = 'evt-' + fn_digest(['k8s-scope-balanced-lifecycle-evolution-v2', task_id, packet['targets']])[:20]
    packet.update(task_id=identity, event_id=identity, episode_id=identity)
    return packet

def fn_condition_key(value):
    return tuple((value.get(key) for key in ('workload_class', 'change_window', 'placement_class', 'access_class', 'traffic_class')))

def fn__slug(value, default='item'):
    text = mod_re.sub('[^a-z0-9]+', '-', str(value or '').strip().lower()).strip('-')
    return text or default

def fn_policy_for_task(task, target):
    mapping = DATA_POST_POLICY if task['policy_epoch'] == 'post' else DATA_POLICY_BY_CONDITIONS
    return mapping[fn_condition_key(fn_target_conditions(target))]

def fn__ports_match(actual, requested, requirements, cluster_id, all_services, service_id):
    if len(actual) != len(requested):
        return False
    fields = ('name', 'port', 'target_port')
    wanted = {p['name']: p for p in requested}
    if len(wanted) != len(requested) or len({p.get('name') for p in actual}) != len(actual):
        return False
    allocated = set()
    for service in all_services:
        if service.get('cluster_id') == cluster_id and service.get('service_id') != service_id:
            allocated.update((p.get('node_port') for p in service.get('ports', []) if p.get('node_port') is not None))
    chosen = set()
    for port in actual:
        expected = wanted.get(port.get('name'))
        if expected is None or any((port.get(k) != expected.get(k) for k in fields)):
            return False
        if port.get('protocol') != requirements['protocol']:
            return False
        node_port = port.get('node_port')
        if requirements['service_type'] == 'NodePort':
            if type(node_port) is not int or not 30000 <= node_port <= 32767:
                return False
            if node_port in allocated or node_port in chosen:
                return False
            chosen.add(node_port)
        elif node_port is not None:
            return False
    return True

def fn_public_task_2(task_id):
    packet = fn_public_task(task_id)
    packet['completion'].update(mode='independent', priority_order='none', started_item_must_close=False)
    packet['completion']['request_order'] = 'Release requests are independent and may be processed in any order. An incomplete release does not block another release. A release still needs its own valid stable deployment and matching service; namespace allocation, live worker capacity and current release policy remain enforced.'
    return packet

def fn__canonical(value):
    return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False)

def fn__matches_type(value, expected):
    if isinstance(expected, list):
        return any((fn__matches_type(value, item) for item in expected))
    if expected == 'null':
        return value is None
    if expected == 'boolean':
        return isinstance(value, bool)
    if expected == 'integer':
        return isinstance(value, int) and (not isinstance(value, bool))
    if expected == 'number':
        return isinstance(value, (int, float)) and (not isinstance(value, bool))
    if expected == 'string':
        return isinstance(value, str)
    if expected == 'array':
        return isinstance(value, list)
    if expected == 'object':
        return isinstance(value, dict)
    return True

def fn_public_task_3(task_id):
    value = fn_public_task_4(DATA_DONORS.get(task_id, task_id))
    if task_id in DATA_DONORS:
        for (slot, target) in enumerate(value['targets'], 1):
            identity = fn_digest(['k8s-two-event-lifecycle-evolution-v1', task_id, slot])[:12]
            target['release_id'] = 'release-' + identity
            for key in ('name', 'app_label'):
                target['workload'][key] = 'workload-' + identity
            target['workload']['image_tag'] = 'build-' + identity
            target['service']['name'] = 'service-' + identity
            target['service']['external_dns'] = identity + '.release.example'
    event = 'evt-' + fn_digest(['k8s-two-event-lifecycle-evolution-v1', task_id, value['targets']])[:20]
    value.update(task_id=event, event_id=event, episode_id=event)
    value['completion'].pop('verification_required', None)
    value['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': 'publish_deployment followed by create_service', 'proves': 'the reported deployment rollout and persisted service contract for that release'}
    value['budget']['charging'].append('Synchronous receipts are sufficient for their reported committed facts. Pool and policy inspections supply current business information and retain their listed costs.')
    return value

def fn_target_conditions(target):
    return {'workload_class': target['workload']['workload_class'], 'change_window': target['workload']['change_window'], 'placement_class': target['placement']['placement_class'], 'access_class': target['service']['access_class'], 'traffic_class': target['service']['traffic_class']}

def fn_public_task_4(task_id):
    task = fn_public_task_5(task_id)
    if task_id not in DATA_REPLACEMENTS:
        return task
    for (slot, cell) in DATA_REPLACEMENTS[task_id].items():
        target = task['targets'][slot - 1]
        conditions = fn_cell_conditions(cell)
        if any((target['service'][key] != conditions[key] for key in ('access_class', 'traffic_class'))):
            raise ValueError('Coverage replacement must preserve the full service contract')
        target['workload'].update({key: conditions[key] for key in ('workload_class', 'change_window')})
    event = 'evt-' + fn_digest(['k8s-operations-binding-v9.3', task_id, task['targets']])[:20]
    task.update(task_id=event, event_id=event, episode_id=event)
    return task

def fn__bounded_int(arguments, name, default, minimum, maximum):
    if not isinstance(arguments, dict):
        return default
    value = arguments.get(name, default)
    if not isinstance(value, int) or isinstance(value, bool) or (not minimum <= value <= maximum):
        return default
    return value

def fn__safe_len(arguments, name, default, maximum):
    if not isinstance(arguments, dict):
        return default
    value = arguments.get(name)
    if not isinstance(value, list) or not 0 <= len(value) <= maximum:
        return default
    return len(value)

def fn_public_task_5(task_id):
    task = ext_deepcopy(fn_public_task_6(task_id))
    for (target, scope_id, cell_id) in zip(task['targets'], DATA_SCOPE_SCHEDULE[task_id], DATA_CELL_SCHEDULE[task_id]):
        fn__copy_scope(target, DATA_SCOPE_TEMPLATES[scope_id])
        conditions = fn_cell_conditions(cell_id)
        target['workload'].update({key: conditions[key] for key in ('workload_class', 'change_window')})
        target['service'].update({key: conditions[key] for key in ('access_class', 'traffic_class')})
    task['completion'].update({'mode': 'ordered_independent', 'priority_order': 'listed', 'subset_allowed': True, 'started_item_must_close': True})
    task['event_id'] = 'evt-' + fn_digest(['k8s-operations-binding-v9', task_id, task['targets']])[:20]
    task['task_id'] = task['event_id']
    task['episode_id'] = task['event_id']
    return task

def fn_cell_conditions(index):
    (workload, window) = DATA_WORKLOAD_CONDITIONS[index // 4]
    (access, traffic) = DATA_SERVICE_CONDITIONS[index % 4]
    return {'workload_class': workload, 'change_window': window, 'placement_class': 'zonal_pair', 'access_class': access, 'traffic_class': traffic}

def fn_public_task_6(task_id):
    task = ext_deepcopy(fn_public_task_7(task_id))
    task['allowed_tools'] = list(DATA_ALLOWED_TOOLS)
    if task_id in DATA_RECOVERY_SCOPE_TASK_IDS:
        anchor = fn_public_task_7('T08')
        for (index, target) in enumerate(task['targets']):
            donor_index = DATA_RECOVERY_SCOPE_ORDER[task_id][index]
            donor = anchor['targets'][donor_index]
            target['cluster_selector'] = ext_deepcopy(donor['cluster_selector'])
            target['namespace_selector'] = ext_deepcopy(donor['namespace_selector'])
            target['placement']['required_zones'] = list(DATA_RECOVERY_ZONES[donor_index])
            conditions = fn_cell_conditions(DATA_RECOVERY_CELL_ORDER[task_id][index])
            target['workload'].update({key: conditions[key] for key in ('workload_class', 'change_window')})
            target['service'].update({key: conditions[key] for key in ('access_class', 'traffic_class')})
    task['event_id'] = 'evt-' + fn_digest(['k8s-operations-mixed-v8', task_id, task['targets']])[:20]
    task['task_id'] = task['event_id']
    task['episode_id'] = task['event_id']
    return task

def fn__copy_scope(target, scope):
    target['cluster_selector'] = ext_deepcopy(scope['cluster_selector'])
    target['namespace_selector'] = ext_deepcopy(scope['namespace_selector'])
    target['placement'] = ext_deepcopy(scope['placement'])

def fn_public_task_7(task_id):
    task = ext_deepcopy(fn_public_task_8(task_id))
    task['allowed_tools'] = list(DATA_ALLOWED_TOOLS)
    task['budget']['charging'] = ['Cluster and namespace catalogs cost two work units plus the scanned prefix, with a minimum four-record scan page; skipped offset rows count.', 'Worker-pool catalogs cost two work units plus the scanned prefix, with a minimum two-candidate scan page; skipped offset rows count.', 'Inspecting one worker pool costs three work units; inspecting one local release policy cell costs eighteen work units.', 'Publishing a deployment consumes eight work units plus three per added replica.', 'Creating a service consumes eight work units plus two per port.', 'Invalid allowed-tool calls and failed writes consume their declared work units.']
    if task_id in DATA_PREFIX_SCOPE_DONORS:
        anchor = fn_public_task_8('T08')
        for (target_index, donor_index) in DATA_PREFIX_SCOPE_DONORS[task_id].items():
            fn__replace_scope(task['targets'][target_index], anchor['targets'][donor_index])
    if task_id in DATA_PREFIX_ZONE_SCHEDULE:
        for (target, zones) in zip(task['targets'], DATA_PREFIX_ZONE_SCHEDULE[task_id]):
            target['placement']['required_zones'] = list(zones)
    position = DATA_TASK_IDS_2.index(task_id)
    for (target, cell_id) in zip(task['targets'], DATA_CELL_SCHEDULE_2[position]):
        conditions = fn_cell_conditions(cell_id)
        target['workload'].update({key: conditions[key] for key in ('workload_class', 'change_window')})
        target['service'].update({key: conditions[key] for key in ('access_class', 'traffic_class')})
    return task

def fn_public_task_8(task_id):
    task = ext_deepcopy(fn_public_task_9(task_id))
    if task_id in {'T07', 'T11', 'T12'}:
        for target in task['targets']:
            if target['cluster_selector']['region'] == 'eu-central':
                target['placement']['required_zones'] = ['euc1b', 'euc1c']
    return task

def fn__replace_scope(target, donor):
    target['cluster_selector'] = ext_deepcopy(donor['cluster_selector'])
    target['namespace_selector'] = ext_deepcopy(donor['namespace_selector'])

def fn_public_task_9(task_id):
    position = DATA_TASK_IDS_2.index(task_id)
    task = fn_public_task_10(task_id)
    if task_id == 'T09':
        anchor = fn_public_task_10('T08')
        for (target, old) in zip(task['targets'], anchor['targets']):
            for key in ('cluster_selector', 'namespace_selector', 'placement'):
                target[key] = ext_deepcopy(old[key])
    task['schema'] = 'rescopebench-public-task/k8s-pool-release'
    task['objective'] = 'Create the four requested deployment-and-service release artifacts. Resolve the local action requirements for each full workload/service condition tuple. Place one replica in each required zone using a worker pool currently assigned to the target namespace; node readiness alone does not establish that assignment. Use the supplied DNS value only when the local policy requires DNS, otherwise omit it. Any cluster-wide free NodePort is acceptable when required.'
    for (target, cell) in zip(task['targets'], DATA_CELL_SCHEDULE_3[position]):
        conditions = fn_cell_conditions(cell)
        target['workload'].update({k: conditions[k] for k in ('workload_class', 'change_window')})
        target['service'].update({k: conditions[k] for k in ('access_class', 'traffic_class')})
        token = target['release_id'].removeprefix('rel-')
        target['service']['external_dns'] = f'svc-{token}.bench.harborbridge-ops.io'
        if task_id == 'T06' and target['cluster_selector']['region'] == 'us-east':
            target['placement']['required_zones'] = ['use1a', 'use1c']
    task['budget']['limits'][0]['allowance'] = 120
    task['budget']['charging'].append('Worker-pool catalogs cost two units plus requested rows; inspecting one pool costs three units.')
    return task

def fn_public_task_10(task_id):
    result = fn_public_task_11(task_id)
    result['schema'] = 'rescopebench-public-task/k8s-staged-structure-v4'
    result['objective'] = result['objective'] + " Place each workload in exactly the two availability zones listed in that request's placement.required_zones field."
    for target in result['targets']:
        cluster_id = 'cluster-atlas-prod-us-east' if target['cluster_selector']['region'] == 'us-east' else 'cluster-meridian-prod-eu-central'
        target['placement']['required_zones'] = list(fn_required_zones(task_id, cluster_id))
    result['completion'] = {'mode': 'independent', 'subset_allowed': True, 'priority_order': 'none', 'started_item_must_close': True, 'verification_required': False}
    result['budget'] = {'limits': [{'resource': 'API work units', 'allowance': 120}], 'charging': ['List operations consume two work units plus one per requested row.', 'Bounded inspections consume three work units plus included context; inspecting one local policy cell consumes eighteen work units.', 'Publishing a deployment consumes eight work units plus three per added replica.', 'Creating a service consumes eight work units plus two per port.', 'Invalid allowed-tool calls and failed writes consume their declared work units.'], 'exhaustion': 'An unfunded operation is rejected before business dispatch without changing business state or consuming additional work units.', 'persistence': 'API work units replenish at each request event; deployments, pods, services, namespace quota, and worker-node capacity persist.'}
    return result

def fn_public_task_11(task_id):
    if task_id not in DATA_TASK_BY_ID:
        raise ValueError(f'unknown Kubernetes task: {task_id}')
    result = fn_public_task_projection(DATA_TASK_BY_ID[task_id])
    result['schema'] = 'rescopebench-public-task/k8s-structure-v3'
    return result

def fn_required_zones(task_id, cluster_id):
    if cluster_id == 'cluster-meridian-prod-eu-central':
        return ('euc1a', 'euc1b')
    if cluster_id != 'cluster-atlas-prod-us-east':
        raise ValueError(f'unsupported cluster binding: {cluster_id}')
    if task_id in {'T08', 'T09'}:
        return ('use1a', 'use1c')
    return ('use1a', 'use1b')

def fn_public_task_projection(task):
    public = mod_copy.deepcopy(task)
    event_id = public.pop('event_id')
    public.pop('limitation', None)
    public['schema'] = 'rescopebench-public-task/k8s-stream-v2'
    public['status'] = 'frozen_runnable'
    public['runnable'] = True
    public['task_id'] = event_id
    public['episode_id'] = event_id
    public['event_id'] = event_id
    public['budget'] = {**public['budget'], 'allowance': 120, 'status': 'measured'}
    fn_assert_opaque_learner_surface(public, surface='Kubernetes public task')
    return public

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_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)}

class World:

    def __init__(self, *args, **kwargs):
        self.namespace_identity_migrations = {}
        self._kubernetes_assignment_world_init(*args, **kwargs)
        affected = set()
        for task_id in DATA_TASK_IDS:
            for target in fn_private_task(task_id)['targets']:
                cluster = next((row for row in self._rows('cluster') if all((row.get(k) == v for (k, v) in target['cluster_selector'].items()))))
                if not any((cluster['cluster_id'] + '/' + zone in DATA_CHANGED_S for zone in target['placement']['required_zones'])):
                    continue
                namespace = next((row for row in self._rows('namespace') if row['cluster_id'] == cluster['cluster_id'] and all((row.get(k) == v for (k, v) in target['namespace_selector'].items()))))
                affected.add(namespace['namespace_id'])
        self.namespace_identity_migrations = {old: 'ns-migrated-' + fn_digest(['k8s-namespace-migration-evolution-v6', old])[:20] for old in sorted(affected)}
        self._original_allocation_keys = set(self.namespace_pool_bindings)

    def _allocation_key(self, key, migrated):
        (namespace, zone) = key.rsplit('|', 1)
        return fn_binding_key(self.namespace_identity_migrations.get(namespace, namespace) if migrated else namespace, zone)

    def apply_event(self, event_id):
        if event_id != 'E1' or event_id in self.applied_boundary_events:
            return self._kubernetes_assignment_world_apply_event(event_id)
        before = self.business_hash()
        receipt = self._kubernetes_assignment_world_apply_event(event_id)
        database = self.manager.snapshot()['database']
        self.manager.db._data = fn_rekey_database(database, self.namespace_identity_migrations)
        self.manager.db._id_counters = {}
        self.manager._core_state_cache = None
        self.namespace_pool_bindings = {self._allocation_key(key, True): pool for (key, pool) in self.namespace_pool_bindings.items()}
        self._refresh_ids()
        return {**receipt, 'before': before, 'after': self.business_hash(), 'namespace_identity_migrations': ext_deepcopy(self.namespace_identity_migrations), 'preserves_workloads_capacity_and_policy': True}

    def snapshot(self):
        value = self._kubernetes_independent_world_snapshot()
        if not getattr(self, '_restoring_namespace_migration', False):
            value['namespace_identity_contract'] = {'case_version': 'k8s-namespace-migration-evolution-v6', 'migrations': ext_deepcopy(self.namespace_identity_migrations)}
        return value

    def restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('namespace_identity_contract', None) != {'case_version': 'k8s-namespace-migration-evolution-v6', 'migrations': self.namespace_identity_migrations}:
            raise ValueError('K8s namespace migration snapshot identity differs')
        migrated = 'E1' in value['applied_boundary_events']
        expected = {self._allocation_key(key, migrated) for key in self._original_allocation_keys}
        actual = value['namespace_allocation_contract']['bindings']
        if set(actual) != expected:
            raise ValueError('K8s namespace migration allocation scope differs')
        ids = {row['namespace_id'] for row in value['raw']['database']['namespace']}
        required = set(self.namespace_identity_migrations.values() if migrated else self.namespace_identity_migrations)
        forbidden = set(self.namespace_identity_migrations if migrated else self.namespace_identity_migrations.values())
        if not required <= ids or forbidden & ids:
            raise ValueError('K8s namespace migration entity scope differs')
        self.namespace_pool_bindings = ext_deepcopy(actual)
        self._restoring_namespace_migration = True
        try:
            self._kubernetes_independent_world_restore(value)
        finally:
            self._restoring_namespace_migration = False
        if self.snapshot() != snapshot:
            raise ValueError('K8s namespace migration snapshot did not round trip')

    def task(self, task_id=None):
        return fn_private_task(task_id or self.current_task_id)

    def _publish_guard(self, public_arguments):
        target = self._target_for_release(public_arguments.get('release_id'))
        if target is None:
            return ('RELEASE_REQUEST_UNKNOWN', 'release_id is not active in this request')
        workload = target['workload']
        expected = {**{key: workload[key] for key in ('name', 'app_label', 'image', 'image_tag', 'desired_replicas', 'workload_class', 'change_window')}, 'placement_class': target['placement']['placement_class'], 'access_class': target['service']['access_class'], 'traffic_class': target['service']['traffic_class']}
        if any((public_arguments.get(key) != value for (key, value) in expected.items())):
            return ('RELEASE_REQUEST_MISMATCH', 'deployment fields do not match the active release request')
        namespace_internal = self.internal_ids.get(public_arguments.get('namespace_id'))
        namespace = self._get('namespace', namespace_internal) if namespace_internal else None
        cluster = self._get('cluster', namespace.get('cluster_id')) if namespace else None
        if not namespace or not cluster:
            return ('RELEASE_SCOPE_MISMATCH', 'namespace handle is outside the active request scope')
        if any((namespace.get(key) != value for (key, value) in target['namespace_selector'].items())) or any((cluster.get(key) != value for (key, value) in target['cluster_selector'].items())):
            return ('RELEASE_SCOPE_MISMATCH', 'namespace handle is outside the active request scope')
        return None

    def public_tool_schemas(self):
        return ext_deepcopy(DATA_PUBLIC_TOOLS)

    def _inspect_pool(self, arguments):
        namespace = self._get('namespace', arguments['namespace_id'])
        pool = self.pools.get(arguments['pool_id'])
        if pool is None or namespace is None or namespace.get('cluster_id') != pool['cluster_id']:
            return self._result('inspect_worker_pool', 'error', 'POOL_SCOPE_MISMATCH: pool and namespace must share a cluster', {'error_code': 'POOL_SCOPE_MISMATCH'})
        result = self._kubernetes_binding_successor_inspect_pool({'pool_id': arguments['pool_id']})
        if result['content'].get('status') != 'success':
            return result
        data = result['content']['data']
        key = fn_binding_key(namespace['namespace_id'], pool['zone'])
        data['assignment'] = {'status': 'assigned' if namespace.get('status') == 'active' and self.namespace_pool_bindings.get(key) == pool['pool_id'] else 'not_assigned', 'binding_key': {'namespace_id': namespace['namespace_id'], 'zone': pool['zone']}, 'applies_to': {'cluster_id': pool['cluster_id'], 'namespace_id': namespace['namespace_id'], 'namespace_status': 'active'}, 'pool_id': pool['pool_id']}
        return result

    def dispatch(self, tool, arguments, actor='platform_release_operator'):
        if tool != 'inspect_worker_pool':
            return self._kubernetes_binding_successor_dispatch(tool, arguments, actor=actor)
        normalized = ext_deepcopy(arguments)
        before = self.business_hash() if self.receipt_hashes else None
        if actor != 'platform_release_operator':
            return self._record(tool, actor, normalized, self._result(tool, 'error', 'TOOL_FORBIDDEN: actor is outside the release slice'), 0, before)
        cost = self._cost(tool, normalized)
        if self.remaining < cost:
            return self._record(tool, actor, normalized, self._result(tool, 'error', 'WORK_QUOTA_EXHAUSTED: insufficient API-work quota'), 0, before)
        self.remaining -= cost
        error = fn__validate_value(normalized, DATA_SCHEMAS[tool], 'arguments')
        try:
            internal = self._internalize(normalized) if not error else None
        except (KeyError, TypeError, ValueError):
            (error, internal) = ('an object handle was not issued by this environment', None)
        result = self._result(tool, 'error', 'INVALID_ARGUMENTS: ' + error, {'error_code': 'INVALID_ARGUMENTS'}) if error else self._inspect_pool(internal)
        return self._record(tool, actor, normalized, self.publicize(result), cost, before)

    def _pool_error(self, namespace_id, node_ids, tool):
        namespace = self._get('namespace', namespace_id)
        if namespace is None:
            return None
        for node_id in node_ids:
            node = self._get('node', node_id)
            if node is None or node.get('cluster_id') != namespace['cluster_id']:
                continue
            pool = self.namespace_pool_bindings.get(fn_binding_key(namespace_id, node.get('zone', '')))
            if pool is None or node_id not in self.pools[pool]['node_ids']:
                return self._result(tool, 'error', 'WORKER_POOL_SCOPE_MISMATCH: selected worker is not allocated to this namespace in this zone', {'error_code': 'WORKER_POOL_SCOPE_MISMATCH', 'namespace_id': namespace_id, 'node_id': node_id, 'zone': node.get('zone')})
        return None

    def eligible_nodes(self):
        result = ext_defaultdict(set)
        for (key, pool) in self.namespace_pool_bindings.items():
            (namespace, _) = key.rsplit('|', 1)
            result[namespace].update(self.pools[pool]['node_ids'])
        return dict(result)

    def business_hash(self):
        return fn_digest({'parent': self._kubernetes_mixed_successor_business_hash(), 'namespace_allocations': self.namespace_pool_bindings})

    def _business_hash_from_snapshot(self, snapshot):
        return fn_digest({'parent': self._kubernetes_mixed_successor_business_hash_from_snapshot(snapshot), 'namespace_allocations': snapshot['namespace_allocation_contract']['bindings']})

    def _list_exact_namespaces(self, arguments):
        raw = self.server.call_tool('list_namespaces', state_manager=self.manager, cluster_id=arguments['cluster_id'], status_filter=arguments['status_filter'], owner_team_contains=arguments['owner_team'], limit=100, offset=0)
        result = fn__sanitize_raw_result('list_namespaces', raw)
        if result['content'].get('status') != 'success':
            return result
        rows = [row for row in result['content']['data'].get('namespaces', []) if row.get('name') == arguments['name'] and row.get('owner_team') == arguments['owner_team']]
        for row in rows:
            row['directory_id'] = f"directory:{arguments['cluster_id']}"
            row['binding_scope'] = {'cluster_id': arguments['cluster_id'], 'name': row['name'], 'owner_team': row['owner_team'], 'status': row['status']}
            row['stable_fields'] = ['namespace_id', 'cluster_id', 'directory_id', 'name', 'owner_team']
            row['live_fields'] = ['status', 'active_pods', 'quota_pods']
        result['content']['data'] = {'total_count': len(rows), 'limit': arguments['limit'], 'offset': 0, 'namespaces': rows[:arguments['limit']]}
        return result

    def prepare_task(self, task_id, **kwargs):
        result = self._kubernetes_evolution_prepare_task(task_id, **kwargs)
        result['public']['event_id'] = fn_public_task(task_id)['event_id']
        return result

    def _policy(self, arguments):
        mapping = DATA_POST_POLICY if self.policy_epoch == 'post' else DATA_POLICY_BY_CONDITIONS
        return mapping.get(fn_condition_key(arguments))

    def _public_id(self, value):
        if value not in self.public_ids:
            handle = 'obj-' + fn_digest(['k8s-operations-binding-v9', 'public-object', value])[:20]
            if handle in self.internal_ids and self.internal_ids[handle] != value:
                raise RuntimeError('public handle collision')
            self.public_ids[value] = handle
            self.internal_ids[handle] = value
        return self.public_ids[value]

    def _inspect_release_policy(self, arguments):
        result = self._kubernetes_release_adapter_inspect_release_policy(arguments)
        if result['content'].get('status') == 'success':
            data = result['content']['data']
            data['binding_scope'] = {'conditions': ext_deepcopy(data['conditions']), 'environment': 'production release policy'}
            data['stable_fields'] = ['conditions', 'requirements', 'policy_id']
            data['revalidate_on'] = ['a current policy read disagrees', 'a policy-gated write is rejected']
        return result

    def _visible_pool_binding(self, binding):
        return self.pool_bindings[binding]

    def _target_for_release(self, release_id):
        return next((target for target in self.task()['targets'] if target['release_id'] == release_id), None)

    def _release_complete(self, target):
        deployments = [row for row in self._rows('deployment') if row.get('app_label') == target['workload']['app_label'] and row.get('created_by') == target['release_id']]
        if len(deployments) != 1:
            return False
        deployment = deployments[0]
        services = [row for row in self._rows('service') if row.get('deployment_id') == deployment['deployment_id'] and row.get('name') == target['service']['name']]
        return len(services) == 1 and deployment.get('rollout_status') == 'stable'

    def _charged_error(self, tool, arguments, code, message, before_hash):
        cost = self._cost(tool, arguments)
        if self.remaining < cost:
            result = self._result(tool, 'error', 'WORK_QUOTA_EXHAUSTED: insufficient API-work quota', {'error_code': 'WORK_QUOTA_EXHAUSTED'})
            return self._record(tool, 'platform_release_operator', arguments, result, 0, before_hash)
        self.remaining -= cost
        result = self._result(tool, 'error', f'{code}: {message}', {'error_code': code})
        return self._record(tool, 'platform_release_operator', arguments, result, cost, before_hash)

    def _publish(self, arguments):
        result = self._kubernetes_pool_successor_publish(arguments)
        if result['content'].get('status') == 'success':
            for node_id in arguments.get('placement_node_ids', []):
                node = self._get('node', node_id)
                if not node:
                    continue
                binding = f"{node['cluster_id']}/{node['zone']}"
                if binding in self.binding_revalidation:
                    self.binding_revalidation[binding] = 'validated_current'
            result['content']['data']['release_ref'] = arguments['created_by']
            result['content']['data']['request_binding_verified'] = True
        return result

    def _create_service(self, arguments):
        result = self._kubernetes_pool_successor_create_service(arguments)
        if result['content'].get('status') == 'success':
            deployment = self._get('deployment', arguments['deployment_id'])
            if deployment:
                result['content']['data']['release_ref'] = deployment.get('created_by')
                result['content']['data']['artifact_binding_verified'] = True
        return result

    def apply_binding_drift(self):
        if 'k8s-worker-pool-reassignment-v9' in self.applied_boundary_events:
            return {'event_id': 'k8s-worker-pool-reassignment-v9', 'idempotent': True, 'bindings': []}
        changes = []
        for binding in DATA_CHANGED_BINDINGS:
            previous = self.pool_bindings[binding]
            replacement = next((pool_id for (pool_id, row) in self.pools.items() if f"{row['cluster_id']}/{row['zone']}" == binding and pool_id != previous))
            self.stale_pool_bindings[binding] = previous
            self.pool_bindings[binding] = replacement
            self.binding_revalidation[binding] = 'awaiting_stale_write'
            changes.append({'binding': binding, 'before': previous, 'after': replacement, 'before_nodes': list(self.pools[previous]['node_ids']), 'after_nodes': list(self.pools[replacement]['node_ids'])})
        self.applied_boundary_events.add('k8s-worker-pool-reassignment-v9')
        return {'event_id': 'k8s-worker-pool-reassignment-v9', 'idempotent': False, 'bindings': changes}

    def apply_mixed_drift(self):
        return self.apply_binding_drift()

    def apply_pool_drift(self):
        return self.apply_binding_drift()

    def _workload_policy(self, arguments):
        return self._policy(arguments)

    def semantic_hash(self):
        return fn_digest(self.snapshot())

    def _normalize(self, tool, arguments):
        if tool == 'list_namespaces' and isinstance(arguments, dict):
            normalized = ext_deepcopy(arguments)
            normalized.setdefault('limit', 4)
            normalized.setdefault('offset', 0)
            return normalized
        supplied_limit = isinstance(arguments, dict) and 'limit' in arguments
        normalized = self._kubernetes_pool_successor_normalize(tool, arguments)
        if isinstance(normalized, dict) and (not supplied_limit):
            if tool in {'list_clusters', 'list_namespaces'}:
                normalized['limit'] = 4
            elif tool == 'list_worker_pools':
                normalized['limit'] = 2
        return normalized

    def _cost(self, tool, arguments):
        if tool in {'list_clusters', 'list_namespaces', 'list_worker_pools'}:
            minimum = 2 if tool == 'list_worker_pools' else 4
            default = minimum
            if isinstance(arguments, dict):
                limit = arguments.get('limit', default)
                offset = arguments.get('offset', 0)
                if type(limit) is int and type(offset) is int and (limit >= 1) and (offset >= 0):
                    return 2 + max(minimum, offset + limit)
            return 2 + minimum
        return self._kubernetes_pool_successor_cost(tool, arguments)

    def _refresh_ids(self):
        for (entity, field) in DATA_ID_FIELDS.items():
            for row in self._rows(entity):
                self._public_id(row[field])
        for value in (*self.directories, *self.pools):
            self._public_id(value)

    def publicize(self, value, key=''):
        if isinstance(value, dict):
            return {k: self.publicize(v, k) for (k, v) in value.items()}
        if isinstance(value, list):
            return [self.publicize(v, key) for v in value]
        if isinstance(value, str) and (value in self.public_ids or key.endswith('_id') or key.endswith('_ids')):
            return self._public_id(value)
        return value

    def _internalize(self, value, key=''):
        if isinstance(value, dict):
            return {k: self._internalize(v, k) for (k, v) in value.items()}
        if isinstance(value, list):
            return [self._internalize(v, key) for v in value]
        if isinstance(value, str) and (key.endswith('_id') or key.endswith('_ids')):
            if value not in self.internal_ids:
                raise ValueError('an object handle was not issued by this environment')
            return self.internal_ids[value]
        return value

    def _namespace_members(self, cluster_id):
        return [n['namespace_id'] for n in self._rows('namespace') if n.get('cluster_id') == cluster_id and n.get('status') == 'active']

    def _scale(self, arguments):
        deployment = self._get('deployment', arguments['deployment_id'])
        if deployment:
            rejected = self._pool_error(deployment['namespace_id'], arguments.get('placement_node_ids', []), 'update_deployment_replicas')
            if rejected:
                return rejected
        return self._kubernetes_release_adapter_scale(arguments)

    def _service_guard(self, arguments):
        deployment = self._get('deployment', arguments['deployment_id'])
        if deployment and any((deployment.get('intended_' + k) != arguments[k] for k in ('access_class', 'traffic_class'))):
            return 'SERVICE_CONDITION_MISMATCH: service conditions differ from the deployment admission request'
        return self._kubernetes_release_adapter_service_guard(arguments)

    def _list_pools(self, arguments):
        cluster = self.directories.get(arguments['directory_id'])
        if cluster is None:
            return self._result('list_worker_pools', 'error', 'DIRECTORY_NOT_FOUND: unknown worker-pool directory')
        pools = [p for p in self.pools.values() if p['cluster_id'] == cluster and p['zone'] == arguments['zone']]
        pools.sort(key=lambda p: self._public_id(p['pool_id']))
        selected = pools[arguments['offset']:arguments['offset'] + arguments['limit']]
        rows = [{'pool_id': p['pool_id'], 'zone': p['zone'], 'member_count': len(p['node_ids'])} for p in selected]
        return self._result('list_worker_pools', 'success', 'OK', {'pools': rows, 'total_count': len(pools), 'limit': arguments['limit'], 'offset': arguments['offset']})

    def close(self):
        self.server.cleanup_runtime()

    def begin_episode(self, allowance=120, *, verify_business_hash=True):
        """Replenish only task-local work quota while preserving the business world."""
        if not isinstance(allowance, int) or isinstance(allowance, bool) or allowance <= 0:
            raise ValueError('allowance must be a positive integer')
        before_business_hash = self.business_hash() if verify_business_hash else None
        previous_remaining = self.remaining
        self.initial_budget = allowance
        self.remaining = allowance
        self.receipts = []
        return {'status': 'success', 'allowance': allowance, 'previous_remaining': previous_remaining, 'business_hash_preserved': self.business_hash() == before_business_hash if verify_business_hash else None}

    def _result(self, tool, status, message, data=None):
        return {'type': 'tool_result', 'tool': tool, 'content': {'status': status, 'data': data or {}, 'message': message}}

    def _record(self, tool, actor, arguments, result, cost, before_hash):
        content = result['content']
        receipt = {'index': len(self.receipts) + 1, 'tool': tool, 'actor': actor, 'arguments': mod_copy.deepcopy(arguments), 'status': content.get('status'), 'cost': cost, 'before_business_hash': before_hash, 'after_business_hash': self.business_hash() if self.receipt_hashes else None, 'remaining': self.remaining}
        self.receipts.append(receipt)
        result['budget'] = {'charged': cost, 'remaining': self.remaining}
        result['receipt_index'] = receipt['index']
        return result

    def _get(self, entity, entity_id):
        return self.manager.get_entity(entity, entity_id, id_field=DATA_ID_FIELDS[entity])

    def _rows(self, entity):
        return self.manager.list_entities(entity)

    def _save(self, entity, row):
        return self.manager.add_entity(entity, row, id_field=DATA_ID_FIELDS[entity])

    def _unique(self, candidate, entity):
        used = {row.get(DATA_ID_FIELDS[entity]) for row in self._rows(entity)}
        if candidate not in used:
            return candidate
        index = 2
        while f'{candidate}-{index}' in used:
            index += 1
        return f'{candidate}-{index}'

    def _deployment_id(self, arguments):
        namespace = str(arguments['namespace_id'])
        namespace_slug = namespace[3:] if namespace.startswith('ns-') else fn__slug(namespace)
        return f"deploy-{namespace_slug}-{fn__slug(arguments['app_label'], 'app')}-{fn__slug(arguments.get('update_strategy'), 'rolling')}"

    def _event(self, *, cluster_id, namespace_id, kind, involved_id, severity, reason, message):
        cluster_slug = cluster_id.removeprefix('cluster-')
        event_id = self._unique(f'event-{cluster_slug}-2026-05-27t12-00-00-{fn__slug(reason)}', 'cluster_event')
        row = {'event_id': event_id, 'cluster_id': cluster_id, 'namespace_id': namespace_id, 'involved_kind': kind, 'involved_id': involved_id, 'severity': severity, 'reason': reason, 'message': message, 'observed_at': '2026-05-27T12:00:00Z', 'created_at': '2026-05-27T12:00:00Z'}
        self._save('cluster_event', row)
        return {'event_id': event_id, 'severity': severity, 'reason': reason, 'observed_at': '2026-05-27T12:00:00Z'}

    def _action(self, deployment, requested_by, reason, previous, target):
        ns_slug = str(deployment['namespace_id']).removeprefix('ns-')
        action_id = self._unique(f'scale-{ns_slug}-2026-05-27t12-00-00-manual-scale', 'scaling_action')
        self._save('scaling_action', {'action_id': action_id, 'cluster_id': deployment['cluster_id'], 'namespace_id': deployment['namespace_id'], 'deployment_id': deployment['deployment_id'], 'requested_by': requested_by, 'action_type': 'manual_scale', 'previous_replicas': previous, 'target_replicas': target, 'status': 'applied', 'reason': reason, 'started_at': '2026-05-27T12:00:00Z', 'completed_at': '2026-05-27T12:00:00Z', 'created_at': '2026-05-27T12:00:00Z'})
        return action_id

    def _placement_error(self, cluster_id, node_ids, expected_count):
        if len(node_ids) != expected_count:
            return 'PLACEMENT_COUNT_MISMATCH: placement_node_ids must contain one entry per added replica'
        planned: dict[str, int] = {}
        for node_id in node_ids:
            node = self._get('node', node_id)
            if not node or node.get('cluster_id') != cluster_id:
                return 'PLACEMENT_SCOPE_MISMATCH: a placement node is absent or outside the deployment cluster'
            if node.get('role') != 'worker' or node.get('readiness') != 'ready' or (not node.get('schedulable')):
                return 'NODE_NOT_SCHEDULABLE: a placement node is not a ready schedulable worker'
            planned[node_id] = planned.get(node_id, 0) + 1
            capacity = int(node.get('allocatable_pods') or node.get('capacity_pods') or 0)
            if int(node.get('active_pods') or 0) + planned[node_id] > capacity:
                return 'NODE_CAPACITY_EXCEEDED: a placement node has insufficient pod capacity'
        return None

    def _make_pod(self, deployment, ordinal, node_id):
        namespace_slug = str(deployment['namespace_id']).removeprefix('ns-')
        base = f"pod-{namespace_slug}-{fn__slug(deployment['app_label'])}-{fn__slug(ordinal)}-running"
        pod_id = self._unique(base, 'pod')
        count = len(self._rows('pod'))
        pod = {'pod_id': pod_id, 'cluster_id': deployment['cluster_id'], 'namespace_id': deployment['namespace_id'], 'deployment_id': deployment['deployment_id'], 'node_id': node_id, 'name': f"{deployment['app_label']}-{ordinal}", 'phase': 'Running', 'readiness': 'ready', 'restart_count': 0, 'image': deployment['image'], 'image_tag': deployment['image_tag'], 'pod_ip': f'10.255.{count % 255}.{count * 7 % 255}', 'container_count': 1, 'started_at': '2026-05-27T12:00:00Z', 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z', 'labels': {'app': deployment['app_label'], 'deployment': deployment['name'], 'managed_by': 'cluster-manager'}}
        self._save('pod', pod)
        node = self._get('node', node_id)
        if node is None:
            raise RuntimeError('validated placement node disappeared')
        node['active_pods'] = int(node.get('active_pods') or 0) + 1
        node['updated_at'] = '2026-05-27T12:00:00Z'
        self._save('node', node)
        return pod

    def _reconcile_deployment(self, deployment):
        nodes = {row['node_id']: row for row in self._rows('node')}
        ready = 0
        for pod in self._rows('pod'):
            if pod.get('deployment_id') != deployment['deployment_id']:
                continue
            node = nodes.get(pod.get('node_id'))
            if pod.get('phase') == 'Running' and pod.get('readiness') == 'ready' and node and (node.get('readiness') == 'ready') and node.get('schedulable'):
                ready += 1
        desired = int(deployment.get('desired_replicas') or 0)
        deployment['ready_replicas'] = ready
        deployment['available_replicas'] = ready
        deployment['rollout_status'] = 'stable' if ready == desired else 'degraded'
        deployment['updated_at'] = '2026-05-27T12:00:00Z'
        return self._save('deployment', deployment)

    def _list_clusters(self, arguments):
        rows = self._rows('cluster')
        for field in ('region', 'environment', 'status'):
            value = arguments.get(field)
            if value:
                rows = [row for row in rows if row.get(field) == value]
        rows.sort(key=lambda row: (row.get('name') or '', row.get('cluster_id') or ''))
        total = len(rows)
        offset = arguments['offset']
        limit = arguments['limit']
        rows = rows[offset:offset + limit]
        visible = [{'cluster_id': row['cluster_id'], 'name': row.get('name'), 'region': row.get('region'), 'environment': row.get('environment'), 'status': row.get('status'), 'kubernetes_version': row.get('kubernetes_version'), 'pod_capacity': row.get('pod_capacity'), 'pod_allocated': row.get('pod_allocated')} for row in rows]
        return self._result('list_clusters', 'success', 'OK', {'total_count': total, 'limit': limit, 'offset': offset, 'clusters': visible})

    def apply_node_drift(self, event_id, node_ids):
        if event_id in self.applied_boundary_events:
            return {'status': 'success', 'event_id': event_id, 'idempotent': True, 'changed': []}
        before = self.snapshot() if self.atomic_snapshots else None
        changed: list[str] = []
        affected_deployments: set[str] = set()
        try:
            for node_id in node_ids:
                node = self._get('node', node_id)
                if not node or node.get('role') != 'worker':
                    continue
                if node.get('schedulable') or node.get('readiness') == 'ready':
                    node['schedulable'] = False
                    node['readiness'] = 'maintenance'
                    node['updated_at'] = '2026-05-27T12:00:00Z'
                    self._save('node', node)
                    changed.append(node_id)
                    for pod in self._rows('pod'):
                        if pod.get('node_id') == node_id and pod.get('phase') == 'Running' and (pod.get('readiness') == 'ready'):
                            pod['readiness'] = 'not_ready'
                            pod['updated_at'] = '2026-05-27T12:00:00Z'
                            self._save('pod', pod)
                            affected_deployments.add(pod['deployment_id'])
                    self._event(cluster_id=node['cluster_id'], namespace_id=None, kind='Node', involved_id=node_id, severity='warning', reason='NodeMaintenance', message=f"Node {node.get('name')} entered maintenance.")
            for deployment_id in affected_deployments:
                deployment = self._get('deployment', deployment_id)
                if deployment:
                    self._reconcile_deployment(deployment)
            self.applied_boundary_events.add(event_id)
        except Exception:
            if before is not None:
                self.restore(before)
            return {'status': 'error', 'event_id': event_id, 'idempotent': False, 'changed': []}
        return {'status': 'success', 'event_id': event_id, 'idempotent': False, 'changed': changed}

    def _kubernetes_assignment_world_init(self, *args, **kwargs):
        self.namespace_pool_bindings = {}
        self._kubernetes_binding_successor_init(*args, **kwargs)
        for binding in DATA_CHANGED_BINDINGS:
            (cluster, zone) = binding.split('/')
            used = {node for pool in self.pools.values() for node in pool['node_ids']}
            available = [node for node in self._rows('node') if node['cluster_id'] == cluster and node['zone'] == zone and (node.get('role') == 'worker') and (node.get('readiness') == 'ready') and (node.get('schedulable') is True) and (node['node_id'] not in used) and (int(node.get('allocatable_pods') or 0) - int(node.get('active_pods') or 0) >= 48)]
            available.sort(key=lambda node: fn_digest(['k8s-namespace-allocation-evolution-v4', 'existing-worker', node['node_id']]))
            if len(available) < 4:
                raise ValueError('Insufficient real workers for four disjoint candidate pools: ' + binding)
            for index in range(2):
                pool_id = f'pool:{binding}:{index + 2}'
                self.pools[pool_id] = {'pool_id': pool_id, 'directory_id': 'directory:' + cluster, 'cluster_id': cluster, 'zone': zone, 'node_ids': [node['node_id'] for node in available[index * 2:index * 2 + 2]]}
            for namespace in self._namespace_members(cluster):
                self.namespace_pool_bindings[fn_binding_key(namespace, zone)] = self.pool_bindings[binding]
        self._refresh_ids()

    def _kubernetes_assignment_world_apply_event(self, event_id):
        if event_id != 'E1' or event_id in self.applied_boundary_events:
            return self._kubernetes_evolution_apply_event(event_id)
        before = self.business_hash()
        changes = []
        for (key, old) in list(self.namespace_pool_bindings.items()):
            (namespace, zone) = key.rsplit('|', 1)
            cluster = self._get('namespace', namespace)['cluster_id']
            if f'{cluster}/{zone}' not in DATA_CHANGED_S:
                continue
            candidates = sorted((p['pool_id'] for p in self.pools.values() if p['cluster_id'] == cluster and p['zone'] == zone and (p['pool_id'] != old)))
            new = candidates[int(fn_digest(['k8s-namespace-allocation-evolution-v4', 'allocation', key])[:8], 16) % len(candidates)]
            self.namespace_pool_bindings[key] = new
            changes.append({'namespace_id': namespace, 'zone': zone, 'before': old, 'after': new})
        self.applied_boundary_events.add(event_id)
        return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_hash(), 'allocations': changes}

    def _kubernetes_independent_world_snapshot(self):
        value = self._kubernetes_assignment_world_snapshot()
        if not getattr(self, '_restoring_independent', False):
            value['independent_releases_contract'] = 'k8s-independent-releases-evolution-v5'
        return value

    def _kubernetes_independent_world_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('independent_releases_contract', None) != 'k8s-independent-releases-evolution-v5':
            raise ValueError('K8s independent-release snapshot version differs')
        self._restoring_independent = True
        try:
            self._kubernetes_assignment_world_restore(value)
        finally:
            self._restoring_independent = False
        if self.snapshot() != snapshot:
            raise ValueError('K8s independent-release snapshot did not round trip')

    def _kubernetes_binding_successor_inspect_pool(self, arguments):
        result = self._kubernetes_pool_successor_inspect_pool(arguments)
        if result['content'].get('status') != 'success':
            return result
        data = result['content']['data']
        pool = self.pools[arguments['pool_id']]
        binding = f"{pool['cluster_id']}/{pool['zone']}"
        assigned = self._visible_pool_binding(binding) == pool['pool_id']
        data.pop('eligible_namespace_ids', None)
        data['assignment'] = {'status': 'assigned' if assigned else 'not_assigned', 'binding_key': {'directory_id': pool['directory_id'], 'zone': pool['zone']}, 'applies_to': {'cluster_id': pool['cluster_id'], 'namespace_status': 'active'}, 'pool_id': pool['pool_id']}
        data['stable_fields'] = ['assignment.binding_key', 'assignment.applies_to', 'assignment.pool_id', 'nodes[].node_id', 'nodes[].zone']
        data['live_fields'] = ['assignment.status', 'nodes[].readiness', 'nodes[].schedulable', 'nodes[].active_pods', 'nodes[].allocatable_pods']
        return result

    def _kubernetes_binding_successor_dispatch(self, tool, arguments, actor='platform_release_operator'):
        if tool not in {'list_namespaces', 'publish_deployment'}:
            return self._kubernetes_pool_successor_dispatch(tool, arguments, actor=actor)
        normalized = ext_deepcopy(arguments) if isinstance(arguments, dict) else arguments
        if tool == 'list_namespaces' and isinstance(normalized, dict):
            normalized.setdefault('limit', 4)
            normalized.setdefault('offset', 0)
        before_hash = self.business_hash() if self.receipt_hashes else None
        if actor != 'platform_release_operator' or tool not in DATA_SCHEMAS_2:
            result = self._result(tool, 'error', 'TOOL_FORBIDDEN: tool or actor is outside the compact release slice', {'error_code': 'TOOL_FORBIDDEN'})
            return self._record(tool, actor, normalized, result, 0, before_hash)
        cost = self._cost(tool, normalized)
        if self.remaining < cost:
            result = self._result(tool, 'error', 'WORK_QUOTA_EXHAUSTED: insufficient API-work quota', {'error_code': 'WORK_QUOTA_EXHAUSTED'})
            return self._record(tool, actor, normalized, result, 0, before_hash)
        error = fn__validate_value(normalized, DATA_SCHEMAS_2[tool], 'arguments')
        if error:
            return self._charged_error(tool, normalized, 'INVALID_ARGUMENTS', error, before_hash)
        if tool == 'list_namespaces':
            self.remaining -= cost
            try:
                internal = self._internalize(normalized)
                result = self._list_exact_namespaces(internal)
            except (KeyError, TypeError, ValueError):
                result = self._result(tool, 'error', 'INVALID_ARGUMENTS: an object handle was not issued by this environment', {'error_code': 'INVALID_ARGUMENTS'})
            result = self.publicize(result)
            return self._record(tool, actor, normalized, result, cost, before_hash)
        guarded = self._publish_guard(normalized)
        if guarded is not None:
            return self._charged_error(tool, normalized, *guarded, before_hash)
        translated = ext_deepcopy(normalized)
        translated['created_by'] = translated.pop('release_id')
        result = self._kubernetes_pool_successor_dispatch(tool, translated, actor=actor)
        if self.receipts and self.receipts[-1]['tool'] == tool:
            self.receipts[-1]['arguments'] = ext_deepcopy(normalized)
        return result

    def _kubernetes_mixed_successor_business_hash(self):
        return fn_digest({'database': self.manager.snapshot()['database'], 'bindings': self.pool_bindings, 'policy_epoch': self.policy_epoch})

    def _kubernetes_mixed_successor_business_hash_from_snapshot(self, snapshot):
        return fn_digest({'database': snapshot['raw']['database'], 'bindings': snapshot['pool_successor']['bindings'], 'policy_epoch': snapshot.get('mixed_successor', {}).get('policy_epoch', 'pre')})

    def _kubernetes_evolution_prepare_task(self, task_id, **kwargs):
        if len(self.prepared_tasks) >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[len(self.prepared_tasks)]:
            raise ValueError('Kubernetes evolution task prefix differs')
        event = next((e for e in DATA_SCHEDULE_2['events'] if e['before_task'] == int(task_id[1:])), None)
        receipt = self.apply_event(event['event_id']) if event else None
        replenishment = self.begin_episode(120)
        self.current_task_id = task_id
        self.prepared_tasks.append(task_id)
        return {'public': {'status': 'ready', 'event_id': fn_public_task_3(task_id)['event_id']}, 'private_drift_receipt': receipt, 'replenishment': replenishment}

    def _kubernetes_release_adapter_inspect_release_policy(self, arguments):
        policy = self._policy(arguments)
        if policy is None:
            return self._result('inspect_release_policy', 'error', 'POLICY_COMBINATION_UNKNOWN: no local release rule matches all supplied conditions')
        return self._result('inspect_release_policy', 'success', 'OK', {'policy_id': policy['policy_id'], 'conditions': mod_copy.deepcopy(policy['conditions']), 'requirements': mod_copy.deepcopy(policy['requirements']), 'scope': 'production release policy at the current environment version'})

    def _kubernetes_pool_successor_publish(self, arguments):
        rejected = self._pool_error(arguments['namespace_id'], arguments['placement_node_ids'], 'publish_deployment')
        if rejected:
            return rejected
        result = self._kubernetes_release_adapter_publish(arguments)
        if result['content'].get('status') == 'success':
            deployment = self._get('deployment', result['content']['data']['deployment_id'])
            deployment['intended_access_class'] = arguments['access_class']
            deployment['intended_traffic_class'] = arguments['traffic_class']
            self._save('deployment', deployment)
        return result

    def _kubernetes_pool_successor_create_service(self, arguments):
        result = self._kubernetes_release_adapter_create_service(arguments)
        if result['content'].get('status') == 'success':
            service = self._get('service', result['content']['data']['service_id'])
            service['service_role'] = arguments['service_role']
            self._save('service', service)
        return result

    def _kubernetes_pool_successor_normalize(self, tool, arguments):
        result = self._kubernetes_release_adapter_normalize(tool, arguments)
        if isinstance(result, dict) and tool == 'list_worker_pools':
            result.setdefault('limit', 2)
            result.setdefault('offset', 0)
        return result

    def _kubernetes_pool_successor_cost(self, tool, arguments):
        if tool == 'list_worker_pools':
            value = arguments.get('limit', 2) if isinstance(arguments, dict) else 2
            return 2 + (value if type(value) is int and 1 <= value <= 100 else 2)
        if tool == 'inspect_worker_pool':
            return 3
        return self._kubernetes_release_adapter_cost(tool, arguments)

    def _kubernetes_release_adapter_scale(self, arguments):
        deployment = self._get('deployment', arguments['deployment_id'])
        if deployment is None:
            return self._result('update_deployment_replicas', 'error', 'DEPLOYMENT_NOT_FOUND: no deployment matches deployment_id')
        if deployment.get('rollout_status') == 'paused':
            return self._result('update_deployment_replicas', 'error', 'DEPLOYMENT_PAUSED: deployment rollout status is paused')
        namespace = self._get('namespace', deployment['namespace_id'])
        cluster = self._get('cluster', deployment['cluster_id'])
        current = int(deployment.get('desired_replicas') or 0)
        target = int(arguments['target_replicas'])
        delta = target - current
        placements = arguments.get('placement_node_ids', [])
        if delta == 0:
            if placements:
                return self._result('update_deployment_replicas', 'error', 'PLACEMENT_COUNT_MISMATCH: idempotent scale accepts no added placement')
            return self._result('update_deployment_replicas', 'success', 'OK', {'deployment_id': deployment['deployment_id'], 'previous_replicas': current, 'target_replicas': target, 'idempotent': True, 'created_pod_ids': [], 'terminated_pod_ids': []})
        if namespace is None or cluster is None:
            return self._result('update_deployment_replicas', 'error', 'PARENT_SCOPE_MISSING: deployment parent scope is incomplete')
        if namespace.get('status') == 'terminating':
            return self._result('update_deployment_replicas', 'error', 'NAMESPACE_TERMINATING: parent namespace is terminating')
        if delta > 0:
            if delta > int(namespace.get('quota_pods') or 0) - int(namespace.get('active_pods') or 0):
                return self._result('update_deployment_replicas', 'error', 'QUOTA_EXCEEDED: scale-up exceeds namespace remaining quota')
            placement_error = self._placement_error(cluster['cluster_id'], placements, delta)
            if placement_error:
                return self._result('update_deployment_replicas', 'error', placement_error)
        elif placements:
            return self._result('update_deployment_replicas', 'error', 'PLACEMENT_COUNT_MISMATCH: scale-down accepts no added placement')
        before = self.snapshot() if self.atomic_snapshots else None
        created: list[str] = []
        terminated: list[str] = []
        try:
            if delta > 0:
                for (index, node_id) in enumerate(placements):
                    created.append(self._make_pod(deployment, f'scale-{current + index:03d}', node_id)['pod_id'])
            else:
                active = [row for row in self._rows('pod') if row.get('deployment_id') == deployment['deployment_id'] and row.get('phase') == 'Running']
                active.sort(key=lambda row: row['pod_id'], reverse=True)
                if len(active) < abs(delta):
                    raise RuntimeError('not enough active pods to scale down')
                for pod in active[:abs(delta)]:
                    node_id = pod.get('node_id')
                    if node_id:
                        node = self._get('node', node_id)
                        if node:
                            node['active_pods'] = max(0, int(node.get('active_pods') or 0) - 1)
                            node['updated_at'] = '2026-05-27T12:00:00Z'
                            self._save('node', node)
                    pod['node_id'] = None
                    pod['phase'] = 'Terminating'
                    pod['readiness'] = 'not_ready'
                    pod['pod_ip'] = None
                    pod['updated_at'] = '2026-05-27T12:00:00Z'
                    self._save('pod', pod)
                    terminated.append(pod['pod_id'])
            namespace['active_pods'] = max(0, int(namespace.get('active_pods') or 0) + delta)
            namespace['updated_at'] = '2026-05-27T12:00:00Z'
            self._save('namespace', namespace)
            cluster['pod_allocated'] = max(0, int(cluster.get('pod_allocated') or 0) + delta)
            cluster['updated_at'] = '2026-05-27T12:00:00Z'
            self._save('cluster', cluster)
            deployment['desired_replicas'] = target
            deployment = self._reconcile_deployment(deployment)
            action_id = self._action(deployment, arguments['requested_by'], arguments['reason'], current, target)
            event = self._event(cluster_id=deployment['cluster_id'], namespace_id=deployment['namespace_id'], kind='Deployment', involved_id=deployment['deployment_id'], severity='normal', reason='ManualScale', message=f"Deployment {deployment['name']} scaled from {current} to {target}.")
        except Exception:
            if before is not None:
                self.restore(before)
            return self._result('update_deployment_replicas', 'error', 'ATOMIC_WRITE_FAILED: scale transaction was rolled back')
        return self._result('update_deployment_replicas', 'success', 'OK', {'deployment_id': deployment['deployment_id'], 'previous_replicas': current, 'target_replicas': target, 'ready_replicas': deployment['ready_replicas'], 'idempotent': False, 'created_pod_ids': created, 'terminated_pod_ids': terminated, 'action_id': action_id, 'event': event})

    def _kubernetes_release_adapter_service_guard(self, arguments):
        deployment = self._get('deployment', arguments['deployment_id'])
        if deployment is None:
            return None
        policy = self._policy({'workload_class': deployment.get('workload_class'), 'change_window': deployment.get('change_window'), 'placement_class': deployment.get('placement_class'), 'access_class': arguments.get('access_class'), 'traffic_class': arguments.get('traffic_class')})
        if policy is None:
            return 'RELEASE_POLICY_UNKNOWN: deployment and service conditions do not select one local policy cell'
        requirements = policy['requirements']
        service_type = arguments['service_type']
        if service_type != requirements['service_type']:
            return 'SERVICE_POLICY_MISMATCH: service_type violates the local access policy'
        ports = arguments['ports']
        names: set[str] = set()
        node_ports: set[int] = set()
        for port in ports:
            name = port['name']
            if name in names:
                return 'INVALID_PORT_SPEC: port names must be unique within the service'
            names.add(name)
            if port.get('protocol') != requirements['protocol']:
                return 'PORT_POLICY_MISMATCH: protocol violates the local traffic policy'
            node_port = port.get('node_port')
            if service_type == 'NodePort':
                if node_port is None:
                    return 'INVALID_PORT_SPEC: NodePort services require node_port'
                if node_port in node_ports:
                    return 'INVALID_PORT_SPEC: node_port values must be unique within the service'
                node_ports.add(node_port)
            elif node_port is not None:
                return 'INVALID_PORT_SPEC: node_port is only allowed for NodePort services'
        if requirements['external_dns'] == 'required' and (not str(arguments.get('external_dns') or '').strip()):
            return 'INVALID_EXTERNAL_DNS: LoadBalancer services require external_dns'
        if requirements['external_dns'] == 'forbidden' and arguments.get('external_dns') is not None:
            return 'INVALID_EXTERNAL_DNS: the selected release policy forbids external_dns'
        if node_ports:
            for service in self._rows('service'):
                if service.get('cluster_id') != deployment['cluster_id']:
                    continue
                for port in service.get('ports') or []:
                    if port.get('node_port') in node_ports:
                        return 'NODE_PORT_CONFLICT: a requested node_port is already allocated in the cluster'
        return None

    def _kubernetes_binding_successor_init(self, source=CASE_DIR / 'raw', budget=120, **kwargs):
        self.stale_pool_bindings = {}
        self.binding_revalidation = {}
        self._kubernetes_mixed_successor_init(source, budget, **kwargs)
        self.policy_epoch = 'pre'

    def _kubernetes_evolution_apply_event(self, event_id):
        if event_id not in {'E1', 'E2'}:
            raise ValueError('unknown Kubernetes event')
        if event_id in self.applied_boundary_events:
            return {'event_id': event_id, 'applied': False}
        before = self.business_hash()
        if event_id == 'E1':
            for binding in DATA_CHANGED_S:
                old = self.pool_bindings[binding]
                self.pool_bindings[binding] = next((k for (k, p) in self.pools.items() if f"{p['cluster_id']}/{p['zone']}" == binding and k != old))
        else:
            if 'E1' not in self.applied_boundary_events:
                raise ValueError('Kubernetes events must be applied in order')
            self.policy_epoch = 'post'
        self.applied_boundary_events.add(event_id)
        return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_hash()}

    def _kubernetes_assignment_world_snapshot(self):
        value = self._kubernetes_exact_namespace_world_snapshot()
        if not getattr(self, '_restoring_assignment', False):
            value['namespace_allocation_contract'] = {'case_version': 'k8s-namespace-allocation-evolution-v4', 'bindings': ext_deepcopy(self.namespace_pool_bindings), 'pools_sha256': fn_digest(self.pools)}
        return value

    def _kubernetes_assignment_world_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        contract = value.pop('namespace_allocation_contract', {})
        if contract.get('case_version') != 'k8s-namespace-allocation-evolution-v4' or contract.get('pools_sha256') != fn_digest(self.pools):
            raise ValueError('K8s namespace-allocation snapshot version or pool fixture differs')
        bindings = contract['bindings']
        if set(bindings) != set(self.namespace_pool_bindings) or any((pool not in self.pools for pool in bindings.values())):
            raise ValueError('K8s namespace-allocation snapshot scope differs')
        self.namespace_pool_bindings = ext_deepcopy(bindings)
        self._restoring_assignment = True
        try:
            self._kubernetes_exact_namespace_world_restore(value)
        finally:
            self._restoring_assignment = False
        if self.snapshot() != snapshot:
            raise ValueError('K8s namespace-allocation snapshot did not round trip')

    def _kubernetes_pool_successor_inspect_pool(self, arguments):
        pool = self.pools.get(arguments['pool_id'])
        if pool is None:
            return self._result('inspect_worker_pool', 'error', 'POOL_NOT_FOUND: unknown worker pool')
        assigned = self.pool_bindings[f"{pool['cluster_id']}/{pool['zone']}"] == pool['pool_id']
        fields = ('node_id', 'cluster_id', 'zone', 'role', 'readiness', 'schedulable', 'active_pods', 'allocatable_pods')
        members = [{k: self._get('node', n).get(k) for k in fields} for n in pool['node_ids']]
        return self._result('inspect_worker_pool', 'success', 'OK', {'pool_id': pool['pool_id'], 'directory_id': pool['directory_id'], 'zone': pool['zone'], 'eligible_namespace_ids': self._namespace_members(pool['cluster_id']) if assigned else [], 'nodes': members})

    def _kubernetes_pool_successor_dispatch(self, tool, arguments, actor='platform_release_operator'):
        normalized = self._normalize(tool, arguments) if tool in DATA_SCHEMAS_3 else arguments
        before_hash = self.business_hash() if self.receipt_hashes else None
        if actor != 'platform_release_operator' or tool not in DATA_SCHEMAS_3:
            result = self._result(tool, 'error', 'TOOL_FORBIDDEN: tool or actor is outside the compact release slice', {'error_code': 'TOOL_FORBIDDEN'})
            return self._record(tool, actor, normalized, result, 0, before_hash)
        cost = self._cost(tool, normalized)
        if self.remaining < cost:
            result = self._result(tool, 'error', 'WORK_QUOTA_EXHAUSTED: insufficient API-work quota', {'error_code': 'WORK_QUOTA_EXHAUSTED'})
            return self._record(tool, actor, normalized, result, 0, before_hash)
        error = fn__validate_value(normalized, DATA_SCHEMAS_3[tool], 'arguments')
        if error:
            self.remaining -= cost
            result = self._result(tool, 'error', 'INVALID_ARGUMENTS: ' + error, {'error_code': 'INVALID_ARGUMENTS'})
            return self._record(tool, actor, normalized, result, cost, before_hash)
        if tool == 'list_namespaces':
            self.remaining -= cost
            try:
                internal = self._internalize(normalized)
                result = self._list_exact_namespaces(internal)
            except (KeyError, TypeError, ValueError):
                result = self._result(tool, 'error', 'INVALID_ARGUMENTS: an object handle was not issued by this environment', {'error_code': 'INVALID_ARGUMENTS'})
            result = self.publicize(result)
            return self._record(tool, actor, normalized, result, cost, before_hash)
        return self._kubernetes_pool_successor_dispatch_2(tool, normalized, actor=actor)

    def _kubernetes_release_adapter_publish(self, arguments):
        namespace = self._get('namespace', arguments['namespace_id'])
        if namespace is None:
            return self._result('publish_deployment', 'error', 'NAMESPACE_NOT_FOUND: no namespace matches namespace_id')
        if namespace.get('status') != 'active':
            return self._result('publish_deployment', 'error', 'NAMESPACE_NOT_ACTIVE: namespace status is not active')
        cluster = self._get('cluster', namespace['cluster_id'])
        if cluster is None or cluster.get('status') == 'offline':
            return self._result('publish_deployment', 'error', 'CLUSTER_OFFLINE: parent cluster is unavailable')
        desired = int(arguments['desired_replicas'])
        if desired > int(namespace.get('quota_pods') or 0) - int(namespace.get('active_pods') or 0):
            return self._result('publish_deployment', 'error', 'QUOTA_EXCEEDED: requested replicas exceed namespace remaining quota')
        deployment_id = self._deployment_id(arguments)
        if self._get('deployment', deployment_id) is not None:
            return self._result('publish_deployment', 'error', 'DUPLICATE_DEPLOYMENT: derived deployment identity already exists')
        policy = self._workload_policy(arguments)
        if policy is None:
            return self._result('publish_deployment', 'error', 'RELEASE_POLICY_UNKNOWN: workload conditions do not select a local rollout policy')
        requirements = policy['requirements']
        if arguments['update_strategy'] != requirements['update_strategy']:
            return self._result('publish_deployment', 'error', 'ROLLOUT_POLICY_MISMATCH: update_strategy violates the local workload policy')
        placement_error = self._placement_error(cluster['cluster_id'], arguments['placement_node_ids'], desired)
        if placement_error:
            return self._result('publish_deployment', 'error', placement_error)
        if requirements.get('distinct_worker_zones'):
            zones = {self._get('node', node_id).get('zone') for node_id in arguments['placement_node_ids']}
            if None in zones or len(zones) != desired:
                return self._result('publish_deployment', 'error', 'PLACEMENT_POLICY_MISMATCH: zonal_pair requires one replica per distinct worker zone')
        deployment = {'deployment_id': deployment_id, 'cluster_id': cluster['cluster_id'], 'namespace_id': namespace['namespace_id'], 'name': arguments['name'].strip(), 'app_label': fn__slug(arguments['app_label']), 'image': arguments['image'].strip(), 'image_tag': arguments['image_tag'].strip(), 'desired_replicas': desired, 'ready_replicas': 0, 'available_replicas': 0, 'update_strategy': arguments['update_strategy'], 'workload_class': arguments['workload_class'], 'change_window': arguments['change_window'], 'placement_class': arguments['placement_class'], 'release_policy_id': policy['policy_id'], 'rollout_status': 'progressing', 'service_account': f"svcacct-{fn__slug(arguments['app_label'])}", 'env_vars': {'APP_MODE': cluster.get('environment'), 'REGION': cluster.get('region'), 'OWNER_TEAM': fn__slug(namespace.get('owner_team'))}, 'config_asset_ids': [], 'service_count': 0, 'created_by': arguments['created_by'].strip(), 'created_at': '2026-05-27T12:00:00Z', 'updated_at': '2026-05-27T12:00:00Z'}
        before = self.snapshot() if self.atomic_snapshots else None
        try:
            self._save('deployment', deployment)
            pod_ids = [self._make_pod(deployment, f'runtime-{index:03d}', node_id)['pod_id'] for (index, node_id) in enumerate(arguments['placement_node_ids'])]
            namespace['active_pods'] = int(namespace.get('active_pods') or 0) + desired
            namespace['updated_at'] = '2026-05-27T12:00:00Z'
            self._save('namespace', namespace)
            cluster['pod_allocated'] = int(cluster.get('pod_allocated') or 0) + desired
            cluster['updated_at'] = '2026-05-27T12:00:00Z'
            self._save('cluster', cluster)
            deployment = self._reconcile_deployment(deployment)
            event = self._event(cluster_id=cluster['cluster_id'], namespace_id=namespace['namespace_id'], kind='Deployment', involved_id=deployment_id, severity='normal', reason='RolloutReady', message=f"Deployment {deployment['name']} reached its declared placement target.")
        except Exception:
            if before is not None:
                self.restore(before)
            return self._result('publish_deployment', 'error', 'ATOMIC_WRITE_FAILED: deployment transaction was rolled back')
        return self._result('publish_deployment', 'success', 'OK', {'deployment_id': deployment_id, 'namespace_id': namespace['namespace_id'], 'cluster_id': cluster['cluster_id'], 'desired_replicas': desired, 'ready_replicas': deployment['ready_replicas'], 'rollout_status': deployment['rollout_status'], 'pod_ids': pod_ids, 'placement_node_ids': list(arguments['placement_node_ids']), 'event': event})

    def _kubernetes_release_adapter_create_service(self, arguments):
        guarded = self._service_guard(arguments)
        if guarded:
            return self._result('create_service', 'error', guarded)
        before = self.snapshot() if self.atomic_snapshots else None
        raw_arguments = {key: mod_copy.deepcopy(value) for (key, value) in arguments.items() if key not in {'access_class', 'traffic_class'}}
        try:
            raw = self.server.call_tool('create_service', state_manager=self.manager, **raw_arguments)
        except Exception:
            raw = None
        result = fn__sanitize_raw_result('create_service', raw)
        if result['content'].get('status') == 'success':
            try:
                service_id = result['content']['data']['service_id']
                service = self._get('service', service_id)
                if service is None:
                    raise RuntimeError('created service is missing')
                service['access_class'] = arguments['access_class']
                service['traffic_class'] = arguments['traffic_class']
                policy = self._policy({'workload_class': self._get('deployment', arguments['deployment_id']).get('workload_class'), 'change_window': self._get('deployment', arguments['deployment_id']).get('change_window'), 'placement_class': self._get('deployment', arguments['deployment_id']).get('placement_class'), 'access_class': arguments['access_class'], 'traffic_class': arguments['traffic_class']})
                service['release_policy_id'] = policy['policy_id']
                self._save('service', service)
            except Exception:
                if before is not None:
                    self.restore(before)
                return self._result('create_service', 'error', 'ATOMIC_WRITE_FAILED: service transaction was rolled back')
        elif before is not None and self.business_hash() != self._business_hash_from_snapshot(before):
            self.restore(before)
        return result

    def _kubernetes_release_adapter_normalize(self, tool, arguments):
        if not isinstance(arguments, dict):
            return arguments
        normalized = mod_copy.deepcopy(arguments)
        if tool in DATA_LIST_TOOLS:
            normalized.setdefault('limit', 25)
            normalized.setdefault('offset', 0)
        if tool == 'inspect_node':
            normalized.setdefault('include_pods', False)
            normalized.setdefault('include_events', False)
        if tool == 'inspect_deployment':
            normalized.setdefault('include_pods', False)
            normalized.setdefault('include_services', False)
        if tool == 'update_deployment_replicas':
            normalized.setdefault('placement_node_ids', [])
        return normalized

    def _kubernetes_release_adapter_cost(self, tool, arguments):
        if tool in DATA_LIST_TOOLS:
            return 2 + fn__bounded_int(arguments, 'limit', 25, 1, 100)
        if tool == 'inspect_node':
            if not isinstance(arguments, dict):
                return 23
            return 3 + (10 if arguments.get('include_pods', False) else 0) + (10 if arguments.get('include_events', False) else 0)
        if tool == 'inspect_deployment':
            if not isinstance(arguments, dict):
                return 23
            return 3 + (10 if arguments.get('include_pods', False) else 0) + (10 if arguments.get('include_services', False) else 0)
        if tool == 'inspect_release_policy':
            return 18
        if tool == 'publish_deployment':
            return 8 + 3 * fn__bounded_int(arguments, 'desired_replicas', 4, 1, 50)
        if tool == 'update_deployment_replicas':
            return 8 + 3 * max(1, fn__safe_len(arguments, 'placement_node_ids', 4, 100))
        if tool == 'create_service':
            return 8 + 2 * max(1, fn__safe_len(arguments, 'ports', 2, 8))
        return 0

    def _kubernetes_mixed_successor_init(self, source=CASE_DIR / 'raw', budget=120, **kwargs):
        self.policy_epoch = 'pre'
        self._kubernetes_pool_successor_init(source, budget, **kwargs)

    def _kubernetes_exact_namespace_world_snapshot(self):
        value = self._kubernetes_scope_balanced_world_snapshot()
        if not getattr(self, '_restoring_exact_namespace', False):
            value['exact_namespace_contract'] = 'k8s-exact-namespace-lifecycle-evolution-v3'
        return value

    def _kubernetes_exact_namespace_world_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('exact_namespace_contract', None) != 'k8s-exact-namespace-lifecycle-evolution-v3':
            raise ValueError('K8s exact-namespace snapshot version differs')
        self._restoring_exact_namespace = True
        try:
            self._kubernetes_scope_balanced_world_restore(value)
        finally:
            self._restoring_exact_namespace = False
        if self.snapshot() != snapshot:
            raise ValueError('K8s exact-namespace snapshot did not round trip')

    def _kubernetes_pool_successor_dispatch_2(self, tool, arguments, actor='platform_release_operator'):
        normalized = self._normalize(tool, arguments)
        before_hash = self.business_hash() if self.receipt_hashes else None
        if actor != 'platform_release_operator' or tool not in DATA_SCHEMAS_4:
            result = self._result(tool, 'error', 'TOOL_FORBIDDEN: tool or actor is outside the release-operator slice')
            return self._record(tool, actor, normalized, result, 0, before_hash)
        cost = self._cost(tool, normalized)
        if self.remaining < cost:
            return self._record(tool, actor, normalized, self._result(tool, 'error', 'WORK_QUOTA_EXHAUSTED: insufficient API-work quota'), 0, before_hash)
        self.remaining -= cost
        error = fn__validate_value(normalized, DATA_SCHEMAS_4[tool], 'arguments')
        try:
            internal = self._internalize(normalized) if not error else None
        except ValueError as exc:
            error = str(exc)
            internal = None
        if error:
            result = self._result(tool, 'error', 'INVALID_ARGUMENTS: ' + error)
        elif tool == 'list_worker_pools':
            result = self._list_pools(internal)
        elif tool == 'inspect_worker_pool':
            result = self._inspect_pool(internal)
        elif tool == 'list_clusters':
            result = self._list_clusters(internal)
        elif tool == 'inspect_release_policy':
            result = self._inspect_release_policy(internal)
        elif tool == 'publish_deployment':
            result = self._publish(internal)
        elif tool == 'create_service':
            result = self._create_service(internal)
        elif tool == 'update_deployment_replicas':
            result = self._scale(internal)
        else:
            try:
                raw = self.server.call_tool(tool, state_manager=self.manager, **internal)
            except Exception:
                raw = None
            result = fn__sanitize_raw_result(tool, raw)
            if tool == 'list_namespaces' and result['content'].get('status') == 'success':
                for row in result['content']['data'].get('namespaces', []):
                    cluster = self._get('namespace', row['namespace_id'])['cluster_id']
                    if cluster in DATA_ZONES:
                        row['directory_id'] = f'directory:{cluster}'
        content = result['content']
        if content.get('status') == 'error':
            content.setdefault('data', {}).setdefault('error_code', content.get('message', 'TOOL_ERROR').split(':', 1)[0])
        result = self.publicize(result)
        return self._record(tool, actor, normalized, result, cost, before_hash)

    def _kubernetes_pool_successor_init(self, source=CASE_DIR / 'raw', budget=120, **kwargs):
        self._kubernetes_pool_successor_init_2(source, budget, **kwargs)
        key = f"{'cluster-meridian-prod-eu-central'}/euc1c"
        candidates = [node for node in self._rows('node') if node.get('cluster_id') == 'cluster-meridian-prod-eu-central' and node.get('zone') == 'euc1c' and (node.get('role') == 'worker') and (node.get('readiness') == 'ready') and (node.get('schedulable') is True) and (int(node.get('allocatable_pods') or 0) - int(node.get('active_pods') or 0) >= 48)]
        candidates.sort(key=lambda node: fn_digest(['k8s-operations-structure-v6', 'worker-selection', node['node_id']]))
        if len(candidates) < 4:
            raise ValueError(f'insufficient independent worker candidates in {key}')
        pair = []
        for ordinal in range(2):
            pool_id = f'pool:{key}:{ordinal}'
            self.pools[pool_id] = {'pool_id': pool_id, 'directory_id': f"directory:{'cluster-meridian-prod-eu-central'}", 'cluster_id': 'cluster-meridian-prod-eu-central', 'zone': 'euc1c', 'node_ids': [node['node_id'] for node in candidates[ordinal * 2:ordinal * 2 + 2]]}
            pair.append(pool_id)
        self.pool_bindings[key] = pair[0]
        self._refresh_ids()

    def _kubernetes_scope_balanced_world_snapshot(self):
        value = self._kubernetes_evolution_snapshot()
        if not getattr(self, '_restoring_scope_balance', False):
            value['scope_balance_contract'] = 'k8s-scope-balanced-lifecycle-evolution-v2'
        return value

    def _kubernetes_scope_balanced_world_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        if value.pop('scope_balance_contract', None) != 'k8s-scope-balanced-lifecycle-evolution-v2':
            raise ValueError('K8s scope-balanced snapshot version differs')
        self._restoring_scope_balance = True
        try:
            self._kubernetes_evolution_restore(value)
        finally:
            self._restoring_scope_balance = False
        if self.snapshot() != snapshot:
            raise ValueError('K8s scope-balanced snapshot did not round trip')

    def _kubernetes_pool_successor_init_2(self, source=CASE_DIR / 'raw', budget=120, **kwargs):
        self._kubernetes_structure_successor_init(source, budget, **kwargs)
        self.directories = {f'directory:{cluster}': cluster for cluster in DATA_ZONES}
        self.pools = {}
        self.pool_bindings = {}
        for (cluster, zones) in DATA_ZONES.items():
            for zone in zones:
                candidates = [n for n in self._rows('node') if n.get('cluster_id') == cluster and n.get('zone') == zone and (n.get('role') == 'worker') and (n.get('readiness') == 'ready') and (n.get('schedulable') is True) and (int(n.get('allocatable_pods') or 0) - int(n.get('active_pods') or 0) >= 48)]
                candidates.sort(key=lambda n: fn_digest(['k8s-operations-structure-v5', 'worker-selection', n['node_id']]))
                if len(candidates) < 4:
                    raise ValueError(f'insufficient independent worker candidates in {cluster}/{zone}')
                key = f'{cluster}/{zone}'
                pair = []
                for ordinal in range(2):
                    pool_id = f'pool:{key}:{ordinal}'
                    self.pools[pool_id] = {'pool_id': pool_id, 'directory_id': f'directory:{cluster}', 'cluster_id': cluster, 'zone': zone, 'node_ids': [n['node_id'] for n in candidates[ordinal * 2:ordinal * 2 + 2]]}
                    pair.append(pool_id)
                self.pool_bindings[key] = pair[0]
        self.public_ids = {}
        self.internal_ids = {}
        self._refresh_ids()

    def _kubernetes_evolution_snapshot(self):
        value = self._kubernetes_binding_successor_snapshot()
        value['evolution'] = {'case_version': 'k8s-two-event-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2), 'policy_sha256': 'f0e7d2900c19ca712badfb4666088b7aa38c288f963d21c530e237ddfe4051b6'}
        return value

    def _kubernetes_evolution_restore(self, snapshot):
        value = ext_deepcopy(snapshot)
        metadata = value.pop('evolution')
        if metadata != {'case_version': 'k8s-two-event-lifecycle-evolution-v1', 'schedule': DATA_SCHEDULE_2, 'policy_sha256': 'f0e7d2900c19ca712badfb4666088b7aa38c288f963d21c530e237ddfe4051b6'}:
            raise ValueError('Kubernetes evolution contract differs')
        stream = value['structure_successor']
        active = stream['prepared_tasks']
        if active != list(DATA_TASK_IDS[:len(active)]) or stream['current_task_id'] != (active[-1] if active else None):
            raise ValueError('Kubernetes evolution checkpoint prefix differs')
        self._kubernetes_binding_successor_restore(value)
        expected = {e['event_id'] for e in DATA_SCHEDULE_2['events'] if e['before_task'] <= len(active)}
        if self.applied_boundary_events != expected or self.policy_epoch != ('post' if len(active) >= 17 else 'pre'):
            raise ValueError('Kubernetes evolution event state differs')
        if self.snapshot() != snapshot:
            raise ValueError('Kubernetes evolution snapshot did not round trip')

    def _kubernetes_structure_successor_init(self, source=CASE_DIR / 'raw', budget=120, *, in_memory=True, receipt_hashes=True, atomic_snapshots=True):
        source = ext_Path(source).resolve()

        def initialize(modules):
            server = modules[0]
            server.cleanup_runtime()
            server.init_database(str(source / 'data'))
            server.load_tools()
            return server.get_state_manager()
        (modules, manager) = ext_load_isolated_modules(source, ('mcp_servers.server',), initialize=initialize)
        self.source = source
        self.server = modules[0]
        self.manager = manager
        if in_memory:
            self.manager.db._flush = lambda _entity_type: None
        self.initial_budget = int(budget)
        self.remaining = int(budget)
        self.receipts: list[dict[str, ext_Any]] = []
        self.applied_boundary_events: set[str] = set()
        self.receipt_hashes = bool(receipt_hashes)
        self.atomic_snapshots = bool(atomic_snapshots)
        self.prepared_tasks: list[str] = []
        self.current_task_id: str | None = None

    def _kubernetes_binding_successor_snapshot(self):
        result = self._kubernetes_mixed_successor_snapshot()
        result['schema'] = 'rescopebench-k8s-binding-snapshot/v9'
        result['structure_successor']['provider_tools_sha256'] = '75b1c919a80d9e1402dd81859bce9618c5f623ccf5b21f2399dd30df368f679e'
        result['binding_successor'] = {'stale_pool_bindings': ext_deepcopy(self.stale_pool_bindings), 'binding_revalidation': ext_deepcopy(self.binding_revalidation)}
        return result

    def _kubernetes_binding_successor_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-k8s-binding-snapshot/v9':
            raise ValueError('unsupported Kubernetes binding snapshot')
        value = ext_deepcopy(snapshot)
        state = value.pop('binding_successor', {})
        self.stale_pool_bindings = ext_deepcopy(state.get('stale_pool_bindings', {}))
        self.binding_revalidation = ext_deepcopy(state.get('binding_revalidation', {}))
        value['schema'] = 'rescopebench-k8s-mixed-snapshot/v8'
        value['structure_successor']['provider_tools_sha256'] = 'a2414103089c1534c4ea904dfc9e729818730ad6407251f0305bc37163e8bf8b'
        self._kubernetes_mixed_successor_restore(value)

    def _kubernetes_mixed_successor_snapshot(self):
        result = self._kubernetes_pool_successor_snapshot()
        result['schema'] = 'rescopebench-k8s-mixed-snapshot/v8'
        result['mixed_successor'] = {'policy_epoch': self.policy_epoch}
        result['structure_successor']['provider_tools_sha256'] = 'a2414103089c1534c4ea904dfc9e729818730ad6407251f0305bc37163e8bf8b'
        return result

    def _kubernetes_mixed_successor_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-k8s-mixed-snapshot/v8':
            raise ValueError('unsupported Kubernetes mixed snapshot')
        mixed = snapshot.get('mixed_successor') or {}
        base = ext_deepcopy(snapshot)
        base.pop('mixed_successor', None)
        base['schema'] = 'rescopebench-k8s-pool-snapshot/v7'
        self.policy_epoch = mixed.get('policy_epoch', 'pre')
        self._kubernetes_pool_successor_restore(base)

    def _kubernetes_pool_successor_snapshot(self):
        result = self._kubernetes_pool_successor_snapshot_2()
        result['schema'] = 'rescopebench-k8s-pool-snapshot/v7'
        result['structure_successor']['provider_tools_sha256'] = 'a2414103089c1534c4ea904dfc9e729818730ad6407251f0305bc37163e8bf8b'
        return result

    def _kubernetes_pool_successor_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-k8s-pool-snapshot/v7':
            raise ValueError('unsupported Kubernetes pool snapshot')
        if snapshot.get('structure_successor', {}).get('provider_tools_sha256') != 'a2414103089c1534c4ea904dfc9e729818730ad6407251f0305bc37163e8bf8b':
            raise ValueError('snapshot provider tool profile differs from V7')
        base = ext_deepcopy(snapshot)
        base['schema'] = 'rescopebench-k8s-pool-snapshot/v6'
        self._kubernetes_pool_successor_restore_2(base)

    def _kubernetes_pool_successor_snapshot_2(self):
        result = self._kubernetes_pool_successor_snapshot_3()
        result['schema'] = 'rescopebench-k8s-pool-snapshot/v6'
        return result

    def _kubernetes_pool_successor_restore_2(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-k8s-pool-snapshot/v6':
            raise ValueError('unsupported Kubernetes pool snapshot')
        base = ext_deepcopy(snapshot)
        base['schema'] = 'rescopebench-k8s-pool-snapshot/v5'
        self._kubernetes_pool_successor_restore_3(base)

    def _kubernetes_pool_successor_snapshot_3(self):
        result = self._kubernetes_structure_successor_snapshot()
        result['schema'] = 'rescopebench-k8s-pool-snapshot/v5'
        result['pool_successor'] = {'bindings': ext_deepcopy(self.pool_bindings)}
        return result

    def _kubernetes_pool_successor_restore_3(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-k8s-pool-snapshot/v5':
            raise ValueError('unsupported Kubernetes pool snapshot')
        self.pool_bindings = ext_deepcopy(snapshot['pool_successor']['bindings'])
        base = ext_deepcopy(snapshot)
        base['schema'] = 'rescopebench-k8s-structure-snapshot/v3'
        base.pop('pool_successor')
        self._kubernetes_structure_successor_restore(base)
        self._refresh_ids()

    def _kubernetes_structure_successor_snapshot(self):
        value = self._kubernetes_release_adapter_snapshot()
        value['schema'] = 'rescopebench-k8s-structure-snapshot/v3'
        value['structure_successor'] = {'prepared_tasks': list(self.prepared_tasks), 'current_task_id': self.current_task_id, 'provider_tools_sha256': '773003f031c22e23ab9eff34715335034752a7c8b5547c8302789c248bbc2080'}
        return value

    def _kubernetes_structure_successor_restore(self, snapshot):
        if snapshot.get('schema') != 'rescopebench-k8s-structure-snapshot/v3':
            raise ValueError('unsupported Kubernetes structure snapshot')
        stream = snapshot.get('structure_successor') or {}
        base = ext_deepcopy(snapshot)
        base.pop('schema', None)
        base.pop('structure_successor', None)
        self._kubernetes_release_adapter_restore(base)
        self.prepared_tasks = list(stream.get('prepared_tasks') or [])
        self.current_task_id = stream.get('current_task_id')

    def _kubernetes_release_adapter_snapshot(self):
        return {'raw': mod_copy.deepcopy(self.manager.snapshot()), 'remaining': self.remaining, 'receipts': mod_copy.deepcopy(self.receipts), 'applied_boundary_events': sorted(self.applied_boundary_events)}

    def _kubernetes_release_adapter_restore(self, snapshot):
        database = mod_copy.deepcopy(snapshot['raw']['database'])
        self.manager.db._data = database
        self.manager.db._id_counters = {}
        for entity_type in database:
            self.manager.db._flush(entity_type)
        self.manager._counters = mod_copy.deepcopy(snapshot['raw'].get('counters', {}))
        self.manager._core_state_cache = None
        self.remaining = int(snapshot['remaining'])
        self.receipts = mod_copy.deepcopy(snapshot['receipts'])
        self.applied_boundary_events = set(snapshot.get('applied_boundary_events', []))