benchmark/simcode4d_unified/tools/runtime.py

"""Unified Dev15 worker with live mechanics, kinematics, and friction audits."""
from __future__ import annotations

import copy
import fnmatch
import hashlib
import json
import math
import sys
from pathlib import Path
import time
from typing import Any
import types

import mujoco
import numpy as np

from physics_diagnostics import annotate_kinematics, energy_summary, mechanics_snapshot


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for block in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def load_json(path: Path) -> dict[str, Any]:
    with path.open("r", encoding="utf-8") as handle:
        return json.load(handle)


def _execute_source(path: Path, module_name: str):
    module = types.ModuleType(module_name)
    module.__file__ = str(path)
    module.__package__ = ""
    sys.modules[module_name] = module
    code = compile(path.read_bytes(), str(path), "exec")
    exec(code, module.__dict__)
    return module


def import_class(path: Path, symbol: str):
    module_name = "simcode4d_dynamic_" + hashlib.sha256(
        (str(path) + ":" + sha256_file(path)).encode()
    ).hexdigest()[:16]
    support_names = [
        name
        for name in (
            "probe_api", "base_control", "mobile_control",
            "common", "dev15_common",
        )
        if (path.parent / (name + ".py")).is_file()
    ]
    managed_names = support_names + [module_name]
    sentinel = object()
    previous_modules = {
        name: sys.modules.get(name, sentinel)
        for name in managed_names
    }
    previous_path = list(sys.path)
    sys.path.insert(0, str(path.parent))
    try:
        for support_name in support_names:
            _execute_source(path.parent / (support_name + ".py"), support_name)
        module = _execute_source(path, module_name)
    finally:
        sys.path[:] = previous_path
        for name, previous in previous_modules.items():
            if previous is sentinel:
                sys.modules.pop(name, None)
            else:
                sys.modules[name] = previous
    return getattr(module, symbol)


def _named_id(model, object_type, name: str) -> int:
    result = mujoco.mj_name2id(model, object_type, name)
    if result < 0:
        raise KeyError(name)
    return int(result)


def _body_free_joint(model, body_name: str) -> int | None:
    body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, body_name)
    first = int(model.body_jntadr[body_id])
    count = int(model.body_jntnum[body_id])
    for joint_id in range(first, first + count):
        if model.jnt_type[joint_id] == mujoco.mjtJoint.mjJNT_FREE:
            return joint_id
    return None


def _set_free_pose(model, data, body_name: str, position=None, quaternion=None) -> None:
    joint_id = _body_free_joint(model, body_name)
    if joint_id is None:
        raise ValueError("body has no free joint: " + body_name)
    address = int(model.jnt_qposadr[joint_id])
    if position is not None:
        data.qpos[address:address + 3] = np.asarray(position, dtype=float)
    if quaternion is not None:
        quat = np.asarray(quaternion, dtype=float)
        quat = quat / np.linalg.norm(quat)
        data.qpos[address + 3:address + 7] = quat


def _offset_free_pose(model, data, body_name: str, xyz, yaw_rad: float = 0.0) -> None:
    joint_id = _body_free_joint(model, body_name)
    if joint_id is None:
        return
    address = int(model.jnt_qposadr[joint_id])
    data.qpos[address:address + 3] += np.asarray(xyz, dtype=float)
    if yaw_rad:
        current = data.qpos[address + 3:address + 7].copy()
        delta = np.asarray([math.cos(yaw_rad / 2.0), 0.0, 0.0, math.sin(yaw_rad / 2.0)])
        result = np.empty(4)
        mujoco.mju_mulQuat(result, delta, current)
        data.qpos[address + 3:address + 7] = result / np.linalg.norm(result)


def _hfield_height(model, geom_name: str, x: float, y: float) -> float:
    geom_id = _named_id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name)
    hfield_id = int(model.geom_dataid[geom_id])
    rows = int(model.hfield_nrow[hfield_id])
    cols = int(model.hfield_ncol[hfield_id])
    hx, hy, hz, _ = model.hfield_size[hfield_id]
    cx, cy, cz = model.geom_pos[geom_id]
    u = np.clip((x - (cx - hx)) / (2.0 * hx) * (cols - 1), 0.0, cols - 1.0)
    v = np.clip((y - (cy - hy)) / (2.0 * hy) * (rows - 1), 0.0, rows - 1.0)
    c0, r0 = int(np.floor(u)), int(np.floor(v))
    c1, r1 = min(c0 + 1, cols - 1), min(r0 + 1, rows - 1)
    du, dv = u - c0, v - r0
    address = int(model.hfield_adr[hfield_id])
    values = model.hfield_data[address:address + rows * cols].reshape(rows, cols)
    normalized = (
        (1.0 - du) * (1.0 - dv) * values[r0, c0]
        + du * (1.0 - dv) * values[r0, c1]
        + (1.0 - du) * dv * values[r1, c0]
        + du * dv * values[r1, c1]
    )
    return float(cz + hz * normalized)


