feat(tasks): complete native BDDL predicates for LIBERO (In/On/Open/Close/TurnOn/TurnOff)

_native_util.py now covers every predicate that appears in the 130 LIBERO task
goals: In (region world-box), On (body-center on-top OR, when the target is a
region site, LIBERO's SiteObject.under = site-local xy + z-from-surface), Open/
Close (articulated open-range, non-free joints only), TurnOn/TurnOff (FlatStove
turnon range qpos>=0.5). Verified on representative tasks (wine-on-cabinet,
bowl-on-stove, turn-on-stove) against recorded done.

vendor_all_native.py: one pass that remote-reads each task's model_file +
initial/final states from HF, writes a native bundle, and checks native BDDL
success at the demo-final state == recorded done.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: geng-haoran

roboverse_pack/tasks/libero/_native_util.py

@@ -65,19 +65,41 @@ def _in_region(model, data, obj: str, region: str) -> bool:
     return bool(np.all(np.abs(data.xpos[bid] - sp) < half))
 
 
+# turn-on/off ranges (FlatStove etc.): turn_on if qpos >= min(range); off if < max(off)
+_TURNON_RANGES = {"flat_stove": [0.5, 2.1]}
+
+
+def _artic_qpos(model, data, base: str):
+    """qpos values of the object's articulated (non-free, 1-dof) joints."""
+    out = []
+    for j in range(model.njnt):
+        jn = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_JOINT, j) or ""
+        if base in jn and model.jnt_type[j] in (mujoco.mjtJoint.mjJNT_HINGE, mujoco.mjtJoint.mjJNT_SLIDE):
+            out.append(float(data.qpos[model.jnt_qposadr[j]]))
+    return out
+
+
+def _region_base(region: str) -> str:
+    return re.sub(r"_(\w+_)?(region|level)$", "", region)
+
+
 def _is_open(model, data, region: str) -> bool:
-    base = re.sub(r"_(\w+_)?(region|level)$", "", region)
+    base = _region_base(region)
     cls = next((k for k in _OPEN_RANGES if k in base.lower()), None)
     rng, direction = _OPEN_RANGES.get(cls, ([-0.14, -0.14], "lt"))
-    for j in range(model.njnt):
-        jn = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_JOINT, j) or ""
-        if base in jn and any(k in jn for k in ("level", "joint", "cabinet", "door")):
-            q = data.qpos[model.jnt_qposadr[j]]
-            if (q < max(rng)) if direction == "lt" else (q > min(rng)):
-                return True
+    for q in _artic_qpos(model, data, base):
+        if (q < max(rng)) if direction == "lt" else (q > min(rng)):
+            return True
     return False
 
 
+def _turn_on(model, data, region: str) -> bool:
+    base = _region_base(region)
+    cls = next((k for k in _TURNON_RANGES if k in base.lower()), None)
+    rng = _TURNON_RANGES.get(cls, [0.5, 2.1])
+    return any(q >= min(rng) for q in _artic_qpos(model, data, base))
+
+
 def _contact(model, data, body_a: int, body_b: int) -> bool:
     if body_a < 0 or body_b < 0:
         return False
@@ -90,7 +112,26 @@ def _contact(model, data, body_a: int, body_b: int) -> bool:
 
 
 def _on(model, data, a: str, b: str) -> bool:
-    """LIBERO On(a,b): a above b, in contact, xy-aligned (<0.03). (b.check_ontop(a))"""
+    """LIBERO On(a,b) = b.check_ontop(a).
+
+    If ``b`` is a region *site* (e.g. ``cabinet_top_side``) LIBERO uses the
+    site's box containment (``SiteObject.under``; site contact is always True) —
+    same as :func:`_in_region`. If ``b`` is a movable *object* it's the
+    body-center on-top test (above + in contact + xy-aligned <0.03).
+    """
+    sid = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_SITE, b)
+    if sid >= 0:
+        # SiteObject.under: obj within site-local xy half-size, z from surface up to +0.10
+        bid = _bid(model, a) if _bid(model, a) >= 0 else _bid(model, a + "_main")
+        if bid < 0:
+            return False
+        size = model.site_size[sid]
+        delta = data.site_xmat[sid].reshape(3, 3) @ (data.xpos[bid] - data.site_xpos[sid])
+        return bool(
+            size[2] - 0.005 < delta[2] < size[2] + 0.10
+            and abs(delta[0]) < size[0]
+            and abs(delta[1]) < size[1]
+        )
     ba = _bid(model, a) if _bid(model, a) >= 0 else _bid(model, a + "_main")
     bb = _bid(model, b) if _bid(model, b) >= 0 else _bid(model, b + "_main")
     if ba < 0 or bb < 0:
@@ -112,6 +153,10 @@ def check_bddl_success(model, data, goal_terms) -> bool:
             ok = _is_open(model, data, args[0])
         elif p == "close" and len(args) == 1:
             ok = not _is_open(model, data, args[0])
+        elif p == "turnon" and len(args) == 1:
+            ok = _turn_on(model, data, args[0])
+        elif p == "turnoff" and len(args) == 1:
+            ok = not _turn_on(model, data, args[0])
         else:
             return False
         if not ok:

