Select, reduce, and order executions

def export_executions(domain):
    records = []
    offset = 0
    expected_total = None
    incumbent_id = None

    while True:
        page = trajectory(domain, "records", {
            "best_only": True,
            "offset": offset,
            "limit": 64,
        })
        if expected_total is None:
            expected_total = page["total"]
            incumbent_id = page["incumbent_id"]
        elif (page["total"] != expected_total
              or page["incumbent_id"] != incumbent_id):
            raise RuntimeError("Acquisition changed during export; export again.")

        batch = page["records"]
        records.extend(batch)
        offset += len(batch)
        if offset == expected_total:
            break
        if not batch or offset > expected_total:
            raise RuntimeError("Unexpected records pagination.")

    if not 1 <= len(records) <= 512:
        raise RuntimeError("A structural stage needs 1–512 executions.")
    ids = [record["id"] for record in records]
    if len(set(ids)) != len(ids) or incumbent_id not in ids:
        raise RuntimeError("Export is missing unique IDs or its incumbent.")

    records.sort(key=lambda record: record["id"])
    return records, incumbent_id


records, incumbent_id = export_executions(ACQUISITION_DOMAIN)

def configure_structural_stage(domain, intervention, records, incumbent_id):
    create_stage(domain, {
        "mechanism": "confirmed_execution",
        "executions": records,
        "incumbent_id": incumbent_id,
        "intervention": intervention,
        "command_budget": 8,
        "objective_names": ["completion"],
        "max_contexts": 4,
    })

import math


def reset_from_context_id(context_id):
    # Load your saved scenario specification, reset the environment, and return
    # an object implementing hold_command(command, duration) and completion().
    raise NotImplementedError("Connect this to your environment reset.")


def execute_candidate(execution, context_id):
    actions = execution["actions"]
    if not 1 <= len(actions) <= 8:
        raise ValueError("Candidate exceeds the configured command budget.")
    for action in actions:
        if len(action) != 2 or any(
            not math.isfinite(value) or not -1 <= value <= 1
            for value in action
        ):
            raise ValueError("Candidate violates the two-axis action contract.")

    env = reset_from_context_id(context_id)
    for action in actions:
        env.hold_command(action, duration=0.5)
    for _ in range(8 - len(actions)):
        env.hold_command([0.0, 0.0], duration=0.5)

    # completion() uses the shared distance, speed, and safety-stop contract.
    # One value, in the same order as objective_names=["completion"].
    return [float(env.completion())]

def compare_candidates(domain, request_id, context_ids, reference_state):
    if not 1 <= len(context_ids) <= 4:
        raise ValueError("Use 1–4 contexts for this configuration.")
    if len(set(context_ids)) != len(context_ids):
        raise ValueError("Context IDs must be unique within a comparison.")

    proposal = trajectory(domain, "propose", {
        "state": reference_state,
        "goal": [0.0],
        "mode": "explore",
        "request_id": request_id,
        "context_ids": context_ids,
    })
    candidates = proposal["candidates"]
    if not candidates:
        raise RuntimeError("Proposal returned no candidates.")

    outcomes = []
    for candidate_index, candidate in enumerate(candidates):
        for context_id in context_ids:
            objectives = execute_candidate(candidate["execution"], context_id)
            outcomes.append({
                "candidate_index": candidate_index,
                "context_id": context_id,
                "objectives": objectives,
            })

    return trajectory(domain, "observe", {
        "decision_id": proposal["decision_id"],
        "outcomes": outcomes,
    })

structural_domains = {}

for intervention in ("selection", "deletion", "ordering"):
    domain = f"{PREFIX}-{intervention}"
    structural_domains[intervention] = domain
    configure_structural_stage(domain, intervention, records, incumbent_id)

    for phase in ("nomination", "confirmation"):
        context_ids = [f"{intervention}-{phase}-{i}" for i in range(4)]
        compare_candidates(
            domain=domain,
            request_id=f"{phase}-v1",
            context_ids=context_ids,
            reference_state=records[0]["initial_state"],
        )

    stage_state = trajectory(domain, "state", {})
    selected = stage_state["selected_execution"]
    if not selected:
        raise RuntimeError("Stage did not return a selected execution.")
    records = [selected]
    incumbent_id = selected["id"]

base_execution = records[0]