def _initialize_hfield_vehicle(model, data, init: dict[str, Any]) -> None:
    body_name = init["body"]
    x, y = init["xy"]
    yaw = float(init["yaw_rad"])
    wheel_xy = np.asarray(init["wheel_xy_m"], dtype=float)
    radius = float(init["wheel_radius_m"])
    center_z = float(init["wheel_center_z_m"])
    heading = np.asarray([math.cos(yaw), math.sin(yaw), 0.0])
    lateral = np.asarray([-math.sin(yaw), math.cos(yaw), 0.0])
    points = np.asarray([x, y]) + wheel_xy[:, :1] * heading[:2] + wheel_xy[:, 1:] * lateral[:2]
    heights = np.asarray([_hfield_height(model, init["hfield_geom"], px, py) for px, py in points])
    matrix = np.column_stack([points, np.ones(len(points))])
    a, b, c = np.linalg.lstsq(matrix, heights, rcond=None)[0]
    normal = np.asarray([-a, -b, 1.0])
    normal /= np.linalg.norm(normal)
    forward = heading - np.dot(heading, normal) * normal
    forward /= np.linalg.norm(forward)
    side = np.cross(normal, forward)
    rotation = np.column_stack([forward, side, normal])
    quaternion = np.zeros(4)
    mujoco.mju_mat2Quat(quaternion, rotation.reshape(-1))
    ground = float(a * x + b * y + c)
    root = np.asarray([x, y, ground]) + normal * (radius - center_z + float(init.get("clearance_m", 0.003)))
    _set_free_pose(model, data, body_name, root, quaternion)


def _seat_hfield_vehicle(model, data, init: dict[str, Any]) -> None:
    joint_id = _body_free_joint(model, init["body"])
    if joint_id is None:
        raise ValueError("hfield vehicle has no free joint: " + init["body"])
    address = int(model.jnt_qposadr[joint_id])
    target_distance = float(init.get("contact_target_distance_m", -0.0001))
    mujoco.mj_forward(model, data)
    for _ in range(64):
        if data.ncon:
            minimum_distance = min(float(data.contact[index].dist) for index in range(data.ncon))
            correction = target_distance - minimum_distance
            if abs(correction) <= 1e-7:
                break
            data.qpos[address + 2] += correction
        else:
            data.qpos[address + 2] -= 0.001
        mujoco.mj_forward(model, data)


def _apply_initialization(model, data, gold: dict[str, Any], perturbation: dict[str, Any]) -> None:
    initialization = gold["initialization"]
    keyframe = initialization.get("keyframe")
    if keyframe:
        key_id = _named_id(model, mujoco.mjtObj.mjOBJ_KEY, keyframe)
        mujoco.mj_resetDataKeyframe(model, data, key_id)
    else:
        mujoco.mj_resetData(model, data)
    if "hfield_vehicle" in initialization:
        _initialize_hfield_vehicle(model, data, initialization["hfield_vehicle"])
    for body_name, pose in initialization.get("free_body_poses", {}).items():
        _set_free_pose(model, data, body_name, pose.get("position"), pose.get("quaternion_wxyz"))
    for joint_name, value in initialization.get("joint_positions", {}).items():
        joint_id = _named_id(model, mujoco.mjtObj.mjOBJ_JOINT, joint_name)
        data.qpos[int(model.jnt_qposadr[joint_id])] = float(value)
    for body_name, offset in initialization.get("free_body_offsets_m", {}).items():
        _offset_free_pose(model, data, body_name, offset)
    for body_name, offset in perturbation.get("body_xy_offset_m", {}).items():
        _offset_free_pose(model, data, body_name, [offset[0], offset[1], 0.0])
    for body_name, yaw in perturbation.get("body_yaw_offset_rad", {}).items():
        _offset_free_pose(model, data, body_name, [0.0, 0.0, 0.0], float(yaw))
    if "hfield_vehicle" in initialization:
        _seat_hfield_vehicle(model, data, initialization["hfield_vehicle"])
    data.qvel[:] = 0.0
    data.ctrl[:] = 0.0
    mujoco.mj_forward(model, data)
    if "hfield_vehicle" in initialization:
        max_depth = max((max(0.0, -float(data.contact[i].dist)) for i in range(data.ncon)), default=0.0)
        if max_depth > 0.001:
            raise RuntimeError(f"hfield initialization penetration exceeds 1 mm: {max_depth}")


