react-manip 0.1.0__py3-none-any.whl

react_manip-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,131 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose.  However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software.  Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else.  These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization.  **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

react_manip-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+assets
+configs
+react_manip
+scripts
+tasks

scripts/add_phone_lean_to_bank.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Add three config-only phone_lean candidates to an existing candidate bank."""
+from __future__ import annotations
+
+import argparse
+from copy import deepcopy
+import json
+from pathlib import Path
+import shutil
+import sys
+
+import numpy as np
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from react_manip.core.compatibility import resolve_task_robot
+from react_manip.core.scenarios import Scenario
+from react_manip.instances.candidate_bank import load_bank, write_json
+from react_manip.instances.records import VERSION, digest, load_suite, save_record, seal
+from react_manip.instances.runtime import (
+    ReplayEnv,
+    _construct,
+    capture_state,
+    contract_for,
+    runtime_identity,
+    spec_for,
+)
+from tasks.phone_lean.instances import sample_episode_instance, sample_task_instance
+
+
+TASK_ID = "phone_lean"
+CANDIDATE_SEEDS = (0, 1, 2)
+EPISODES_PER_CANDIDATE = 15
+REQUIRED_SUPPORTS = frozenset({"bowl", "bottle"})
+
+
+def _build_group(out: Path, index: int, task_seed: int, report: dict) -> dict:
+    spec = spec_for(TASK_ID)
+    contract = contract_for(TASK_ID)
+    robot = resolve_task_robot(spec)
+    task = sample_task_instance(task_seed)
+    if not REQUIRED_SUPPORTS.intersection(task["support_names"]):
+        raise ValueError(
+            f"task seed {task_seed} must contain at least one of {sorted(REQUIRED_SUPPORTS)}"
+        )
+
+    identity = f"{TASK_ID}_{index:03d}"
+    scenario = Scenario("1.0", TASK_ID, identity, task_seed, task)
+    base_scene = sample_episode_instance(task, 1_000_000)
+    scenario.metadata["initial_episode_scene"] = deepcopy(base_scene)
+    env = _construct(TASK_ID, scenario, robot, episode=base_scene)
+    try:
+        env.reset()
+        instance = seal(
+            "task_instance",
+            task_id=TASK_ID,
+            task_instance_id=identity,
+            task_spec_digest=digest(spec.to_dict()),
+            contract_digest=digest(contract),
+            robot_id=robot,
+            scenario=scenario.to_dict(),
+            runtime=runtime_identity(env, TASK_ID),
+            provenance={"sampler": VERSION, "seed": task_seed},
+        )
+    finally:
+        env.close()
+
+    instance_ref = f"instances/{identity}.json"
+    save_record(instance, out / instance_ref)
+    group = {
+        "task_instance": {
+            "path": instance_ref,
+            "digest": instance["content_digest"],
+        },
+        "episodes": [],
+    }
+    episodes = []
+    for episode_seed in range(EPISODES_PER_CANDIDATE):
+        scene = sample_episode_instance(task, episode_seed)
+        env = _construct(TASK_ID, scenario, robot, episode=scene)
+        try:
+            env.reset()
+            if runtime_identity(env, TASK_ID) != instance["runtime"]:
+                raise ValueError("Episode layout changed the frozen Task runtime identity")
+            episode_id = f"{identity}_e{episode_seed:03d}"
+            episode = seal(
+                "episode_instance",
+                task_id=TASK_ID,
+                task_instance_id=identity,
+                task_instance_digest=instance["content_digest"],
+                episode_id=episode_id,
+                initial_state=capture_state(env),
+                round_plan=None,
+                provenance={"sampler": VERSION, "seed": episode_seed},
+                scene=scene,
+            )
+        finally:
+            env.close()
+        episode_ref = f"episodes/{episode_id}.json"
+        save_record(episode, out / episode_ref)
+        group["episodes"].append(
+            {"path": episode_ref, "digest": episode["content_digest"]}
+        )
+        episodes.append(episode)
+
+    replay = ReplayEnv(instance, cameras=False)
+    try:
+        language_sample = None
+        for episode_index, episode in enumerate(episodes):
+            replay.bind(episode)
+            _, reset_info = replay.reset()
+            if capture_state(replay) != episode["initial_state"]:
+                raise ValueError(f"{episode['episode_id']}: replay state is not exact")
+            info = replay.step(np.zeros(replay.action_dim))[-1]
+            if info["language_prompt_structured"] != replay._wrapped.get_language_prompt():
+                raise ValueError(f"{episode['episode_id']}: language prompt changed after one step")
+            if episode_index == 0:
+                language_sample = {
+                    "task_instance_id": identity,
+                    "task_id": TASK_ID,
+                    "episode_id": episode["episode_id"],
+                    "prompt": reset_info["language_prompt_structured"],
+                }
+    finally:
+        replay.close()
+
+    report["candidates"].append(
+        {
+            "task_instance_id": identity,
+            "task_seed": task_seed,
+            "support_names": task["support_names"],
+            "small_support_names": task["small_support_names"],
+            "large_support_names": task["large_support_names"],
+            "base_episode_seed": base_scene["episode_seed"],
+            "episode_seeds": list(range(EPISODES_PER_CANDIDATE)),
+            "exact_replays": EPISODES_PER_CANDIDATE,
+        }
+    )
+    report["language_samples"].append(language_sample)
+    print(
+        f"{identity}: task_seed={task_seed}, supports={task['support_names']}, "
+        f"{EPISODES_PER_CANDIDATE} exact replays",
+        flush=True,
+    )
+    return group
+
+
+def extend_bank(source: Path, out: Path) -> None:
+    source = source.resolve()
+    source_bank, source_manifest_path, source_manifest, by_task = load_bank(source)
+    if TASK_ID in by_task:
+        raise ValueError(f"{TASK_ID} already exists in the source bank")
+    if out.exists():
+        raise FileExistsError(f"output already exists: {out}")
+    shutil.copytree(source.parent, out)
+
+    extension = {
+        "schema_version": "phone-lean-bank-extension.v1",
+        "task_id": TASK_ID,
+        "candidate_seeds": list(CANDIDATE_SEEDS),
+        "episodes_per_candidate": EPISODES_PER_CANDIDATE,
+        "selection_rule": "Each fixed candidate seed must include bowl or bottle; no solvability screening or seed replacement.",
+        "verification": "Every generated Episode restored exactly and advanced one zero-action step.",
+        "candidates": [],
+        "language_samples": [],
+    }
+    new_groups = [
+        _build_group(out, index, seed, extension)
+        for index, seed in enumerate(CANDIDATE_SEEDS)
+    ]
+
+    _, source_groups = load_suite(source_manifest_path)
+    task_by_digest = {
+        instance["content_digest"]: instance["task_id"]
+        for instance, _ in source_groups
+    }
+    task_by_digest.update(
+        {group["task_instance"]["digest"]: TASK_ID for group in new_groups}
+    )
+    groups = [*source_manifest["groups"], *new_groups]
+    groups.sort(
+        key=lambda group: (
+            task_by_digest[group["task_instance"]["digest"]],
+            group["task_instance"]["path"],
+        )
+    )
+    manifest = seal(
+        "manifest",
+        suite_id=source_manifest["suite_id"],
+        protocol=source_manifest["protocol"],
+        groups=groups,
+    )
+    write_json(out / "candidates.json", manifest)
+
+    bank = deepcopy(source_bank)
+    bank["manifest_digest"] = manifest["content_digest"]
+    bank.pop("content_digest")
+    bank["content_digest"] = digest(bank)
+    write_json(out / "bank.json", bank)
+
+    generation_path = source.parent / "generation.json"
+    generation = json.loads(generation_path.read_text())
+    generation["instances"] = len(groups)
+    generation["episodes"] = sum(len(group["episodes"]) for group in groups)
+    generation["extended_from_bank_digest"] = source_bank["content_digest"]
+    generation.setdefault("extensions", []).append(extension)
+    generation.setdefault("robots", {})[TASK_ID] = resolve_task_robot(spec_for(TASK_ID))
+    first_instance = json.loads(
+        (out / new_groups[0]["task_instance"]["path"]).read_text()
+    )
+    generation.setdefault("cameras", {})[TASK_ID] = first_instance["runtime"]["cameras"]
+    generation.setdefault("language_samples", []).extend(extension["language_samples"])
+    generation["included_tasks"] = sorted({*generation.get("included_tasks", []), TASK_ID})
+    generation["excluded_tasks"] = []
+    generation["bank_digest"] = bank["content_digest"]
+    write_json(out / "generation.json", generation)
+
+    loaded_bank, _, loaded_manifest, loaded = load_bank(out / "bank.json")
+    if loaded_bank["content_digest"] != bank["content_digest"]:
+        raise ValueError("written bank digest changed during validation")
+    if len(loaded_manifest["groups"]) != len(source_manifest["groups"]) + 3:
+        raise ValueError("candidate manifest group count mismatch")
+    if len(loaded[TASK_ID]) != 3 or any(len(episodes) != 15 for _, episodes in loaded[TASK_ID]):
+        raise ValueError("phone_lean bank must contain three groups of fifteen Episodes")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--source",
+        type=Path,
+        default=ROOT / "react_manip/suites/piperx_candidates_v1/bank.json",
+    )
+    parser.add_argument("--out", type=Path, required=True, help="new output directory")
+    args = parser.parse_args()
+    extend_bank(args.source, args.out)
+
+
+if __name__ == "__main__":
+    main()

scripts/agilex_wheeled_builder.py

@@ -0,0 +1,133 @@
+"""Official aloha_new URDF chassis tree -> free-root MJCF.
+
+CAD and inertias come from pinned upstream. The operator display bundled in the
+mobile body CAD is intentionally omitted; a head camera is added by the outer
+builder at the same upper-body station. Wheel servo/friction are explicitly
+simulation tuning, not system identification. No planar propulsion actuators.
+"""
+import xml.etree.ElementTree as ET
+import numpy as np
+
+
+def add_wheeled_base(root, base, source, fetch, destination, pose):
+    import trimesh
+    links = {x.get("name"): x for x in source.findall("link")}
+    joints = source.findall("joint")
+    ET.SubElement(base, "freejoint", name="mobile_free")
+    bounds = {}
+
+    def add(link_name, parent, origin):
+        link = links[link_name]
+        name = "mobile_" + link_name
+        body = ET.SubElement(parent, "body", name=name, **pose(origin))
+        if link_name in ("left_wheel_link", "right_wheel_link"):
+            xyz = np.fromstring(body.get("pos"), sep=" ")
+            xyz[2] -= 0.011
+            body.set("pos", " ".join(map(str, xyz)))
+        inertial = link.find("inertial")
+        # Upstream puts chassis inertia in an identity fixed child. Merge it
+        # onto the chassis body so MuJoCo never infers mass from mass-zero CAD.
+        if link_name == "base_link":
+            inertial = links["inertial_link"].find("inertial")
+        if inertial is not None:
+            inertia_origin = inertial.find("origin")
+            if inertia_origin is not None and not np.allclose(np.fromstring(inertia_origin.get("rpy", "0 0 0"), sep=" "), 0):
+                raise ValueError("rotated chassis inertia requires tensor conversion")
+            inertia = inertial.find("inertia")
+            ET.SubElement(body, "inertial", mass=inertial.find("mass").get("value"),
+                          pos=inertial.find("origin").get("xyz", "0 0 0"),
+                          fullinertia=" ".join(inertia.get(k) for k in ("ixx", "iyy", "izz", "ixy", "ixz", "iyz")))
+        for i, visual in enumerate(link.findall("visual")):
+            mesh = visual.find("geometry/mesh")
+            path = mesh.get("filename").removeprefix("package://")
+            raw = fetch(path)
+            converted = destination / (name + f"_{i}.obj")
+            scene = trimesh.load(str(raw), force="scene")
+            geometry = scene.to_geometry()
+            # The upstream mobile CAD stores the operator display and frame
+            # in one ``body_Link`` mesh. The benchmark replaces that display
+            # with a head camera, so clip only the elevated panel (z~=1.18--
+            # 1.34 m in this link frame) while preserving the chassis below.
+            # Applying the filter before exporting and collision decomposition
+            # keeps visual and physical geometry consistent.
+            if link_name == "body_Link":
+                geometry.update_faces(geometry.triangles_center[:, 2] < 1.15)
+                geometry.remove_unreferenced_vertices()
+            geometry.export(str(converted))
+            bounds[link_name] = geometry.bounds.tolist()
+            mesh_name = name + f"_mesh{i}"
+            ET.SubElement(root.find("asset"), "mesh", name=mesh_name, file=str(converted.resolve()),
+                          scale=mesh.get("scale", "1 1 1"))
+            ET.SubElement(body, "geom", name=name + f"_vis{i}", type="mesh", mesh=mesh_name,
+                          group="1", contype="0", conaffinity="0", mass="0", rgba="0.35 0.38 0.42 1",
+                          **pose(visual.find("origin")))
+            # Convex hull of official collision shape for rigid chassis/frame.
+            # Wheels use analytic rolling surfaces fitted to the CAD bounds.
+            if link_name in ("left_wheel_link", "right_wheel_link"):
+                extent = geometry.extents
+                center = geometry.bounds.mean(axis=0)
+                radius = max(extent[0], extent[2]) / 2
+                ET.SubElement(body, "geom", name=name+"_tire", type="cylinder",
+                              pos=" ".join(map(str, center)), quat="0.70710678 0.70710678 0 0",
+                              size=f"{radius} {extent[1]/2}", friction="1.0 0.001 0.0001", condim="3", mass="0")
+            elif link_name.endswith("wheel_link") and link_name[:2] in ("fl", "fr", "rl", "rr"):
+                extent = geometry.extents
+                # Mesh is in wheel frame; local Z is its rotation axis.
+                ET.SubElement(body, "geom", name=name+"_roller", type="cylinder",
+                              pos=" ".join(map(str, geometry.bounds.mean(axis=0))),
+                              size=f"{max(extent[:2])/2} {extent[2]/2}", friction="0.8 0.001 0.0001", mass="0")
+            elif link_name == "body_Link":
+                # Separate CAD solids: a hull of the entire frame incorrectly
+                # fills its open spaces. Omit thin sheets and small fasteners.
+                pieces = geometry.split(only_watertight=False, repair=False)
+                for k, piece in enumerate(pieces):
+                    if min(piece.extents) < .003 or max(piece.extents) < .04:
+                        continue
+                    # Rotated zero-thickness sheets can have nonzero XYZ
+                    # extents; reject them before MuJoCo's 3D hull compiler.
+                    centered = piece.vertices - piece.vertices.mean(axis=0)
+                    if np.linalg.svd(centered, compute_uv=False)[-1] / np.sqrt(len(centered)) < .0005:
+                        continue
+                    hull = piece.convex_hull
+                    path = destination / f"mobile_frame_collision_{k}.obj"
+                    hull.export(str(path))
+                    mesh_id = f"mobile_frame_collision_{k}"
+                    ET.SubElement(root.find("asset"), "mesh", name=mesh_id, file=str(path.resolve()))
+                    ET.SubElement(body, "geom", name=mesh_id, type="mesh", mesh=mesh_id,
+                                  mass="0", **pose(visual.find("origin")))
+            else:
+                for collision in link.findall("collision"):
+                    ET.SubElement(body, "geom", name=name+f"_collision{i}", type="mesh", mesh=mesh_name,
+                                  mass="0", **pose(collision.find("origin")))
+        for joint in joints:
+            if joint.find("parent").get("link") != link_name:
+                continue
+            child_name = joint.find("child").get("link")
+            if child_name == "inertial_link":
+                continue
+            if child_name.startswith(("fl_base", "fr_base", "bl_base", "br_base")):
+                continue
+            child = add(child_name, body, joint.find("origin"))
+            if child_name.endswith("wheel_link") and child_name[:2] in ("fl", "fr", "rl", "rr"):
+                # Rollers sit inside chassis wheel wells; its convex hull has
+                # no wheel-well cutouts. Other wheel contacts remain enabled.
+                ET.SubElement(root.find("contact"), "exclude", body1="mobile_base_link", body2=child.get("name"))
+            if joint.get("type") != "fixed":
+                jname = "mobile_" + joint.get("name")
+                ET.SubElement(child, "joint", name=jname, type="hinge", axis=joint.find("axis").get("xyz"),
+                              damping="0.02", armature="0.01")
+                if joint.get("name") in ("left_wheel", "right_wheel"):
+                    ET.SubElement(root.find("actuator"), "velocity", name=jname+"_motor", joint=jname,
+                                  kv="40", ctrllimited="true", ctrlrange="-6 6", forcelimited="true", forcerange="-20 20")
+            ET.SubElement(root.find("contact"), "exclude", body1=name, body2=child.get("name"))
+        return body
+
+    for name in ("base_link", "body_Link"):
+        joint = next(j for j in joints if j.find("child").get("link") == name)
+        add(name, base, joint.find("origin"))
+    radius = (bounds["left_wheel_link"][1][2] - bounds["left_wheel_link"][0][2]) / 2
+    return {"wheel_radius": radius, "track_width": 0.34, "cad_bounds": bounds,
+            "source": "aloha_new.urdf", "drive": "free root, two velocity-actuated wheels; passive caster hinges",
+            "servo_calibrated": False, "drive_axle_z_correction_m": -0.011,
+            "wheel_servo": {"kv": 40, "torque_limit_nm": 20, "speed_limit_rad_s": 6},
+            "collision": "CAD chassis hull with wheel-well exclusions; frame component hulls (thickness under 3mm, span under 40mm and degenerate sheets omitted); CAD-fitted wheel cylinders"}

scripts/audit_task_solvability.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""Bounded privileged witnesses on unchanged bank environments; no model score."""
+import argparse, ast, importlib, importlib.util, json, sys, types, traceback, hashlib, subprocess
+from pathlib import Path
+import numpy as np
+ROOT=Path(__file__).resolve().parents[1]
+sys.path.insert(0,str(ROOT))
+from react_manip.instances.candidate_bank import load_bank
+from react_manip.instances.runtime import ReplayEnv, runtime_identity, _json
+
+LEGACY_REF = "05025dc395aaf709685c50773600cf50f109529d"
+
+def prepare_controllers(destination):
+    """Recover diagnostic algorithms, never historical environments or physics."""
+    if destination.exists(): return
+    names=subprocess.check_output(['git','ls-tree','-r','--name-only',LEGACY_REF],cwd=ROOT,text=True).splitlines()
+    tasks={p.parent.name for p in (ROOT/'tasks').glob('*/task_spec.json')}
+    for name in names:
+        if not ((name.startswith('tasks/') and name.split('/')[1] in tasks and '/operation/' in name and name.endswith('.py')) or name == 'tasks/car_drive2/demo_aloha.py'): continue
+        source=subprocess.check_output(['git','show',LEGACY_REF+':'+name],cwd=ROOT,text=True)
+        source=source.replace('benchmark.','react_manip.').replace('frontends.arm_actions','react_manip.robots.arm_actions').replace("(p/'benchmark')","(p/'react_manip')").replace('(p / "benchmark")','(p / "react_manip")')
+        source=source.replace('from react_manip.core.episode import EpisodeEvaluator\n','')
+        if name.endswith('/ring_toss1/operation/solve.py'):
+            source=source.replace('{"right": gripper, "left": -1.0}', '{arm: (gripper if arm == "right" else -1.0) for arm in env.robots[0].arms}')
+            source='\n'.join(line for line in source.splitlines() if not any(x in line for x in ('controller.output_max[:3] =','controller.output_min[:3] =','controller.action_scale =')))+'\n'
+        if name.endswith('/rope_hang/operation/rebalance.py'):
+            class KeepOriginalPhysics(ast.NodeTransformer):
+                def visit_Assign(self,node):
+                    forbidden=('model.actuator_gainprm','model.actuator_biasprm','self._arm_controller.kp','self._arm_controller.kd')
+                    return ast.copy_location(ast.Pass(),node) if any(x in ast.unparse(node.targets) for x in forbidden) else node
+            source=ast.unparse(KeepOriginalPhysics().visit(ast.parse(source)))+'\n'
+        target=destination/name;target.parent.mkdir(parents=True,exist_ok=True);target.write_text(source)
+
+class Finished(BaseException): pass
+class Session:
+    def __init__(self, env):
+        self.replay=env; self.task_id=env._instance['task_id']; self.env=self; self.actions=[]; self.info={}; self.observation={}; self.ended=False
+    def __getattr__(self,k): return getattr(self.replay.env,k)
+    def close(self): pass
+    def reset(self, **kwargs):
+        if self.actions: raise RuntimeError('Controller reset after rollout started')
+        self.observation,self.info=self.replay.reset()
+        return self.observation
+    def step(self,a):
+        if self.ended: raise Finished()
+        a=np.asarray(a,float)
+        self.actions.append(a.tolist())
+        self.observation,r,t,tr,self.info=self.replay.step(a)
+        self.ended=bool(t or tr)
+        if len(self.actions)%500==0: print('progress',len(self.actions),flush=True)
+        if self.ended: raise Finished()
+        return self.observation,r,self.ended,self.info
+
+def load_module(name,path):
+    spec=importlib.util.spec_from_file_location(name,path)
+    module=importlib.util.module_from_spec(spec);sys.modules[name]=module;spec.loader.exec_module(module)
+    return module
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--task',required=True);p.add_argument('--candidate',type=int,default=0);p.add_argument('--replay-actions',type=Path);p.add_argument('--out',type=Path,required=True)
+    args=p.parse_args();out=args.out.resolve();out.mkdir(parents=True,exist_ok=False)
+    legacy=ROOT/'outputs/solvability_20261012/legacy'
+    prepare_controllers(legacy)
+    bank,_,_,groups=load_bank(ROOT/'react_manip/suites/piperx_candidates_v1/bank.json')
+    instance,episodes=groups[args.task][args.candidate];episode=episodes[0]
+    report=dict(task=args.task,robot=instance['robot_id'],bank_digest=bank['content_digest'],instance_digest=instance['content_digest'],episode_digest=episode['content_digest'],episode_id=episode['episode_id'],controller_source_commit=LEGACY_REF,scope='One saved Episode, bounded historical controller adaptation, privileged calibration; not full bank certification',status='started')
+    def save(): (out/'report.json').write_text(json.dumps(_json(report),ensure_ascii=False,indent=2))
+    save();env=None;s=None
+    try:
+        env=ReplayEnv(instance,cameras=False);env.bind(episode);obs,info=env.reset();s=Session(env);s.observation=obs;s.info=info
+        before=runtime_identity(env._wrapped,args.task)
+        prefix='tasks.'+args.task+'.operation'
+        importlib.import_module('tasks.'+args.task)
+        pkg=types.ModuleType(prefix);pkg.__path__=[str(legacy/'tasks'/args.task/'operation')];pkg.make_env=lambda **kw:s;sys.modules[prefix]=pkg
+        # Imported code is diagnostic only; construction is replaced by the strict bank environment.
+        def mod(n): return importlib.import_module(prefix+'.'+n)
+        t=args.task;controller=None
+        if args.replay_actions:
+            report['replayed_actions_from']=str(args.replay_actions)
+            for action in json.loads(args.replay_actions.read_text()): s.step(action)
+            raise Finished()
+        if t=='box_insertion':
+            controller=mod('density_controller').DensityAwareBoxInsertionController(robot_id=instance['robot_id'],direct_gripper_contact=True);controller.set_action_dim(env.action_dim)
+        elif t=='button_indicator_matching': controller=mod('demo_runtime').ButtonPressDemo(s,'aloha')
+        elif t=='pan_flip': controller=mod('controller').PanFlipController(s)
+        elif t=='pitch_pot': controller=mod('arm').PickThrowController(s,motion=mod('planning').motion_for_target(s))
+        elif t=='rail_ball_to_cup': controller=mod('arm').PickPlaceController(s)
+        elif t=='conveyor_grasp': controller=mod('solve').ConveyorSortingController(s)
+        elif t=='find_object_in_drawer2': controller=mod('retrieval').RetrievalController(s)
+        elif t=='tilte_maze': controller=mod('solve').JoystickMazeController(s)
+        elif t=='rope_hang': controller=mod('rebalance').RebalanceController(s)
+        elif t=='laptop_into_drawer': controller=mod('controller').PhysicsOraclePolicy()
+        assert before==runtime_identity(env._wrapped,t),'Controller modified model or controller configuration'
+        if controller is not None:
+            for i in range(int(s.horizon)):
+                state=np.r_[s.sim.data.qpos.copy(),s.sim.data.qvel.copy()]
+                if t in ('box_insertion','laptop_into_drawer'):
+                    # Read native observations for privileged physical calibration.
+                    observation=s.replay.env._get_observations(force_update=True)
+                    if hasattr(s.replay.env,'_observation'): observation=s.replay.env._observation()
+                    elif hasattr(s.replay.env,'_obs'): observation=s.replay.env._obs()
+                    a=controller.act(observation,info=s.info)
+                    if t=='laptop_into_drawer':
+                        from react_manip.robots.arm_actions import arm_action
+                        layout=s.robots[0].composite_controller._action_split_indexes
+                        a=arm_action(env.action_dim,layout,'right',a[:6],{'right':a[6],'left':-1.0})
+                else: a=controller.act()
+                np.testing.assert_array_equal(state,np.r_[s.sim.data.qpos,s.sim.data.qvel])
+                s.step(a)
+            report['controller_phase']=str(getattr(controller,'phase','unknown'))
+        elif t in ('leveling_board1','ring_toss1','turntable_gamble1'):
+            mod('solve').run(out=out/'legacy_result',record=False)
+        elif t=='car_drive2':
+            m=load_module('audit_car',legacy/'tasks/car_drive2/demo_aloha.py');m.run(out=out/'legacy_result',record=False)
+        else: raise ValueError('No controller')
+    except Finished: pass
+    except Exception as exc:
+        report['error']=f'{type(exc).__name__}: {exc}';report['traceback']=traceback.format_exc()
+    finally:
+        if s is not None:
+            if 'controller' in locals() and controller is not None:
+                report['controller_phase']=str(getattr(controller,'phase',getattr(controller,'stage','unknown')))
+            report.update(steps=len(s.actions),final_info=_json(s.info),simulation_seconds=float(s.sim.data.time))
+            report['model_controller_unchanged']=before==runtime_identity(env._wrapped,args.task)
+            (out/'actions.json').write_text(json.dumps(s.actions))
+            if not report['model_controller_unchanged']:
+                after=runtime_identity(env._wrapped,args.task)
+                report['runtime_changed_fields']=[k for k in before if before[k]!=after[k]]
+                if args.task in ('button_indicator_matching','conveyor_grasp') and report['runtime_changed_fields']==['model_digest']:
+                    report['model_change_note']='Task-owned dynamic model state: indicator colors/lights or conveyor object activation; source controller has no model writes. Not a static-model certificate.'
+                else: report.setdefault('error','Model/controller changed during calibration')
+        if env is not None: env.close()
+    success=s is not None and bool(s.info.get('terminal_success',False)) and not report.get('error')
+    report['status']='attempt_failed' if not report.get('error') else 'controller_incompatible'
+    if success:
+        fresh=ReplayEnv(instance,cameras=False)
+        try:
+            fresh.bind(episode);fresh.reset();ri={};ended=False
+            for a in s.actions:
+                _,_,te,tr,ri=fresh.step(a)
+                if te or tr: ended=True;break
+            report['independent_replay']={'terminal_success':bool(ri.get('terminal_success')), 'final_info':_json(ri),'ended':ended}
+            score_keys=('total_score','task_score','score')
+            score_equal=all(ri.get(k)==s.info.get(k) for k in score_keys)
+            report['independent_replay']['scores_equal']=score_equal
+            report['status']='success_replayed' if ri.get('terminal_success') and score_equal else 'replay_failed'
+        finally:fresh.close()
+    report['controller_sources_sha256']={str(f.relative_to(legacy)):hashlib.sha256(f.read_bytes()).hexdigest() for f in (legacy/'tasks'/args.task/'operation').glob('*.py')}
+    save();print(args.task,report['status'],report.get('steps'),report.get('error',''),flush=True)
+if __name__=='__main__':main()