tools/libero_integration/vendor_all_native.py

@@ -0,0 +1,106 @@
+"""Vendor + verify ALL 130 LIBERO tasks as native MetaSim bundles.
+
+For every task: remote-read its model_file + a demo's initial/final states +
+recorded done from HF (range requests, no full download); read the BDDL goal
+locally; write a native bundle (model.xml + goal.json + init.npz); load the model
+and check that the native BDDL success at the demo's final state equals the
+recorded done. One pass vendors all bundles AND validates the native predicates.
+
+    python -m tools.libero_integration.vendor_all_native --out <report>/metasim_1to1/native130.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import time
+from pathlib import Path
+
+os.environ.setdefault("MUJOCO_GL", "egl")
+os.environ.setdefault("HF_HUB_OFFLINE", "0")
+
+import fsspec  # noqa: E402
+import h5py  # noqa: E402
+import mujoco  # noqa: E402
+import numpy as np  # noqa: E402
+
+from roboverse_pack.tasks.libero._native_util import check_bddl_success, parse_goal, remap_libero_model  # noqa: E402
+
+_HF = "https://huggingface.co/datasets/yifengzhu-hf/LIBERO-datasets/resolve/main"
+_BDDL = "/venv/roboverse/lib/python3.11/site-packages/libero/libero/bddl_files"
+_BUNDLES = Path(__file__).resolve().parents[2] / "roboverse_pack/tasks/libero/native_bundles"
+_ASSETS = str(Path(__file__).resolve().parents[2] / "third_party/LIBERO/libero/libero/assets")
+_LOCAL = {
+    ("libero_object", "pick_up_the_butter_and_place_it_in_the_basket"): "datasets/libero/butter_demo.hdf5",
+    ("libero_goal", "open_the_middle_drawer_of_the_cabinet"): "datasets/libero/goal_drawer_demo.hdf5",
+}
+
+
+def _read(suite, stem):
+    local = _LOCAL.get((suite, stem))
+    f = h5py.File(local, "r") if local and os.path.exists(local) else h5py.File(fsspec.open(f"{_HF}/{suite}/{stem}_demo.hdf5", "rb").open(), "r")
+    g = f["data"]["demo_0"]
+    mf = g.attrs["model_file"]
+    s0 = g["states"][0]
+    sN = g["states"][-1]
+    done = int(g["dones"][()][-1]) if "dones" in g else int(g["rewards"][()][-1] >= 1.0)
+    f.close()
+    return mf, s0, sN, done
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--tasks-json", default="datasets/libero/all_tasks.json")
+    args = ap.parse_args()
+    tasks = json.loads(Path(args.tasks_json).read_text())
+
+    results, vendored, matched, errs = [], 0, 0, 0
+    by_suite_match: dict[str, list[bool]] = {}
+    for i, (suite, pf, stem) in enumerate(tasks):
+        name = f"{suite.replace('libero_', '')}__{stem}"[:120]
+        try:
+            mf, s0, sN, done = _read(suite, stem)
+            xml = remap_libero_model(mf, _ASSETS)
+            m = mujoco.MjModel.from_xml_string(xml)
+            d = mujoco.MjData(m)
+            nq, nv = m.nq, m.nv
+            goal = parse_goal(Path(f"{_BDDL}/{pf}/{stem}.bddl").read_text())
+            # write bundle
+            out = _BUNDLES / name
+            out.mkdir(parents=True, exist_ok=True)
+            (out / "model.xml").write_text(mf)
+            (out / "goal.json").write_text(json.dumps(goal))
+            np.savez(out / "init.npz", qpos=s0[1 : 1 + nq], qvel=s0[1 + nq : 1 + nq + nv])
+            vendored += 1
+            # verify native success at demo-final == recorded done
+            d.qpos[:] = sN[1 : 1 + nq]
+            d.qvel[:] = sN[1 + nq : 1 + nq + nv]
+            native = check_bddl_success(m, d, goal)
+            ok = native == bool(done)
+            matched += ok
+            by_suite_match.setdefault(suite, []).append(ok)
+            rec = {"name": name, "suite": suite, "goal": goal, "native_success": native, "recorded_done": done, "match": ok}
+            print(f"  [{i + 1:3d}/130] {name[:60]:60s} goal={[g[0] for g in goal]} native={native} done={done} match={ok}", flush=True)
+        except Exception as e:  # noqa: BLE001
+            errs += 1
+            rec = {"name": name, "suite": suite, "error": str(e)[:140]}
+            print(f"  [{i + 1:3d}/130] {name[:60]:60s} ERROR {str(e)[:60]}", flush=True)
+        results.append(rec)
+        time.sleep(0.25)
+
+    summary = {
+        "n": len(tasks), "vendored": vendored, "success_match": f"{matched}/{len(tasks)}", "errors": errs,
+        "per_suite_match": {s: f"{sum(v)}/{len(v)}" for s, v in by_suite_match.items()},
+        "tasks": results,
+    }
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(json.dumps(summary, indent=2))
+    print(f"\nNATIVE 130: vendored {vendored}/{len(tasks)} | success-match {summary['success_match']} | errors {errs}")
+    print("per-suite match:", summary["per_suite_match"])
+    print(f"wrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()