def _apply_model_perturbation(model, perturbation: dict[str, Any]) -> None:
    for body_name, scale in perturbation.get("body_mass_scale", {}).items():
        body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, body_name)
        model.body_mass[body_id] *= float(scale)
        model.body_inertia[body_id] *= float(scale)
    for geom_name, scale in perturbation.get("geom_friction_scale", {}).items():
        geom_id = _named_id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name)
        model.geom_friction[geom_id] *= float(scale)

    for body_name, scale in perturbation.get("body_geom_friction_scale", {}).items():
        body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, body_name)
        for geom_id in range(model.ngeom):
            current = int(model.geom_bodyid[geom_id])
            while current > 0 and current != body_id:
                current = int(model.body_parentid[current])
            if current == body_id:
                model.geom_friction[geom_id] *= float(scale)

def _model_fingerprint(model) -> str:
    digest = hashlib.sha256()
    arrays = (
        model.body_mass, model.body_inertia, model.geom_type, model.geom_size,
        model.geom_pos, model.geom_quat, model.geom_friction, model.geom_contype,
        model.geom_conaffinity, model.jnt_type, model.jnt_axis, model.jnt_range,
        model.actuator_gear, model.actuator_ctrlrange, model.eq_type, model.eq_data,
    )
    for array in arrays:
        digest.update(np.asarray(array).tobytes())
    return digest.hexdigest()


def _object_velocity(model, data, body_id: int) -> tuple[list[float], list[float]]:
    velocity = np.zeros(6)
    mujoco.mj_objectVelocity(
        model, data, mujoco.mjtObj.mjOBJ_BODY, body_id, velocity, 0
    )
    return velocity[3:].tolist(), velocity[:3].tolist()


def _contact_snapshot(model, data) -> tuple[list[dict[str, Any]], float, float]:
    contacts = []
    maximum_depth = 0.0
    maximum_force = 0.0
    force = np.zeros(6)
    for index in range(data.ncon):
        contact = data.contact[index]
        geom1 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_GEOM, contact.geom1) or "geom_" + str(contact.geom1)
        geom2 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_GEOM, contact.geom2) or "geom_" + str(contact.geom2)
        body1_id = int(model.geom_bodyid[contact.geom1])
        body2_id = int(model.geom_bodyid[contact.geom2])
        body1 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_BODY, body1_id) or "world"
        body2 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_BODY, body2_id) or "world"
        mujoco.mj_contactForce(model, data, index, force)
        depth = max(0.0, -float(contact.dist))
        normal_force = abs(float(force[0]))
        tangential_force = math.hypot(float(force[1]), float(force[2]))
        torsional_torque = abs(float(force[3]))
        rolling_torque = math.hypot(float(force[4]), float(force[5]))
        friction = [float(value) for value in contact.friction]
        active_friction_axes = 0
        if int(contact.dim) >= 3:
            active_friction_axes = 2
        if int(contact.dim) >= 4:
            active_friction_axes = 3
        if int(contact.dim) >= 6:
            active_friction_axes = 5
        normalized_friction_loads = []
        if normal_force > 1e-9:
            for axis in range(active_friction_axes):
                coefficient = max(abs(friction[axis]), 1e-12)
                normalized_friction_loads.append(
                    abs(float(force[axis + 1])) / (coefficient * normal_force)
                )
        cone_is_pyramidal = int(model.opt.cone) == int(
            mujoco.mjtCone.mjCONE_PYRAMIDAL
        )
        if cone_is_pyramidal:
            cone_utilization = sum(normalized_friction_loads)
        else:
            cone_utilization = math.sqrt(
                sum(value * value for value in normalized_friction_loads)
            )
        linear1, angular1 = _object_velocity(model, data, body1_id)
        linear2, angular2 = _object_velocity(model, data, body2_id)
        point = np.asarray(contact.pos, dtype=float)
        velocity1 = (
            np.asarray(linear1)
            + np.cross(np.asarray(angular1), point - data.xpos[body1_id])
        )
        velocity2 = (
            np.asarray(linear2)
            + np.cross(np.asarray(angular2), point - data.xpos[body2_id])
        )
        normal_axis = np.asarray(contact.frame, dtype=float).reshape(3, 3)[0]
        relative_velocity = velocity2 - velocity1
        tangential_velocity = relative_velocity - normal_axis * float(np.dot(relative_velocity, normal_axis))
        slip_speed = float(np.linalg.norm(tangential_velocity))
        maximum_depth = max(maximum_depth, depth)
        maximum_force = max(maximum_force, normal_force)
        contacts.append({
            "geom1": geom1,
            "geom2": geom2,
            "body1": body1,
            "body2": body2,
            "distance_m": float(contact.dist),
            "normal_force_N": normal_force,
            "tangential_force_N": tangential_force,
            "contact_frame_force_torque": [float(value) for value in force],
            "torsional_torque_Nm": torsional_torque,
            "rolling_torque_Nm": rolling_torque,
            "friction_coefficients": {"sliding_1": friction[0], "sliding_2": friction[1], "torsional": friction[2], "rolling_1": friction[3], "rolling_2": friction[4]},
            "contact_dimension": int(contact.dim),
            "friction_cone_type": "pyramidal" if cone_is_pyramidal else "elliptic",
            "normalized_friction_loads": normalized_friction_loads,
            "coulomb_cone_utilization": cone_utilization,
            "tangential_slip_speed_mps": slip_speed,
        })
    return contacts, maximum_depth, maximum_force


def _group_active(model, data, binding: dict[str, Any]) -> bool:
    condition = binding.get("active_when")
    if not condition:
        return True
    joint_id = _named_id(model, mujoco.mjtObj.mjOBJ_JOINT, condition["joint"])
    value = float(data.qpos[int(model.jnt_qposadr[joint_id])])
    if "minimum_position" in condition and value < float(condition["minimum_position"]):
        return False
    if "maximum_position" in condition and value > float(condition["maximum_position"]):
        return False
    return True


def _group_matches(contact: dict[str, Any], endpoint: int, binding: dict[str, Any]) -> bool:
    geom_name = contact["geom" + str(endpoint)]
    body_name = contact["body" + str(endpoint)]
    return (
        any(fnmatch.fnmatchcase(geom_name, pattern) for pattern in binding.get("geoms", []))
        or any(fnmatch.fnmatchcase(body_name, pattern) for pattern in binding.get("bodies", []))
    )


def _semantic_contacts(model, data, contacts: list[dict[str, Any]], policy: dict[str, Any], pairs: list[list[str]]) -> dict[str, dict[str, Any]]:
    groups = policy["groups"]
    matches: dict[str, dict[str, Any]] = {}
    for left, right in pairs:
        left_binding = groups[left]
        right_binding = groups[right]
        if not _group_active(model, data, left_binding) or not _group_active(model, data, right_binding):
            continue
        rule = left + "/" + right
        for contact in contacts:
            if contact["normal_force_N"] <= 0.0 and contact["distance_m"] >= 0.0:
                continue
            direct = _group_matches(contact, 1, left_binding) and _group_matches(contact, 2, right_binding)
            reverse = _group_matches(contact, 2, left_binding) and _group_matches(contact, 1, right_binding)
            if direct or reverse:
                matches[rule] = contact
                break
    return matches


def _forbidden_contacts(model, data, contacts: list[dict[str, Any]], policy: dict[str, Any]) -> dict[str, dict[str, Any]]:
    return _semantic_contacts(model, data, contacts, policy, policy["forbidden"])


def _joint_limit_violations(model, data, tolerance: float = 1e-4) -> dict[str, dict[str, float]]:
    violations: dict[str, dict[str, float]] = {}
    for joint_id in range(model.njnt):
        if not bool(model.jnt_limited[joint_id]):
            continue
        if model.jnt_type[joint_id] not in (mujoco.mjtJoint.mjJNT_HINGE, mujoco.mjtJoint.mjJNT_SLIDE):
            continue
        position = float(data.qpos[int(model.jnt_qposadr[joint_id])])
        lower, upper = (float(value) for value in model.jnt_range[joint_id])
        excess = max(lower - position, position - upper, 0.0)
        if excess > tolerance:
            name = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_JOINT, joint_id) or "joint_" + str(joint_id)
            violations[name] = {
                "position": position,
                "lower": lower,
                "upper": upper,
                "excess": excess,
            }
    return violations


def _qualified_trace(trace: list[set[str]], timestep_s: float, dwell_s: float) -> tuple[bool, float, list[dict[str, Any]]]:
    minimum_steps = max(1, int(math.ceil(dwell_s / timestep_s - 1e-12)))
    qualified = np.zeros(len(trace), dtype=bool)
    runs: list[dict[str, Any]] = []
    labels = sorted(set().union(*trace)) if trace else []
    for label in labels:
        start = None
        for index in range(len(trace) + 1):
            active = index < len(trace) and label in trace[index]
            if active and start is None:
                start = index
            elif not active and start is not None:
                count = index - start
                if count >= minimum_steps:
                    qualified[start:index] = True
                    runs.append({
                        "rule": label,
                        "start_time_s": (start + 1) * timestep_s,
                        "end_time_s": index * timestep_s,
                        "duration_s": count * timestep_s,
                    })
                start = None
    ratio = float(np.count_nonzero(qualified) / len(trace)) if trace else 0.0
    return bool(runs), ratio, runs


def _observation(model, data, body_names: list[str], joint_names: list[str]) -> dict[str, Any]:
    bodies = {}
    for name in body_names:
        body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, name)
        linear, angular = _object_velocity(model, data, body_id)
        bodies[name] = {
            "position": data.xpos[body_id].tolist(),
            "quaternion": data.xquat[body_id].tolist(),
            "linear_velocity": linear,
            "angular_velocity": angular,
        }
    joints = {}
    for name in joint_names:
        joint_id = _named_id(model, mujoco.mjtObj.mjOBJ_JOINT, name)
        qpos_address = int(model.jnt_qposadr[joint_id])
        dof_address = int(model.jnt_dofadr[joint_id])
        joints[name] = {
            "position": float(data.qpos[qpos_address]),
            "velocity": float(data.qvel[dof_address]),
        }
    contacts, depth, force = _contact_snapshot(model, data)
    return {
        "time_s": float(data.time),
        "bodies": bodies,
        "joints": joints,
        "contacts": contacts,
        "maximum_penetration_m": depth,
        "maximum_contact_force_N": force,
    }


def _apply_static_field(model, data, field: dict[str, Any] | None) -> dict[str, float]:
    data.xfrc_applied[:] = 0.0
    if not field:
        return {}
    if field["type"] != "static_fluid":
        raise ValueError("unsupported static field: " + field["type"])
    body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, field["body"])
    body_position = data.xpos[body_id]
    linear, angular = _object_velocity(model, data, body_id)
    water_level = float(field["surface_z_m"])
    depth_span = float(field["immersion_span_m"])
    submerged = max(0.0, min(1.0, (water_level - (body_position[2] - depth_span * 0.5)) / depth_span))
    density = float(field["density_kg_m3"])
    volume = float(field["displaced_volume_m3"])
    buoyancy = density * 9.81 * volume * submerged
    vx, _, vz = linear
    drag_x = -float(field["drag_x"]) * submerged * vx * abs(vx)
    drag_z = -float(field["drag_z"]) * submerged * vz * abs(vz)
    pitch_drag = -float(field["pitch_drag"]) * submerged * angular[1]
    data.xfrc_applied[body_id] = [drag_x, 0.0, buoyancy + drag_z, 0.0, pitch_drag, 0.0]
    return {
        "submerged_fraction": submerged,
        "buoyancy_N": buoyancy,
        "drag_x_N": drag_x,
        "drag_z_N": drag_z,
    }


def _resolve_controls(model, requested: dict[str, float], limits: dict[str, list[float]]) -> tuple[np.ndarray, list[dict[str, Any]]]:
    controls = np.zeros(model.nu)
    violations: list[dict[str, Any]] = []
    for name, raw_value in requested.items():
        actuator_id = _named_id(model, mujoco.mjtObj.mjOBJ_ACTUATOR, name)
        value = float(raw_value)
        if not math.isfinite(value):
            raise ValueError("non-finite actuator command: " + name)
        if name in limits:
            lo, hi = limits[name]
        elif bool(model.actuator_ctrllimited[actuator_id]):
            lo, hi = model.actuator_ctrlrange[actuator_id]
        else:
            raise ValueError("missing explicit limit for actuator: " + name)
        lower, upper = float(lo), float(hi)
        if value < lower - 1e-9 or value > upper + 1e-9:
            violations.append({
                "actuator": name, "requested": value,
                "lower": lower, "upper": upper,
            })
        controls[actuator_id] = max(lower, min(upper, value))
    return controls, violations


def _try_grasp(model, data, api: dict[str, Any], observation: dict[str, Any]) -> tuple[bool, str]:
    equality_id = _named_id(model, mujoco.mjtObj.mjOBJ_EQUALITY, api["equality"])
    if bool(data.eq_active[equality_id]):
        return True, "already_active"
    a = observation["bodies"][api["body_a"]]["position"]
    b = observation["bodies"][api["body_b"]]["position"]
    distance = math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))
    if distance > float(api["maximum_distance_m"]):
        return False, "distance_gate"
    if api.get("contact_required", False):
        body_a = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, api["body_a"])
        body_b = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, api["body_b"])
        touching = False
        for contact in data.contact[:data.ncon]:
            pair = {int(model.geom_bodyid[contact.geom1]), int(model.geom_bodyid[contact.geom2])}
            if body_a in pair and body_b in pair:
                touching = True
                break
        if not touching:
            return False, "contact_gate"
    data.eq_active[equality_id] = 1
    return True, "activated"


def run_episode(
    suite_root: Path,
    case_spec_path: Path,
    case_gold_path: Path,
    generation_seed: int,
    physics_seed: int,
    output_dir: Path,
) -> dict[str, Any]:
    case_spec = load_json(case_spec_path)
    case_gold = load_json(case_gold_path)
    workspace = suite_root.parents[1]
    model_path = workspace / case_spec["artifacts"]["runtime_model"]["path"]
    expected_model_hash = case_spec["artifacts"]["runtime_model"]["sha256"]
    if sha256_file(model_path) != expected_model_hash:
        raise RuntimeError("runtime model hash mismatch")
    model = mujoco.MjModel.from_xml_path(str(model_path))
    model.opt.timestep = float(case_spec["simulator"]["timestep_s"])
    perturbation = copy.deepcopy(case_gold["perturbations"][str(physics_seed)])
    _apply_model_perturbation(model, perturbation)
    data = mujoco.MjData(model)
    _apply_initialization(model, data, case_gold, perturbation)
    protected_hash = _model_fingerprint(model)

    probe_path = suite_root / case_spec["probe"]["path"]
    validator_path = suite_root / case_spec["validator"]["path"]
    ProbeClass = import_class(probe_path, "PROBE_CLASS")
    probe = ProbeClass()
    probe.reset(case_spec, case_gold)
    actuator_limits = case_spec["probe"]["actuator_limits"]
    body_names = case_spec["observation"]["bodies"]
    joint_names = case_spec["observation"]["joints"]
    field = case_spec.get("static_field")
    grasp_api = case_spec["probe"].get("grasp_api")
    contact_policy = case_gold["contact_policy"]
    allowed_equality_id = None
    if grasp_api:
        allowed_equality_id = _named_id(model, mujoco.mjtObj.mjOBJ_EQUALITY, grasp_api["equality"])
    initial_eq_active = data.eq_active.copy()

    initial_observation = _observation(model, data, body_names, joint_names)
    initial_admissibility = {
        "finite": bool(np.isfinite(data.qpos).all() and np.isfinite(data.qvel).all()),
        "maximum_penetration_m": initial_observation["maximum_penetration_m"],
        "penetration_pass_1mm": initial_observation["maximum_penetration_m"] <= 0.001,
    }

    duration = float(case_spec["probe"]["episode_duration_s"])
    log_hz = float(case_spec["probe"]["log_hz"])
    log_period = 1.0 / log_hz
    next_log = 0.0
    frames = []
    events = []
    maximum_penetration = initial_observation["maximum_penetration_m"]
    maximum_force = initial_observation["maximum_contact_force_N"]
    maximum_penetration_contact = None
    maximum_penetration_time_s = 0.0
    penetration_samples: list[float] = []
    force_samples: list[float] = []
    tangential_force_samples: list[float] = []
    friction_utilization_samples: list[float] = []
    slip_speed_samples: list[float] = []
    observed_semantic_contacts: set[str] = set()
    forbidden_trace: list[set[str]] = []
    joint_limit_trace: list[set[str]] = []
    friction_failure_trace: list[set[str]] = []
    friction_examples: dict[str, dict[str, Any]] = {}
    forbidden_examples: dict[str, dict[str, Any]] = {}
    joint_limit_examples: dict[str, dict[str, float]] = {}
    action_bound_examples: dict[str, dict[str, Any]] = {}
    undeclared_equality_examples: dict[str, dict[str, Any]] = {}
    finite = True
    grasp_active = False
    start = time.perf_counter()

    while data.time < duration - model.opt.timestep * 0.5:
        observation = _observation(model, data, body_names, joint_names)
        command = probe.command(float(data.time), copy.deepcopy(observation))
        resolved_controls, control_violations = _resolve_controls(model, command.controls, actuator_limits)
        data.ctrl[:] = resolved_controls
        for violation in control_violations:
            actuator = violation["actuator"]
            if actuator not in action_bound_examples:
                example = dict(violation)
                example["t"] = float(data.time)
                action_bound_examples[actuator] = example
        if command.grasp_request and grasp_api:
            activated, reason = _try_grasp(model, data, grasp_api, observation)
            if activated and not grasp_active:
                events.append({"event": "grasp_activated", "t": float(data.time), "reason": reason})
                grasp_active = True
        for marker in command.markers:
            if not any(item["event"] == marker for item in events):
                events.append({"event": marker, "t": float(data.time)})
        field_state = _apply_static_field(model, data, field)
        mujoco.mj_step(model, data)
        contacts, depth, force = _contact_snapshot(model, data)
        friction_failures: set[str] = set()
        for contact in contacts:
            penetration_samples.append(max(0.0, -float(contact["distance_m"])))
            force_samples.append(float(contact["normal_force_N"]))
            tangential_force_samples.append(float(contact["tangential_force_N"]))
            friction_utilization_samples.append(float(contact["coulomb_cone_utilization"]))
            slip_speed_samples.append(float(contact["tangential_slip_speed_mps"]))
            if contact["normal_force_N"] > 1e-6 and contact["coulomb_cone_utilization"] > 1.25:
                label = contact["geom1"] + "/" + contact["geom2"]
                friction_failures.add(label)
                if label not in friction_examples:
                    example = dict(contact)
                    example["t"] = float(data.time)
                    friction_examples[label] = example
        friction_failure_trace.append(friction_failures)
        allowed_matches = _semantic_contacts(model, data, contacts, contact_policy, contact_policy["allowed"])
        for rule, contact in allowed_matches.items():
            if rule not in observed_semantic_contacts:
                events.append({"event": "semantic_contact", "rule": rule, "t": float(data.time), "contact": contact})
                observed_semantic_contacts.add(rule)

        forbidden_matches = _forbidden_contacts(model, data, contacts, contact_policy)
        forbidden_trace.append(set(forbidden_matches))
        for rule, contact in forbidden_matches.items():
            if rule not in forbidden_examples:
                example = dict(contact)
                example["t"] = float(data.time)
                forbidden_examples[rule] = example
        joint_limit_matches = _joint_limit_violations(model, data)
        joint_limit_trace.append(set(joint_limit_matches))
        for joint_name, violation in joint_limit_matches.items():
            if joint_name not in joint_limit_examples:
                example = dict(violation)
                example["t"] = float(data.time)
                joint_limit_examples[joint_name] = example
        for equality_id in range(model.neq):
            if bool(data.eq_active[equality_id]) and not bool(initial_eq_active[equality_id]) and equality_id != allowed_equality_id:
                equality_name = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_EQUALITY, equality_id) or "equality_" + str(equality_id)
                if equality_name not in undeclared_equality_examples:
                    undeclared_equality_examples[equality_name] = {"equality": equality_name, "t": float(data.time)}
        if depth > maximum_penetration:
            maximum_penetration = depth
            maximum_penetration_time_s = float(data.time)
            maximum_penetration_contact = min(contacts, key=lambda item: item["distance_m"]) if contacts else None
        maximum_force = max(maximum_force, force)
        if not np.isfinite(data.qpos).all() or not np.isfinite(data.qvel).all():
            finite = False
            events.append({"event": "non_finite_state", "t": float(data.time)})
            break
        if data.time + 1e-9 >= next_log:
            frame_observation = _observation(model, data, body_names, joint_names)
            frames.append({
                "t": float(data.time),
                "mechanics": mechanics_snapshot(model, data),
                "bodies": frame_observation["bodies"],
                "joints": frame_observation["joints"],
                "contacts": contacts,
                "maximum_penetration_m": depth,
                "maximum_contact_force_N": force,
                "controls": {
                    model.actuator(i).name: float(data.ctrl[i])
                    for i in range(model.nu)
                },
                "field": field_state,
                "grasp_active": grasp_active,
            })
            next_log += log_period

    dwell_time_s = 0.010
    forbidden_episode, forbidden_ratio, forbidden_runs = _qualified_trace(
        forbidden_trace, float(model.opt.timestep), dwell_time_s
    )
    joint_limit_episode, joint_limit_ratio, joint_limit_runs = _qualified_trace(
        joint_limit_trace, float(model.opt.timestep), dwell_time_s
    )
    friction_cone_episode, friction_cone_ratio, friction_cone_runs = _qualified_trace(
        friction_failure_trace, float(model.opt.timestep), dwell_time_s
    )
    for run in forbidden_runs:
        run["first_observation"] = forbidden_examples[run["rule"]]
        events.append({
            "event": "forbidden_contact_violation",
            "t": run["start_time_s"],
            "rule": run["rule"],
        })
    for run in joint_limit_runs:
        run["first_observation"] = joint_limit_examples[run["rule"]]
        events.append({
            "event": "joint_limit_violation",
            "t": run["start_time_s"],
            "joint": run["rule"],
        })
    for run in friction_cone_runs:
        run["first_observation"] = friction_examples[run["rule"]]
        events.append({
            "event": "friction_cone_failure",
            "t": run["start_time_s"],
            "contact_pair": run["rule"],
        })
    dynamic_penetration_p95 = float(np.percentile(penetration_samples, 95)) if penetration_samples else 0.0
    contact_force_p95 = float(np.percentile(force_samples, 95)) if force_samples else 0.0
    tangential_force_p95 = float(np.percentile(tangential_force_samples, 95)) if tangential_force_samples else 0.0
    friction_utilization_p95 = float(np.percentile(friction_utilization_samples, 95)) if friction_utilization_samples else 0.0
    friction_utilization_max = max(friction_utilization_samples, default=0.0)
    slip_speed_p95 = float(np.percentile(slip_speed_samples, 95)) if slip_speed_samples else 0.0
    slip_speed_max = max(slip_speed_samples, default=0.0)
    friction_warning_sample_ratio = (
        sum(value > 1.05 for value in friction_utilization_samples)
        / len(friction_utilization_samples)
        if friction_utilization_samples
        else 0.0
    )
    kinematics = annotate_kinematics(frames)
    energy = energy_summary(frames)

    mutation_pass = protected_hash == _model_fingerprint(model)
    raw = {
        "schema_version": "simcode4d.dev15.episode-log.v1",
        "case_id": case_spec["case_id"],
        "world_id": case_spec["world_id"],
        "generation_seed": generation_seed,
        "physics_seed": physics_seed,
        "artifact_hashes": {
            "runtime_model_sha256": expected_model_hash,
            "case_spec_sha256": sha256_file(case_spec_path),
            "case_gold_sha256": sha256_file(case_gold_path),
            "probe_sha256": sha256_file(probe_path),
            "validator_sha256": sha256_file(validator_path),
            "runtime_sha256": sha256_file(Path(__file__)),
            "physics_diagnostics_sha256": sha256_file(Path(__file__).with_name("physics_diagnostics.py")),
        },
        "simulator": {
            "name": "mujoco",
            "version": mujoco.__version__,
            "timestep_s": float(model.opt.timestep),
        },
        "initial_admissibility": initial_admissibility,
        "finite_execution": finite,
        "model_mutation_guard_pass": mutation_pass,
        "integrity_audit": {
            "action_bound_violation": bool(action_bound_examples),
            "action_bound_examples": [action_bound_examples[key] for key in sorted(action_bound_examples)],
            "undeclared_equality_activation": bool(undeclared_equality_examples),
            "undeclared_equality_examples": [undeclared_equality_examples[key] for key in sorted(undeclared_equality_examples)],
            "integrity_violation": bool(
                not finite
                or not mutation_pass
                or action_bound_examples
                or undeclared_equality_examples
            ),
        },
        "safety": {
            "minimum_dwell_s": dwell_time_s,
            "forbidden_contact_episode": forbidden_episode,
            "forbidden_contact_time_ratio": forbidden_ratio,
            "forbidden_contact_runs": forbidden_runs,
            "joint_limit_violation_episode": joint_limit_episode,
            "joint_limit_violation_time_ratio": joint_limit_ratio,
            "joint_limit_violation_runs": joint_limit_runs,
            "friction_cone_failure_episode": friction_cone_episode,
            "friction_cone_failure_time_ratio": friction_cone_ratio,
            "friction_cone_failure_runs": friction_cone_runs,
            "friction_warning_sample_ratio": friction_warning_sample_ratio,
            "friction_utilization_p95": friction_utilization_p95,
            "friction_utilization_max": friction_utilization_max,
            "tangential_slip_speed_p95_mps": slip_speed_p95,
            "tangential_slip_speed_max_mps": slip_speed_max,
            "dynamic_penetration_p95_m": dynamic_penetration_p95,
            "contact_force_p95_N": contact_force_p95,
        },
        "grasp_api_used": grasp_active,
        "events": events,
        "frames": frames,
        "summary": {
            "duration_simulated_s": float(data.time),
            "maximum_penetration_m": maximum_penetration,
            "maximum_penetration_time_s": maximum_penetration_time_s,
            "maximum_penetration_contact": maximum_penetration_contact,
            "maximum_contact_force_N": maximum_force,
            "tangential_contact_force_p95_N": tangential_force_p95,
            "friction_utilization_p95": friction_utilization_p95,
            "friction_utilization_max": friction_utilization_max,
            "tangential_slip_speed_p95_mps": slip_speed_p95,
            "tangential_slip_speed_max_mps": slip_speed_max,
            "friction_warning_sample_ratio": friction_warning_sample_ratio,
            "friction_contact_sample_count": len(friction_utilization_samples),
            "slip_reporting_sample_count": sum(
                value > 0.02 for value in slip_speed_samples
            ),
            "dynamic_penetration_p95_m": dynamic_penetration_p95,
            "contact_force_p95_N": contact_force_p95,
            **kinematics,
            **energy,
            "wall_time_s": time.perf_counter() - start,
        },
    }
    output_dir.mkdir(parents=True, exist_ok=False)
    raw_path = output_dir / "episode_log.json"
    with raw_path.open("w", encoding="utf-8") as handle:
        json.dump(raw, handle, indent=2, sort_keys=True)

    ValidatorClass = import_class(validator_path, "VALIDATOR_CLASS")
    validation = ValidatorClass().validate(raw, case_spec, case_gold)
    validation["raw_event_log_sha256"] = sha256_file(raw_path)
    validation["validator_sha256"] = sha256_file(validator_path)
    validation_path = output_dir / "validation.json"
    with validation_path.open("w", encoding="utf-8") as handle:
        json.dump(validation, handle, indent=2, sort_keys=True)
    return validation