Add files using upload-large-folder tool

tactile_tasks/collect_data.py

@@ -8,7 +8,7 @@ import os
 import sys
 import argparse
 from datetime import datetime
-
+import math
 import numpy as np
 import h5py
 
@@ -198,7 +198,7 @@ def run_peg_insertion(env, sensor, recorder):
         grasp_steps=30,
         retry_dz=-0.012,
     )
-
+    # grasp_object结束后
     # ── Phase 2: Lift high ──────────────────────────────────────────────────
     lift_pos = get_eef_pos(env).copy(); lift_pos[2] += 0.22
     recorder.run_until(env, sensor, lambda: move_action(env, lift_pos, gain=5.0, gripper=1.0),
@@ -207,29 +207,29 @@ def run_peg_insertion(env, sensor, recorder):
     # ── Phase 3: Move to above hole ────────────────────────────────────────
     hole_pos = env.sim.data.body_xpos[env.hole_body_id].copy()
     hole_xy = hole_pos[:2].copy()
-
+    hole_xy_target = hole_xy.copy()
+    hole_xy_target[1] += eef_to_peg[1]
     above_hole = np.array([hole_xy[0], hole_xy[1], get_eef_pos(env)[2]])
     recorder.run_until(env, sensor,
                        lambda: move_action(env, above_hole, gain=4.0, gripper=1.0),
                        done_fn=lambda: at_target(env, above_hole, 0.01), max_steps=120)
 
     # ── Phase 4: Position align + gradual orientation correction ────────────
-    # First: precise xy alignment (no ori)
     align_object_to_xy(
         env, sensor, recorder,
         get_obj_xy_fn=lambda: env.sim.data.body_xpos[env.peg_body_id][:2].copy(),
-        target_xy=hole_xy,
-        gripper=1.0, xy_tol=0.002, max_steps=80, gain=10.0, ori_gain=0.0,
+        target_xy=hole_xy_target,
+        gripper=1.0, xy_tol=0.001, max_steps=500, gain=15.0, ori_gain=0.0,
     )
 
-    # Gradual ori ramp with continuous position correction
+    # Gradual ori ramp — use hole_xy_target throughout for consistency
     for step in range(200):
         if recorder.done:
             break
         peg_xy = env.sim.data.body_xpos[env.peg_body_id][:2].copy()
         eef = get_eef_pos(env)
         target = eef.copy()
-        target[:2] += (hole_xy - peg_xy) * 3.0
+        target[:2] += (hole_xy_target - peg_xy) * 3.0
         og = min(1.5, step / 150.0 * 1.5)
         action = move_action(env, target, gain=10.0, gripper=1.0, ori_gain=og)
         recorder.step(env, sensor, action)
@@ -238,7 +238,6 @@ def run_peg_insertion(env, sensor, recorder):
     eef_settled = get_eef_pos(env).copy()
     peg_settled = env.sim.data.body_xpos[env.peg_body_id].copy()
     eef_to_peg = eef_settled - peg_settled
-
     # ── Phase 5: Descend to just above hole ─────────────────────────────────
     hole_top_z = hole_pos[2] + env.hole_height * 0.5
     target_eef_z = hole_top_z + 0.005 + eef_to_peg[2] + env.peg_height
@@ -252,28 +251,63 @@ def run_peg_insertion(env, sensor, recorder):
         max_steps=120, ori_gain=0.5,
     )
 
-    # ── Phase 6: Insertion — push down with xy + ori corrections ────────────
-    for _ in range(150):
+    search_radius = 0.002
+    search_angle = 0.0
+    stuck_steps = 0
+
+    for step in range(400):
         if recorder.done:
             break
+
+        mags = sensor.get_force_magnitudes()
+        total_force = mags["left_finger"].mean() + mags["right_finger"].mean()
+
         peg_xy = env.sim.data.body_xpos[env.peg_body_id][:2].copy()
+        peg_z  = env.sim.data.body_xpos[env.peg_body_id][2]
+        hole_z = env.sim.data.body_xpos[env.hole_body_id][2]
         xy_err = hole_xy - peg_xy
         ori = get_ori_correction(env, ori_gain=0.5)
+
         action = np.zeros(7)
-        action[:2] = np.clip(xy_err * 15.0, -1, 1)
-        action[2] = -0.15
         action[3:6] = ori
-        action[6] = 1.0
+        action[6] = 1.0  # 保持抓住
+
+        if total_force > 0.8:
+            stuck_steps += 1
+            search_angle += 0.4
+            sx = search_radius * math.cos(search_angle)
+            sy = search_radius * math.sin(search_angle)
+            action[0] = np.clip(xy_err[0] * 15.0 + sx * 20.0, -1, 1)
+            action[1] = np.clip(xy_err[1] * 15.0 + sy * 20.0, -1, 1)
+            action[2] = +0.05
+            if stuck_steps > 20:
+                search_radius = min(0.003, search_radius + 0.0002)
+        else:
+            stuck_steps = 0
+            action[0] = np.clip(xy_err[0] * 15.0, -1, 1)
+            action[1] = np.clip(xy_err[1] * 15.0, -1, 1)
+            action[2] = -0.08
+
         recorder.step(env, sensor, action)
-        if env._check_success():
+
+        # peg插入足够深再停，不依赖_check_success
+        if peg_z < hole_z - env.peg_height * 0.3:
             break
 
-    # ── Phase 7: Release and retreat ─────────────────────────────────────────
-    recorder.run_for(env, sensor, lambda: grip_action(env, -1.0), steps=12)
-    retreat = get_eef_pos(env).copy(); retreat[2] += 0.10
-    recorder.run_until(env, sensor, lambda: move_action(env, retreat, gain=4.0, gripper=-1),
-                       done_fn=lambda: at_target(env, retreat, 0.01), max_steps=50)
+    # ── Phase 7: 松手，等peg稳定，再退出 ────────────────────────────────────
+    recorder.run_for(env, sensor, lambda: grip_action(env, -1.0), steps=20)
 
+    # 等peg自然稳定
+    eef_hold = get_eef_pos(env).copy()
+    recorder.run_for(env, sensor,
+                    lambda: move_action(env, eef_hold, gain=5.0, gripper=-1),
+                    steps=30)
+
+    retreat = get_eef_pos(env).copy(); retreat[2] += 0.10
+    recorder.run_until(env, sensor,
+                    lambda: move_action(env, retreat, gain=4.0, gripper=-1),
+                    done_fn=lambda: at_target(env, retreat, 0.01),
+                    max_steps=50)
 
 def run_gentle_stack(env, sensor, recorder):
     # ── Phase 1: Grasp box, measure real EEF→box offset ──────────────────────
@@ -343,7 +377,13 @@ def run_gentle_stack(env, sensor, recorder):
         z_gain=3.0,
         max_steps=120,
     )
+    # Re-measure offset with final orientation
+    eef_settled = get_eef_pos(env).copy()
+    peg_settled = env.sim.data.body_xpos[env.peg_body_id].copy()
+    eef_to_peg = eef_settled - peg_settled
 
+    # 加这行
+    print(f"对齐后误差: {hole_xy - env.sim.data.body_xpos[env.peg_body_id][:2]}")
     # ── Phase 5: Gentle final push until contact ──────────────────────────────
     for _ in range(80):
         if recorder.done:
@@ -474,33 +514,57 @@ TASK_CONFIGS = {
     "precision_grasp": {
         "env_class": "PrecisionGrasp",
         "run_fn": run_precision_grasp,
-        "horizon": 300,
+        "horizon": 3000,
         "controller": "OSC_POSE",
     },
     "peg_insertion": {
         "env_class": "PegInsertion",
         "run_fn": run_peg_insertion,
-        "horizon": 600,
+        "horizon": 5000,
         "controller": "OSC_POSE",
     },
     "gentle_stack": {
         "env_class": "GentleStack",
         "run_fn": run_gentle_stack,
-        "horizon": 400,
+        "horizon": 5000,
+        "controller": "OSC_POSE",
+    },
+    "fragile_transport": {
+        "env_class": "FragileTransport",
+        "run_fn": None,  # keyboard-only collection
+        "horizon": 5000,
+        "controller": "OSC_POSE",
+    },
+    "cup_retrieval": {
+        "env_class": "CupRetrieval",
+        "run_fn": None,
+        "horizon": 5000,
+        "controller": "OSC_POSE",
+    },
+    "pen_insertion": {
+        "env_class": "PenInsertion",
+        "run_fn": None,
+        "horizon": 5000,
         "controller": "OSC_POSE",
     },
 }
 
 
-def create_env(task_name, has_renderer=False, camera_names=None):
+def create_env(task_name, has_renderer=False, camera_names=None, render_camera="agentview"):
     from tactile_tasks.envs.precision_grasp import PrecisionGrasp
     from tactile_tasks.envs.peg_insertion import PegInsertion
     from tactile_tasks.envs.gentle_stack import GentleStack
+    from tactile_tasks.envs.fragile_transport import FragileTransport
+    from tactile_tasks.envs.cup_retrieval import CupRetrieval
+    from tactile_tasks.envs.pen_insertion import PenInsertion
 
     env_classes = {
         "PrecisionGrasp": PrecisionGrasp,
         "PegInsertion": PegInsertion,
         "GentleStack": GentleStack,
+        "FragileTransport": FragileTransport,
+        "CupRetrieval": CupRetrieval,
+        "PenInsertion": PenInsertion,
     }
 
     config = TASK_CONFIGS[task_name]
@@ -540,6 +604,7 @@ def create_env(task_name, has_renderer=False, camera_names=None):
         controller_configs=controller_configs,
         has_renderer=has_renderer,
         has_offscreen_renderer=True,
+        render_camera=render_camera,
         use_camera_obs=True,
         use_object_obs=True,
         control_freq=20,

tactile_tasks/collect_keyboard.py

@@ -0,0 +1,478 @@
+#!/usr/bin/env python3
+"""
+Keyboard teleoperation with smooth target-tracking control.
+
+Instead of raw delta commands (jerky, hard to control), this maintains a
+"target EEF position" that the robot smoothly tracks via proportional control.
+Keyboard inputs move the target, not the robot directly.
+
+Controls:
+  Arrow keys       : move target in x-y plane (3mm per tap)
+  . / ;            : move target down / up
+  o / p            : rotate yaw
+  y / h            : rotate pitch
+  e / r            : rotate roll
+  Space            : toggle gripper open/close
+  1                : snap target to object (nearest graspable body)
+  2                : lift target +10cm
+  3                : descend target 3cm
+  Enter            : finish episode (save)
+  Ctrl+q / Esc     : discard episode and reset
+  +/-              : increase/decrease step size
+
+Usage:
+  python tactile_tasks/collect_keyboard.py --task fragile_transport --num_episodes 1 --save_all
+"""
+
+import os
+import sys
+import argparse
+import time
+import threading
+
+import numpy as np
+import cv2
+import mujoco
+from pynput.keyboard import Key, Listener
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from tactile_tasks.collect_data import (
+    create_env, TASK_CONFIGS, EpisodeRecorder, save_episode_hdf5,
+)
+from tactile_tasks.uskin_sensor import USkinSensor
+
+
+class SmoothKeyboardController:
+    """
+    Target-tracking keyboard controller.
+
+    Maintains a target EEF pose. Keyboard inputs move the target;
+    a proportional controller generates smooth OSC_POSE actions.
+    """
+
+    def __init__(self, env, pos_step=0.015, rot_step=0.08, pos_gain=15.0, ori_gain=3.0):
+        self.env = env
+        self.pos_step = pos_step      # meters per keypress
+        self.rot_step = rot_step      # radians per keypress
+        self.pos_gain = pos_gain
+        self.ori_gain = ori_gain
+
+        # State
+        self.target_pos = self._get_eef_pos()
+        self.gripper_action = -1.0  # -1=open, 1=closed
+        self.ori_delta = np.zeros(3)  # accumulated orientation delta
+        self._reset_flag = False
+        self._save_flag = False
+        self._quit_flag = False
+        self._started = False  # first movement detected
+
+        # Key state tracking for held keys
+        self._held_keys = set()
+        self._lock = threading.Lock()
+
+        # Start listener
+        self.listener = Listener(on_press=self._on_press, on_release=self._on_release)
+        self.listener.start()
+
+    def _get_eef_pos(self):
+        return self.env.sim.data.site_xpos[
+            self.env.robots[0].eef_site_id["right"]
+        ].copy()
+
+    def _get_eef_mat(self):
+        return self.env.sim.data.site_xmat[
+            self.env.robots[0].eef_site_id["right"]
+        ].reshape(3, 3).copy()
+
+    def _get_ori_correction(self):
+        """Compute orientation delta to maintain vertical (z down)."""
+        z_axis = self._get_eef_mat()[:, 2]
+        target_z = np.array([0.0, 0.0, -1.0])
+        cross = np.cross(z_axis, target_z)
+        sin_a = np.linalg.norm(cross)
+        if sin_a < 1e-6:
+            return np.zeros(3)
+        axis = cross / sin_a
+        cos_a = np.dot(z_axis, target_z)
+        angle = np.arctan2(sin_a, cos_a)
+        return axis * angle
+
+    def _find_nearest_object(self):
+        """Find nearest object body position for snap-to functionality."""
+        eef = self._get_eef_pos()
+        best_pos = None
+        best_dist = float('inf')
+
+        # Look for known object body IDs on the env
+        for attr in dir(self.env):
+            if attr.endswith('_body_id') and attr not in ('_body_id',):
+                try:
+                    bid = getattr(self.env, attr)
+                    if isinstance(bid, (int, np.integer)):
+                        pos = self.env.sim.data.body_xpos[bid].copy()
+                        d = np.linalg.norm(pos - eef)
+                        if d < best_dist:
+                            best_dist = d
+                            best_pos = pos
+                except:
+                    pass
+
+        return best_pos
+
+    def _on_press(self, key):
+        with self._lock:
+            try:
+                if key == Key.up:
+                    self._held_keys.add('up')
+                elif key == Key.down:
+                    self._held_keys.add('down')
+                elif key == Key.left:
+                    self._held_keys.add('left')
+                elif key == Key.right:
+                    self._held_keys.add('right')
+                elif hasattr(key, 'char'):
+                    if key.char == '.':
+                        self._held_keys.add('z_down')
+                    elif key.char == ';':
+                        self._held_keys.add('z_up')
+                    elif key.char == 'o':
+                        self._held_keys.add('yaw_left')
+                    elif key.char == 'p':
+                        self._held_keys.add('yaw_right')
+                    elif key.char == 'y':
+                        self._held_keys.add('pitch_up')
+                    elif key.char == 'h':
+                        self._held_keys.add('pitch_down')
+                    elif key.char == 'e':
+                        self._held_keys.add('roll_left')
+                    elif key.char == 'r':
+                        self._held_keys.add('roll_right')
+            except:
+                pass
+
+    def _on_release(self, key):
+        with self._lock:
+            try:
+                if key == Key.up:
+                    self._held_keys.discard('up')
+                elif key == Key.down:
+                    self._held_keys.discard('down')
+                elif key == Key.left:
+                    self._held_keys.discard('left')
+                elif key == Key.right:
+                    self._held_keys.discard('right')
+                elif key == Key.space:
+                    self.gripper_action *= -1.0  # toggle
+                    self._started = True
+                elif key == Key.enter:
+                    self._save_flag = True
+                elif key == Key.esc:
+                    self._quit_flag = True
+                elif hasattr(key, 'char'):
+                    if key.char == '.':
+                        self._held_keys.discard('z_down')
+                    elif key.char == ';':
+                        self._held_keys.discard('z_up')
+                    elif key.char == 'o':
+                        self._held_keys.discard('yaw_left')
+                    elif key.char == 'p':
+                        self._held_keys.discard('yaw_right')
+                    elif key.char == 'y':
+                        self._held_keys.discard('pitch_up')
+                    elif key.char == 'h':
+                        self._held_keys.discard('pitch_down')
+                    elif key.char == 'e':
+                        self._held_keys.discard('roll_left')
+                    elif key.char == 'r':
+                        self._held_keys.discard('roll_right')
+                    elif key.char == 'q':
+                        self._reset_flag = True
+                    elif key.char == '1':
+                        # Snap to nearest object
+                        obj_pos = self._find_nearest_object()
+                        if obj_pos is not None:
+                            above = obj_pos.copy()
+                            above[2] += 0.06  # 6cm above object
+                            self.target_pos = above
+                            self._started = True
+                            print(f"    -> Snap to object at {obj_pos[:2].round(3)}")
+                    elif key.char == '2':
+                        # Lift
+                        self.target_pos[2] += 0.10
+                        self._started = True
+                        print("    -> Lift +10cm")
+                    elif key.char == '3':
+                        # Descend
+                        self.target_pos[2] -= 0.03
+                        self._started = True
+                        print("    -> Descend -3cm")
+                    elif key.char == '+' or key.char == '=':
+                        self.pos_step = min(0.01, self.pos_step * 1.5)
+                        print(f"    -> Step size: {self.pos_step*1000:.1f}mm")
+                    elif key.char == '-':
+                        self.pos_step = max(0.001, self.pos_step / 1.5)
+                        print(f"    -> Step size: {self.pos_step*1000:.1f}mm")
+            except:
+                pass
+
+    def process_held_keys(self):
+        """Process continuously held keys - called each control step."""
+        with self._lock:
+            moved = False
+            for k in self._held_keys:
+                if k == 'up':
+                    self.target_pos[0] -= self.pos_step
+                    moved = True
+                elif k == 'down':
+                    self.target_pos[0] += self.pos_step
+                    moved = True
+                elif k == 'left':
+                    self.target_pos[1] -= self.pos_step
+                    moved = True
+                elif k == 'right':
+                    self.target_pos[1] += self.pos_step
+                    moved = True
+                elif k == 'z_down':
+                    self.target_pos[2] -= self.pos_step
+                    moved = True
+                elif k == 'z_up':
+                    self.target_pos[2] += self.pos_step
+                    moved = True
+                elif k == 'yaw_left':
+                    self.ori_delta[2] -= self.rot_step
+                    moved = True
+                elif k == 'yaw_right':
+                    self.ori_delta[2] += self.rot_step
+                    moved = True
+                elif k == 'pitch_up':
+                    self.ori_delta[0] += self.rot_step
+                    moved = True
+                elif k == 'pitch_down':
+                    self.ori_delta[0] -= self.rot_step
+                    moved = True
+                elif k == 'roll_left':
+                    self.ori_delta[1] -= self.rot_step
+                    moved = True
+                elif k == 'roll_right':
+                    self.ori_delta[1] += self.rot_step
+                    moved = True
+
+            if moved and not self._started:
+                self._started = True
+
+    def get_action(self):
+        """Generate smooth OSC_POSE action tracking target pose."""
+        self.process_held_keys()
+
+        eef_pos = self._get_eef_pos()
+        pos_error = self.target_pos - eef_pos
+
+        # Proportional control with capping to avoid overshoot
+        pos_action = pos_error * self.pos_gain
+        output_max = 0.15
+        error_norm = np.linalg.norm(pos_error)
+        if error_norm > 0.001:
+            max_mag = 0.7 * error_norm / output_max
+            mag = np.linalg.norm(pos_action)
+            if mag > max_mag:
+                pos_action = pos_action * (max_mag / mag)
+        pos_action = np.clip(pos_action, -1.0, 1.0)
+
+        # Orientation: maintain vertical + apply user's rotation delta
+        ori_action = self._get_ori_correction() * self.ori_gain
+        ori_action += self.ori_delta
+        self.ori_delta *= 0.85  # decay rotation commands
+        ori_action = np.clip(ori_action, -1.0, 1.0)
+
+        return np.concatenate([pos_action, ori_action, [self.gripper_action]])
+
+    def reset_target(self):
+        """Reset target to current EEF position."""
+        self.target_pos = self._get_eef_pos()
+        self.ori_delta = np.zeros(3)
+        self._reset_flag = False
+        self._save_flag = False
+        self._started = False
+
+    def stop(self):
+        self.listener.stop()
+
+
+def render_multi_view(env, cam_size=256):
+    """Render multiple camera views tiled in one OpenCV window."""
+    cameras = ["agentview", "sideview", "robot0_eye_in_hand"]
+    imgs = []
+    for cam in cameras:
+        try:
+            img = env.sim.render(
+                camera_name=cam, height=cam_size, width=cam_size,
+            )[::-1]  # flip vertically (MuJoCo convention)
+            img = np.ascontiguousarray(img[..., ::-1])  # RGB -> BGR for OpenCV
+        except Exception:
+            img = np.zeros((cam_size, cam_size, 3), dtype=np.uint8)
+        # Add camera label
+        cv2.putText(img, cam, (5, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+        imgs.append(img)
+
+    # Tile horizontally
+    tiled = np.concatenate(imgs, axis=1)
+    cv2.imshow("Multi-View", tiled)
+    cv2.waitKey(1)
+
+
+def collect_episode(env, controller, sensor, max_steps, max_fr=20):
+    """Collect one episode with smooth keyboard control."""
+    env.reset()
+    env.render()
+
+    # Let objects settle
+    for _ in range(50):
+        env.step(np.zeros(env.action_dim))
+
+    controller.reset_target()
+    recorder = EpisodeRecorder(env, sensor)
+
+    print(f"\n  Controls: arrows=xy  ;/.=z  space=gripper  1=snap-to-obj  2=lift  3=descend")
+    print(f"  Enter=save  Ctrl+q=discard  +/-=step size ({controller.pos_step*1000:.0f}mm)")
+    print(f"  Waiting for first input... (max {max_steps} steps after start)")
+
+    status = "discard"
+    active_steps = 0
+    view_counter = 0
+
+    while True:
+        start = time.time()
+
+        if controller._reset_flag:
+            status = "discard"
+            break
+
+        if controller._quit_flag:
+            status = "quit"
+            break
+
+        if controller._save_flag:
+            status = "done"
+            break
+
+        action = controller.get_action()
+        recorder.step(env, sensor, action)
+        env.render()
+
+        # Multi-view every 3 frames (save GPU)
+        view_counter += 1
+        if view_counter % 3 == 0:
+            render_multi_view(env)
+
+        if controller._started:
+            active_steps += 1
+
+        if env._check_success():
+            if active_steps % 50 == 1:
+                print(f"  Task success detected at step {active_steps}!")
+
+        if recorder.done:
+            status = "done"
+            break
+
+        if controller._started and active_steps >= max_steps:
+            print(f"  Max steps ({max_steps}) reached.")
+            status = "done"
+            break
+
+        if controller._started and active_steps % 100 == 0:
+            eef = controller._get_eef_pos()
+            tgt = controller.target_pos
+            dist = np.linalg.norm(eef - tgt)
+            grip = "CLOSED" if controller.gripper_action > 0 else "open"
+            print(f"    step {active_steps}/{max_steps}  "
+                  f"eef=[{eef[0]:.3f},{eef[1]:.3f},{eef[2]:.3f}]  "
+                  f"err={dist:.3f}m  grip={grip}")
+
+        if max_fr is not None:
+            elapsed = time.time() - start
+            diff = 1.0 / max_fr - elapsed
+            if diff > 0:
+                time.sleep(diff)
+
+    cv2.destroyAllWindows()
+    recorder.finalize()
+    return recorder, status
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Smooth keyboard teleoperation")
+    parser.add_argument("--task", type=str, required=True,
+                        choices=list(TASK_CONFIGS.keys()))
+    parser.add_argument("--num_episodes", type=int, default=10)
+    parser.add_argument("--save_dir", type=str, default=None)
+    parser.add_argument("--save_all", action="store_true",
+                        help="save all episodes, not just successful ones")
+    parser.add_argument("--max_fr", type=int, default=20, help="max frame rate")
+    parser.add_argument("--max_steps", type=int, default=None,
+                        help="override max steps (default: from task config)")
+    parser.add_argument("--step_size", type=float, default=10.0,
+                        help="movement step size in mm (default: 10)")
+    parser.add_argument("--render_camera", type=str, default="agentview",
+                        help="initial camera view (agentview/sideview/frontview)")
+    args = parser.parse_args()
+
+    task = args.task
+    save_dir = args.save_dir or os.path.join("tactile_data", f"{task}_keyboard")
+    os.makedirs(save_dir, exist_ok=True)
+
+    existing = len([f for f in os.listdir(save_dir) if f.endswith(".hdf5")])
+    print(f"Saving to: {save_dir} (existing: {existing} episodes)")
+
+    env = create_env(task, has_renderer=True, render_camera=args.render_camera)
+    env.reset()
+    sensor = USkinSensor(env.sim)
+    controller = SmoothKeyboardController(
+        env, pos_step=args.step_size / 1000.0,
+    )
+
+    max_steps = args.max_steps or TASK_CONFIGS[task]["horizon"]
+    saved = 0
+    attempted = 0
+
+    try:
+        while saved < args.num_episodes:
+            attempted += 1
+            print(f"\n{'='*50}")
+            print(f"  Episode {attempted} (saved: {saved}/{args.num_episodes})")
+            print(f"{'='*50}")
+
+            recorder, status = collect_episode(
+                env, controller, sensor, max_steps, args.max_fr,
+            )
+
+            if status == "quit":
+                print("  Quit.")
+                break
+
+            if status == "discard":
+                print("  Discarded.")
+                continue
+
+            success = recorder.data.get("task_success", False)
+
+            if not success and not args.save_all:
+                print(f"  Task failed. Discarding (use --save_all to keep).")
+                continue
+
+            ep_idx = existing + saved
+            filepath = os.path.join(save_dir, f"episode_{ep_idx:02d}.hdf5")
+            save_episode_hdf5(filepath, recorder.data, task)
+            saved += 1
+            tag = "SUCCESS" if success else "saved"
+            print(f"  {tag} -> {filepath} ({recorder.step_count} steps)")
+
+    finally:
+        controller.stop()
+        print(f"\nDone! Saved {saved} episodes to {save_dir}")
+        env.close()
+
+
+if __name__ == "__main__":
+    main()

tactile_tasks/envs/cup_retrieval.py

@@ -0,0 +1,277 @@
+"""
+Task: Cup Retrieval (Upright)
+
+Contact-rich task: Grasp an upside-down cup and flip it right-side up.
+Requires careful reorientation while maintaining grip — tactile feedback prevents slip.
+
+Objects: Cup (021_cup) — placed upside-down on its rim
+Success: Cup standing upright on table, gripper released, cup stable
+Tactile role: Detect slip during rotation, adjust grip force for reorientation
+"""
+
+from collections import OrderedDict
+
+import numpy as np
+import mujoco
+
+from robosuite.environments.manipulation.manipulation_env import ManipulationEnv
+from robosuite.models.arenas import TableArena
+from robosuite.models.objects.objects import MujocoXMLObject
+from robosuite.models.tasks import ManipulationTask
+from robosuite.utils.observables import Observable, sensor
+from robosuite.utils.mjcf_utils import xml_path_completion
+from robosuite.utils.placement_samplers import UniformRandomSampler
+from robosuite.utils.transform_utils import convert_quat
+
+
+class CupRetrieval(ManipulationEnv):
+    """
+    Cup retrieval task: grasp an upside-down cup and flip it right-side up.
+
+    The cup starts upside-down on its rim. The robot must grasp it,
+    flip it 180°, and place it standing upright on the table.
+    This is contact-rich because:
+    - Grasping an inverted cup requires careful approach angle
+    - 180° flip requires maintaining grip while rotating
+    - Placement requires detecting table contact via tactile
+    """
+
+    def __init__(
+        self,
+        robots,
+        env_configuration="default",
+        controller_configs=None,
+        gripper_types="Robotiq85Gripper",
+        base_types="default",
+        initialization_noise="default",
+        table_full_size=(0.8, 0.8, 0.05),
+        table_friction=(1.0, 5e-3, 1e-4),
+        use_camera_obs=True,
+        use_object_obs=True,
+        reward_scale=1.0,
+        reward_shaping=True,
+        placement_initializer=None,
+        has_renderer=False,
+        has_offscreen_renderer=True,
+        render_camera="frontview",
+        render_collision_mesh=False,
+        render_visual_mesh=True,
+        render_gpu_device_id=-1,
+        control_freq=20,
+        lite_physics=True,
+        horizon=600,
+        ignore_done=False,
+        hard_reset=True,
+        camera_names="agentview",
+        camera_heights=256,
+        camera_widths=256,
+        camera_depths=False,
+        camera_segmentations=None,
+        renderer="mjviewer",
+        renderer_config=None,
+        seed=None,
+    ):
+        self.table_full_size = table_full_size
+        self.table_friction = table_friction
+        self.table_offset = np.array((0, 0, 0.8))
+        self.reward_scale = reward_scale
+        self.reward_shaping = reward_shaping
+        self.use_object_obs = use_object_obs
+        self.placement_initializer = placement_initializer
+
+        super().__init__(
+            robots=robots,
+            env_configuration=env_configuration,
+            controller_configs=controller_configs,
+            base_types=base_types,
+            gripper_types=gripper_types,
+            initialization_noise=initialization_noise,
+            use_camera_obs=use_camera_obs,
+            has_renderer=has_renderer,
+            has_offscreen_renderer=has_offscreen_renderer,
+            render_camera=render_camera,
+            render_collision_mesh=render_collision_mesh,
+            render_visual_mesh=render_visual_mesh,
+            render_gpu_device_id=render_gpu_device_id,
+            control_freq=control_freq,
+            lite_physics=lite_physics,
+            horizon=horizon,
+            ignore_done=ignore_done,
+            hard_reset=hard_reset,
+            camera_names=camera_names,
+            camera_heights=camera_heights,
+            camera_widths=camera_widths,
+            camera_depths=camera_depths,
+            camera_segmentations=camera_segmentations,
+            renderer=renderer,
+            renderer_config=renderer_config,
+            seed=seed,
+        )
+
+    def reward(self, action=None):
+        reward = 0.0
+        if self._check_success():
+            reward = 3.0
+        elif self.reward_shaping:
+            # Reaching
+            dist = self._gripper_to_target(
+                gripper=self.robots[0].gripper,
+                target=self.cup.root_body,
+                target_type="body",
+                return_distance=True,
+            )
+            reward += 0.5 * (1 - np.tanh(10.0 * dist))
+
+            # Grasping
+            grasped = self._check_grasp(gripper=self.robots[0].gripper, object_geoms=self.cup)
+            if grasped:
+                reward += 0.5
+
+                # Uprightness reward
+                uprightness = self._get_cup_uprightness()
+                reward += 1.0 * uprightness
+
+                # Lifting reward
+                cup_pos = self.sim.data.body_xpos[self.cup_body_id]
+                lift = max(0, cup_pos[2] - self.table_offset[2] - 0.02)
+                reward += min(0.5, lift * 5)
+
+        if self.reward_scale is not None:
+            reward *= self.reward_scale / 3.0
+        return reward
+
+    def _get_cup_uprightness(self):
+        """Return how upright the cup is (0 = sideways, 1 = perfectly upright)."""
+        quat = self.sim.data.body_xquat[self.cup_body_id]
+        mat = np.zeros(9)
+        mujoco.mju_quat2Mat(mat, quat)
+        z_axis = mat.reshape(3, 3)[:, 2]
+        # Cup's z-axis should point up (z_axis[2] close to 1)
+        return max(0, z_axis[2])
+
+    def _load_model(self):
+        super()._load_model()
+
+        xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
+        self.robots[0].robot_model.set_base_xpos(xpos)
+
+        mujoco_arena = TableArena(
+            table_full_size=self.table_full_size,
+            table_friction=self.table_friction,
+            table_offset=self.table_offset,
+        )
+        mujoco_arena.set_origin([0, 0, 0])
+
+        self.cup = MujocoXMLObject(
+            fname=xml_path_completion("objects/custom/021_cup/021_cup.xml"),
+            name="cup",
+            joints=[dict(type="free", damping="0.0005")],
+            obj_type="all",
+            duplicate_collision_geoms=False,
+        )
+
+        # Placement — cup will be tipped over in _reset_internal
+        self.placement_initializer = UniformRandomSampler(
+            name="CupSampler",
+            mujoco_objects=self.cup,
+            x_range=[-0.03, 0.03],
+            y_range=[-0.03, 0.03],
+            rotation=None,
+            ensure_object_boundary_in_range=False,
+            ensure_valid_placement=True,
+            reference_pos=self.table_offset,
+            z_offset=0.05,
+            rng=self.rng,
+        )
+
+        self.model = ManipulationTask(
+            mujoco_arena=mujoco_arena,
+            mujoco_robots=[robot.robot_model for robot in self.robots],
+            mujoco_objects=self.cup,
+        )
+
+    def _setup_references(self):
+        super()._setup_references()
+        self.cup_body_id = self.sim.model.body_name2id(self.cup.root_body)
+
+    def _setup_observables(self):
+        observables = super()._setup_observables()
+
+        if self.use_object_obs:
+            modality = "object"
+
+            @sensor(modality=modality)
+            def cup_pos(obs_cache):
+                return np.array(self.sim.data.body_xpos[self.cup_body_id])
+
+            @sensor(modality=modality)
+            def cup_quat(obs_cache):
+                return convert_quat(np.array(self.sim.data.body_xquat[self.cup_body_id]), to="xyzw")
+
+            sensors = [cup_pos, cup_quat]
+            arm_prefixes = self._get_arm_prefixes(self.robots[0], include_robot_name=False)
+            full_prefixes = self._get_arm_prefixes(self.robots[0])
+
+            sensors += [
+                self._get_obj_eef_sensor(full_pf, "cup_pos", f"{arm_pf}gripper_to_cup_pos", modality)
+                for arm_pf, full_pf in zip(arm_prefixes, full_prefixes)
+            ]
+            names = [s.__name__ for s in sensors]
+
+            for name, s in zip(names, sensors):
+                observables[name] = Observable(
+                    name=name, sensor=s, sampling_rate=self.control_freq,
+                )
+
+        return observables
+
+    def _reset_internal(self):
+        super()._reset_internal()
+        if not self.deterministic_reset:
+            # Place cup upside-down (180° rotation around x-axis)
+            # This is a stable configuration — cup rests on its rim
+            # Task: robot must flip it right-side up
+            obj_x = self.table_offset[0] + self.rng.uniform(-0.03, 0.03)
+            obj_y = self.table_offset[1] + self.rng.uniform(-0.03, 0.03)
+            # 180° around x: quat = [cos(90°), sin(90°), 0, 0] = [0, 1, 0, 0]
+            # Add slight random tilt for variety
+            angle = np.pi + self.rng.uniform(-0.15, 0.15)
+            quat = np.array([np.cos(angle/2), np.sin(angle/2), 0, 0])
+
+            obj_z = self.table_offset[2] + 0.06  # slightly above to settle
+            if self.cup.joints:
+                self.sim.data.set_joint_qpos(
+                    self.cup.joints[0],
+                    np.concatenate([[obj_x, obj_y, obj_z], quat]),
+                )
+
+    def _check_success(self):
+        cup_pos = self.sim.data.body_xpos[self.cup_body_id]
+
+        # Cup must be upright
+        uprightness = self._get_cup_uprightness()
+        is_upright = uprightness > 0.9
+
+        # Cup must be on table
+        on_table = cup_pos[2] < self.table_offset[2] + 0.12
+
+        # Gripper released
+        not_grasped = not self._check_grasp(
+            gripper=self.robots[0].gripper, object_geoms=self.cup
+        )
+
+        # Cup stable
+        if self.cup.joints:
+            jid = self.sim.model.joint_name2id(self.cup.joints[0])
+            qvel_addr = self.sim.model.jnt_dofadr[jid]
+            vel = np.linalg.norm(self.sim.data.qvel[qvel_addr:qvel_addr + 3])
+        else:
+            vel = 0.0
+        stable = vel < 0.1
+
+        return is_upright and on_table and not_grasped and stable
+
+    def visualize(self, vis_settings):
+        super().visualize(vis_settings=vis_settings)
+        if vis_settings["grippers"]:
+            self._visualize_gripper_to_target(gripper=self.robots[0].gripper, target=self.cup)

tactile_tasks/envs/fragile_transport.py

@@ -0,0 +1,285 @@
+"""
+Task: Fragile Transport
+
+Contact-rich task: Grasp a fragile object (apple/egg-sized) and transport it to a
+marked target zone on the table without dropping or crushing it.
+
+Objects: Apple (035_apple) or Rubik's cube (073_rubikscube) — randomly selected
+Success: Object placed in target zone (within tolerance), gripper released, object stable
+Tactile role: Monitor grip force during transport — too little = drop, too much = crush
+"""
+
+from collections import OrderedDict
+
+import numpy as np
+
+from robosuite.environments.manipulation.manipulation_env import ManipulationEnv
+from robosuite.models.arenas import TableArena
+from robosuite.models.objects import BoxObject
+from robosuite.models.objects.objects import MujocoXMLObject
+from robosuite.models.tasks import ManipulationTask
+from robosuite.utils.observables import Observable, sensor
+from robosuite.utils.placement_samplers import UniformRandomSampler
+from robosuite.utils.transform_utils import convert_quat
+
+from robosuite.utils.mjcf_utils import xml_path_completion
+
+
+class FragileTransport(ManipulationEnv):
+    """
+    Transport a fragile object from one side of the table to a target zone.
+
+    The target zone is visualized as a flat marker on the table.
+    The robot must pick up the object, carry it across the table, and
+    gently place it in the target zone.
+    """
+
+    def __init__(
+        self,
+        robots,
+        env_configuration="default",
+        controller_configs=None,
+        gripper_types="Robotiq85Gripper",
+        base_types="default",
+        initialization_noise="default",
+        table_full_size=(0.8, 0.8, 0.05),
+        table_friction=(1.0, 5e-3, 1e-4),
+        use_camera_obs=True,
+        use_object_obs=True,
+        reward_scale=1.0,
+        reward_shaping=True,
+        placement_initializer=None,
+        has_renderer=False,
+        has_offscreen_renderer=True,
+        render_camera="frontview",
+        render_collision_mesh=False,
+        render_visual_mesh=True,
+        render_gpu_device_id=-1,
+        control_freq=20,
+        lite_physics=True,
+        horizon=600,
+        ignore_done=False,
+        hard_reset=True,
+        camera_names="agentview",
+        camera_heights=256,
+        camera_widths=256,
+        camera_depths=False,
+        camera_segmentations=None,
+        renderer="mjviewer",
+        renderer_config=None,
+        seed=None,
+    ):
+        self.table_full_size = table_full_size
+        self.table_friction = table_friction
+        self.table_offset = np.array((0, 0, 0.8))
+        self.reward_scale = reward_scale
+        self.reward_shaping = reward_shaping
+        self.use_object_obs = use_object_obs
+        self.placement_initializer = placement_initializer
+
+        # Target zone position (set in _reset_internal)
+        self.target_pos = None
+
+        super().__init__(
+            robots=robots,
+            env_configuration=env_configuration,
+            controller_configs=controller_configs,
+            base_types=base_types,
+            gripper_types=gripper_types,
+            initialization_noise=initialization_noise,
+            use_camera_obs=use_camera_obs,
+            has_renderer=has_renderer,
+            has_offscreen_renderer=has_offscreen_renderer,
+            render_camera=render_camera,
+            render_collision_mesh=render_collision_mesh,
+            render_visual_mesh=render_visual_mesh,
+            render_gpu_device_id=render_gpu_device_id,
+            control_freq=control_freq,
+            lite_physics=lite_physics,
+            horizon=horizon,
+            ignore_done=ignore_done,
+            hard_reset=hard_reset,
+            camera_names=camera_names,
+            camera_heights=camera_heights,
+            camera_widths=camera_widths,
+            camera_depths=camera_depths,
+            camera_segmentations=camera_segmentations,
+            renderer=renderer,
+            renderer_config=renderer_config,
+            seed=seed,
+        )
+
+    def reward(self, action=None):
+        reward = 0.0
+        if self._check_success():
+            reward = 3.0
+        elif self.reward_shaping:
+            obj_pos = self.sim.data.body_xpos[self.obj_body_id]
+            # Reaching
+            dist = self._gripper_to_target(
+                gripper=self.robots[0].gripper,
+                target=self.obj.root_body,
+                target_type="body",
+                return_distance=True,
+            )
+            reward += 0.5 * (1 - np.tanh(10.0 * dist))
+
+            # Grasping
+            if self._check_grasp(gripper=self.robots[0].gripper, object_geoms=self.obj):
+                reward += 0.5
+                # Transport progress: distance from obj to target
+                transport_dist = np.linalg.norm(obj_pos[:2] - self.target_pos[:2])
+                reward += 1.0 * (1 - np.tanh(5.0 * transport_dist))
+
+                # Height bonus (keep object lifted during transport)
+                if obj_pos[2] > self.table_offset[2] + 0.05:
+                    reward += 0.5
+
+        if self.reward_scale is not None:
+            reward *= self.reward_scale / 3.0
+        return reward
+
+    def _load_model(self):
+        super()._load_model()
+
+        xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
+        self.robots[0].robot_model.set_base_xpos(xpos)
+
+        mujoco_arena = TableArena(
+            table_full_size=self.table_full_size,
+            table_friction=self.table_friction,
+            table_offset=self.table_offset,
+        )
+        mujoco_arena.set_origin([0, 0, 0])
+
+        # Use apple from converted objects
+        self.obj = MujocoXMLObject(
+            fname=xml_path_completion("objects/custom/035_apple/035_apple.xml"),
+            name="fragile_obj",
+            joints=[dict(type="free", damping="0.0005")],
+            obj_type="all",
+            duplicate_collision_geoms=False,
+        )
+
+        # Target zone marker (flat box on table — needs mass for free joint)
+        self.target_marker = BoxObject(
+            name="target_zone",
+            size=[0.04, 0.04, 0.002],
+            rgba=[0.2, 0.8, 0.2, 0.5],
+            density=500,
+        )
+
+        self.placement_initializer = UniformRandomSampler(
+            name="ObjectSampler",
+            mujoco_objects=self.obj,
+            x_range=[-0.05, -0.02],
+            y_range=[-0.02, 0.02],
+            rotation=None,
+            ensure_object_boundary_in_range=False,
+            ensure_valid_placement=True,
+            reference_pos=self.table_offset,
+            z_offset=0.01,
+            rng=self.rng,
+        )
+
+        self.model = ManipulationTask(
+            mujoco_arena=mujoco_arena,
+            mujoco_robots=[robot.robot_model for robot in self.robots],
+            mujoco_objects=[self.obj, self.target_marker],
+        )
+
+    def _setup_references(self):
+        super()._setup_references()
+        self.obj_body_id = self.sim.model.body_name2id(self.obj.root_body)
+        self.target_body_id = self.sim.model.body_name2id(self.target_marker.root_body)
+
+    def _setup_observables(self):
+        observables = super()._setup_observables()
+
+        if self.use_object_obs:
+            modality = "object"
+
+            @sensor(modality=modality)
+            def obj_pos(obs_cache):
+                return np.array(self.sim.data.body_xpos[self.obj_body_id])
+
+            @sensor(modality=modality)
+            def obj_quat(obs_cache):
+                return convert_quat(np.array(self.sim.data.body_xquat[self.obj_body_id]), to="xyzw")
+
+            @sensor(modality=modality)
+            def target_pos(obs_cache):
+                return self.target_pos.copy() if self.target_pos is not None else np.zeros(3)
+
+            sensors = [obj_pos, obj_quat, target_pos]
+            arm_prefixes = self._get_arm_prefixes(self.robots[0], include_robot_name=False)
+            full_prefixes = self._get_arm_prefixes(self.robots[0])
+
+            sensors += [
+                self._get_obj_eef_sensor(full_pf, "obj_pos", f"{arm_pf}gripper_to_obj_pos", modality)
+                for arm_pf, full_pf in zip(arm_prefixes, full_prefixes)
+            ]
+            names = [s.__name__ for s in sensors]
+
+            for name, s in zip(names, sensors):
+                observables[name] = Observable(
+                    name=name, sensor=s, sampling_rate=self.control_freq,
+                )
+
+        return observables
+
+    def _reset_internal(self):
+        super()._reset_internal()
+
+        # Place object on left side
+        if not self.deterministic_reset:
+            object_placements = self.placement_initializer.sample()
+            for obj_pos, obj_quat, obj in object_placements.values():
+                self.sim.data.set_joint_qpos(
+                    obj.joints[0], np.concatenate([np.array(obj_pos), np.array(obj_quat)])
+                )
+
+        # Place target zone on right side
+        target_x = self.rng.uniform(0.03, 0.06)
+        target_y = self.rng.uniform(-0.02, 0.02)
+        self.target_pos = np.array([
+            target_x + self.table_offset[0],
+            target_y + self.table_offset[1],
+            self.table_offset[2] + 0.002,
+        ])
+
+        # Move target marker
+        if self.target_marker.joints:
+            self.sim.data.set_joint_qpos(
+                self.target_marker.joints[0],
+                np.concatenate([self.target_pos, [1, 0, 0, 0]]),
+            )
+
+    def _check_success(self):
+        obj_pos = self.sim.data.body_xpos[self.obj_body_id]
+
+        # Object must be in target zone
+        xy_dist = np.linalg.norm(obj_pos[:2] - self.target_pos[:2])
+        on_table = obj_pos[2] < self.table_offset[2] + 0.08
+        in_zone = xy_dist < 0.04 and on_table
+
+        # Gripper must be released
+        not_grasped = not self._check_grasp(
+            gripper=self.robots[0].gripper, object_geoms=self.obj
+        )
+
+        # Object must be stable
+        if self.obj.joints:
+            jid = self.sim.model.joint_name2id(self.obj.joints[0])
+            qvel_addr = self.sim.model.jnt_dofadr[jid]
+            vel = np.linalg.norm(self.sim.data.qvel[qvel_addr:qvel_addr + 3])
+        else:
+            vel = 0.0
+        stable = vel < 0.1
+
+        return in_zone and not_grasped and stable
+
+    def visualize(self, vis_settings):
+        super().visualize(vis_settings=vis_settings)
+        if vis_settings["grippers"]:
+            self._visualize_gripper_to_target(gripper=self.robots[0].gripper, target=self.obj)

tactile_tasks/envs/peg_insertion.py

@@ -291,13 +291,7 @@ class PegInsertion(ManipulationEnv):
             self._success_steps = 0
             return False
 
-        # 3. Peg translational velocity should be low
-        if self.peg_joint_id is not None:
-            qvel_addr = self.sim.model.jnt_dofadr[self.peg_joint_id]
-            peg_vel = self.sim.data.qvel[qvel_addr: qvel_addr + 3]  # translational only
-            if np.linalg.norm(peg_vel) > 0.1:
-                self._success_steps = 0
-                return False
+
 
         self._success_steps += 1
         return self._success_steps >= self._required_success_steps

tactile_tasks/envs/pen_insertion.py

@@ -0,0 +1,309 @@
+"""
+Task: Pen Insertion
+
+Contact-rich task: Grasp a pen/marker and insert it into a cup (pencup).
+Requires precise alignment and force-controlled insertion.
+
+Objects: Marker pen (058_markpen) + Pen cup (059_pencup)
+Success: Pen inserted into cup (pen tip below cup rim, pen roughly vertical)
+Tactile role: Detect contact with cup rim for alignment, control insertion force
+"""
+
+from collections import OrderedDict
+
+import numpy as np
+import mujoco
+
+from robosuite.environments.manipulation.manipulation_env import ManipulationEnv
+from robosuite.models.arenas import TableArena
+from robosuite.models.objects.objects import MujocoXMLObject
+from robosuite.models.tasks import ManipulationTask
+from robosuite.utils.observables import Observable, sensor
+from robosuite.utils.mjcf_utils import xml_path_completion
+from robosuite.utils.placement_samplers import UniformRandomSampler, SequentialCompositeSampler
+from robosuite.utils.transform_utils import convert_quat
+
+
+class PenInsertion(ManipulationEnv):
+    """
+    Pen insertion task: grasp a pen and insert it into a cup.
+
+    The pen starts lying on the table. The robot must:
+    1. Grasp the pen
+    2. Lift and reorient to vertical
+    3. Align with cup opening
+    4. Insert with controlled force
+
+    Contact-rich because:
+    - Grasping a thin cylindrical object requires precise contact
+    - Alignment with cup opening needs tactile feedback at rim
+    - Insertion force must be controlled to avoid tipping the cup
+    """
+
+    def __init__(
+        self,
+        robots,
+        env_configuration="default",
+        controller_configs=None,
+        gripper_types="Robotiq85Gripper",
+        base_types="default",
+        initialization_noise="default",
+        table_full_size=(0.8, 0.8, 0.05),
+        table_friction=(1.0, 5e-3, 1e-4),
+        use_camera_obs=True,
+        use_object_obs=True,
+        reward_scale=1.0,
+        reward_shaping=True,
+        placement_initializer=None,
+        has_renderer=False,
+        has_offscreen_renderer=True,
+        render_camera="frontview",
+        render_collision_mesh=False,
+        render_visual_mesh=True,
+        render_gpu_device_id=-1,
+        control_freq=20,
+        lite_physics=True,
+        horizon=800,
+        ignore_done=False,
+        hard_reset=True,
+        camera_names="agentview",
+        camera_heights=256,
+        camera_widths=256,
+        camera_depths=False,
+        camera_segmentations=None,
+        renderer="mjviewer",
+        renderer_config=None,
+        seed=None,
+    ):
+        self.table_full_size = table_full_size
+        self.table_friction = table_friction
+        self.table_offset = np.array((0, 0, 0.8))
+        self.reward_scale = reward_scale
+        self.reward_shaping = reward_shaping
+        self.use_object_obs = use_object_obs
+        self.placement_initializer = placement_initializer
+
+        super().__init__(
+            robots=robots,
+            env_configuration=env_configuration,
+            controller_configs=controller_configs,
+            base_types=base_types,
+            gripper_types=gripper_types,
+            initialization_noise=initialization_noise,
+            use_camera_obs=use_camera_obs,
+            has_renderer=has_renderer,
+            has_offscreen_renderer=has_offscreen_renderer,
+            render_camera=render_camera,
+            render_collision_mesh=render_collision_mesh,
+            render_visual_mesh=render_visual_mesh,
+            render_gpu_device_id=render_gpu_device_id,
+            control_freq=control_freq,
+            lite_physics=lite_physics,
+            horizon=horizon,
+            ignore_done=ignore_done,
+            hard_reset=hard_reset,
+            camera_names=camera_names,
+            camera_heights=camera_heights,
+            camera_widths=camera_widths,
+            camera_depths=camera_depths,
+            camera_segmentations=camera_segmentations,
+            renderer=renderer,
+            renderer_config=renderer_config,
+            seed=seed,
+        )
+
+    def _get_pen_verticality(self):
+        """Return how vertical the pen is (0 = horizontal, 1 = vertical)."""
+        quat = self.sim.data.body_xquat[self.pen_body_id]
+        mat = np.zeros(9)
+        mujoco.mju_quat2Mat(mat, quat)
+        z_axis = mat.reshape(3, 3)[:, 2]
+        return abs(z_axis[2])
+
+    def reward(self, action=None):
+        reward = 0.0
+        if self._check_success():
+            reward = 4.0
+        elif self.reward_shaping:
+            pen_pos = self.sim.data.body_xpos[self.pen_body_id]
+            cup_pos = self.sim.data.body_xpos[self.cup_body_id]
+
+            # Reaching pen
+            dist = self._gripper_to_target(
+                gripper=self.robots[0].gripper,
+                target=self.pen.root_body,
+                target_type="body",
+                return_distance=True,
+            )
+            reward += 0.5 * (1 - np.tanh(10.0 * dist))
+
+            # Grasping pen
+            grasped = self._check_grasp(gripper=self.robots[0].gripper, object_geoms=self.pen)
+            if grasped:
+                reward += 0.5
+
+                # Verticality bonus
+                vert = self._get_pen_verticality()
+                reward += 0.5 * vert
+
+                # Alignment: pen xy near cup xy
+                xy_dist = np.linalg.norm(pen_pos[:2] - cup_pos[:2])
+                reward += 1.0 * (1 - np.tanh(10.0 * xy_dist))
+
+                # Insertion: pen z going down toward cup
+                if xy_dist < 0.03 and vert > 0.7:
+                    # Cup top ~ cup_pos[2] + cup_half_height
+                    insertion_depth = cup_pos[2] + 0.035 - pen_pos[2]
+                    if insertion_depth > 0:
+                        reward += min(1.5, insertion_depth * 20)
+
+        if self.reward_scale is not None:
+            reward *= self.reward_scale / 4.0
+        return reward
+
+    def _load_model(self):
+        super()._load_model()
+
+        xpos = self.robots[0].robot_model.base_xpos_offset["table"](self.table_full_size[0])
+        self.robots[0].robot_model.set_base_xpos(xpos)
+
+        mujoco_arena = TableArena(
+            table_full_size=self.table_full_size,
+            table_friction=self.table_friction,
+            table_offset=self.table_offset,
+        )
+        mujoco_arena.set_origin([0, 0, 0])
+
+        # Pen (marker)
+        self.pen = MujocoXMLObject(
+            fname=xml_path_completion("objects/custom/058_markpen/058_markpen.xml"),
+            name="pen",
+            joints=[dict(type="free", damping="0.0005")],
+            obj_type="all",
+            duplicate_collision_geoms=False,
+        )
+
+        # Cup (pencup)
+        self.cup = MujocoXMLObject(
+            fname=xml_path_completion("objects/custom/059_pencup/059_pencup.xml"),
+            name="pencup",
+            joints=[dict(type="free", damping="0.0005")],
+            obj_type="all",
+            duplicate_collision_geoms=False,
+        )
+
+        self.placement_initializer = SequentialCompositeSampler(name="ObjectSampler")
+        self.placement_initializer.append_sampler(
+            UniformRandomSampler(
+                name="PenSampler",
+                mujoco_objects=self.pen,
+                x_range=[-0.08, -0.03],
+                y_range=[-0.02, 0.02],
+                rotation=None,
+                ensure_object_boundary_in_range=False,
+                ensure_valid_placement=False,
+                reference_pos=self.table_offset,
+                z_offset=0.01,
+                rng=self.rng,
+            )
+        )
+        self.placement_initializer.append_sampler(
+            UniformRandomSampler(
+                name="CupSampler",
+                mujoco_objects=self.cup,
+                x_range=[0.03, 0.06],
+                y_range=[-0.02, 0.02],
+                rotation=None,
+                ensure_object_boundary_in_range=False,
+                ensure_valid_placement=False,
+                reference_pos=self.table_offset,
+                z_offset=0.01,
+                rng=self.rng,
+            )
+        )
+
+        self.model = ManipulationTask(
+            mujoco_arena=mujoco_arena,
+            mujoco_robots=[robot.robot_model for robot in self.robots],
+            mujoco_objects=[self.pen, self.cup],
+        )
+
+    def _setup_references(self):
+        super()._setup_references()
+        self.pen_body_id = self.sim.model.body_name2id(self.pen.root_body)
+        self.cup_body_id = self.sim.model.body_name2id(self.cup.root_body)
+
+    def _setup_observables(self):
+        observables = super()._setup_observables()
+
+        if self.use_object_obs:
+            modality = "object"
+
+            @sensor(modality=modality)
+            def pen_pos(obs_cache):
+                return np.array(self.sim.data.body_xpos[self.pen_body_id])
+
+            @sensor(modality=modality)
+            def pen_quat(obs_cache):
+                return convert_quat(np.array(self.sim.data.body_xquat[self.pen_body_id]), to="xyzw")
+
+            @sensor(modality=modality)
+            def cup_pos(obs_cache):
+                return np.array(self.sim.data.body_xpos[self.cup_body_id])
+
+            @sensor(modality=modality)
+            def cup_quat(obs_cache):
+                return convert_quat(np.array(self.sim.data.body_xquat[self.cup_body_id]), to="xyzw")
+
+            sensors = [pen_pos, pen_quat, cup_pos, cup_quat]
+            arm_prefixes = self._get_arm_prefixes(self.robots[0], include_robot_name=False)
+            full_prefixes = self._get_arm_prefixes(self.robots[0])
+
+            sensors += [
+                self._get_obj_eef_sensor(full_pf, "pen_pos", f"{arm_pf}gripper_to_pen_pos", modality)
+                for arm_pf, full_pf in zip(arm_prefixes, full_prefixes)
+            ]
+            names = [s.__name__ for s in sensors]
+
+            for name, s in zip(names, sensors):
+                observables[name] = Observable(
+                    name=name, sensor=s, sampling_rate=self.control_freq,
+                )
+
+        return observables
+
+    def _reset_internal(self):
+        super()._reset_internal()
+        if not self.deterministic_reset:
+            object_placements = self.placement_initializer.sample()
+            for obj_pos, obj_quat, obj in object_placements.values():
+                self.sim.data.set_joint_qpos(
+                    obj.joints[0], np.concatenate([np.array(obj_pos), np.array(obj_quat)])
+                )
+
+    def _check_success(self):
+        pen_pos = self.sim.data.body_xpos[self.pen_body_id]
+        cup_pos = self.sim.data.body_xpos[self.cup_body_id]
+
+        # Pen must be roughly vertical
+        vertical = self._get_pen_verticality() > 0.7
+
+        # Pen xy must be near cup xy (inside the cup opening)
+        xy_dist = np.linalg.norm(pen_pos[:2] - cup_pos[:2])
+        aligned = xy_dist < 0.03
+
+        # Pen center must be below cup top (inserted)
+        # Cup half-height ~ 0.035m, so cup top is cup_pos[2] + 0.035
+        inserted = pen_pos[2] < cup_pos[2] + 0.04
+
+        # Gripper released
+        not_grasped = not self._check_grasp(
+            gripper=self.robots[0].gripper, object_geoms=self.pen
+        )
+
+        return vertical and aligned and inserted and not_grasped
+
+    def visualize(self, vis_settings):
+        super().visualize(vis_settings=vis_settings)
+        if vis_settings["grippers"]:
+            self._visualize_gripper_to_target(gripper=self.robots[0].gripper, target=self.pen)

tactile_tasks/eval_act.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Evaluate trained ACT policy in robosuite environment.
+
+ACT outputs action chunks (chunk_size steps at once).
+Two execution modes:
+  - chunk: execute full chunk, then re-query (default)
+  - temporal_agg: query every step, exponentially-weighted average of overlapping chunks
+
+Usage:
+  cd policy/ACT
+  python ../../tactile_tasks/eval_act.py --task precision_grasp
+  python ../../tactile_tasks/eval_act.py --task precision_grasp --temporal_agg
+  python ../../tactile_tasks/eval_act.py --task precision_grasp --ckpt policy_last.ckpt
+"""
+
+import os
+import sys
+import argparse
+import pickle
+
+import numpy as np
+import torch
+from einops import rearrange
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "policy", "ACT"))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from act_policy import ACTPolicy
+
+
+def load_policy(ckpt_dir, ckpt_name, policy_config):
+    """Load trained ACT policy and dataset stats."""
+    policy = ACTPolicy(policy_config)
+    ckpt_path = os.path.join(ckpt_dir, ckpt_name)
+    loading_status = policy.load_state_dict(torch.load(ckpt_path, map_location="cpu"))
+    print(f"Loaded: {ckpt_path} ({loading_status})")
+    policy.cuda()
+    policy.eval()
+
+    stats_path = os.path.join(ckpt_dir, "dataset_stats.pkl")
+    with open(stats_path, "rb") as f:
+        stats = pickle.load(f)
+
+    return policy, stats
+
+
+def get_obs(env, camera_names, stats):
+    """Extract qpos and images from robosuite env, apply normalization."""
+    robot = env.robots[0]
+
+    # qpos: joint_pos(7) + normalized_gripper(1) = 8D
+    joint_pos = np.array(env.sim.data.qpos[robot._ref_joint_pos_indexes])
+    gripper_idx = robot._ref_gripper_joint_pos_indexes.get("right", [])
+    gripper_val = env.sim.data.qpos[gripper_idx][0] / 0.8 if len(gripper_idx) else 0.0
+    qpos = np.concatenate([joint_pos, [gripper_val]]).astype(np.float32)
+
+    # Normalize qpos
+    qpos_norm = (qpos - stats["qpos_mean"]) / stats["qpos_std"]
+    qpos_tensor = torch.from_numpy(qpos_norm).float().cuda().unsqueeze(0)
+
+    # Images: stack cameras → (1, num_cams, 3, H, W)
+    obs = env._get_observations()
+    cam_map = {"agentview": "agentview_image", "eye_in_hand": "robot0_eye_in_hand_image"}
+    images = []
+    for cam in camera_names:
+        key = cam_map.get(cam, cam + "_image")
+        img = obs[key]  # (H, W, 3) uint8
+        img = rearrange(img, "h w c -> c h w")
+        images.append(img)
+    images = np.stack(images, axis=0)  # (num_cams, 3, H, W)
+    images = torch.from_numpy(images / 255.0).float().cuda().unsqueeze(0)
+
+    return qpos_tensor, images, qpos
+
+
+def run_eval(task, ckpt_dir, ckpt_name, num_rollouts, temporal_agg, camera_names,
+             render=False):
+    """Run evaluation rollouts."""
+    import yaml
+
+    # Load ACT config
+    config_path = os.path.join(os.path.dirname(__file__), "..", "policy", "ACT", "train_config.yaml")
+    with open(config_path, "r") as f:
+        cfg = yaml.safe_load(f)
+
+    state_dim = cfg["state_dim"]
+    chunk_size = cfg["chunk_size"]
+
+    # Build policy config (same structure as training)
+    policy_config = {
+        "lr": cfg["lr"],
+        "num_queries": chunk_size,
+        "kl_weight": cfg["kl_weight"],
+        "hidden_dim": cfg["hidden_dim"],
+        "dim_feedforward": cfg["dim_feedforward"],
+        "lr_backbone": 1e-5,
+        "backbone": "resnet18",
+        "enc_layers": 4,
+        "dec_layers": 7,
+        "nheads": 8,
+        "camera_names": camera_names,
+        "state_dim": state_dim,
+        "chunk_size": chunk_size,
+    }
+
+    policy, stats = load_policy(ckpt_dir, ckpt_name, policy_config)
+    post_process = lambda a: a * stats["action_std"] + stats["action_mean"]
+
+    # Create environment with extended horizon (settling steps + eval steps)
+    from tactile_tasks.collect_data import create_env, TASK_CONFIGS
+    settle_steps = 50
+    max_timesteps = max(TASK_CONFIGS[task]["horizon"], 900)
+    env = create_env(task, has_renderer=render)
+    env.horizon = max_timesteps + settle_steps  # override so env doesn't cut us short
+
+    query_frequency = 1 if temporal_agg else chunk_size
+
+    successes = []
+    for ep in range(num_rollouts):
+        env.reset()
+        # Let objects settle
+        for _ in range(50):
+            env.step(np.zeros(7))
+
+        if temporal_agg:
+            all_time_actions = torch.zeros(
+                [max_timesteps, max_timesteps + chunk_size, state_dim]
+            ).cuda()
+
+        all_actions = None
+        episode_success = False
+
+        with torch.inference_mode():
+            for t in range(max_timesteps):
+                qpos, images, _ = get_obs(env, camera_names, stats)
+
+                # Query policy
+                if t % query_frequency == 0:
+                    all_actions = policy(qpos, images)  # (1, chunk_size, state_dim)
+
+                if temporal_agg:
+                    all_time_actions[[t], t:t + chunk_size] = all_actions
+                    actions_for_curr_step = all_time_actions[:, t]
+                    actions_populated = torch.all(actions_for_curr_step != 0, axis=1)
+                    actions_for_curr_step = actions_for_curr_step[actions_populated]
+                    k = 0.01
+                    exp_weights = np.exp(-k * np.arange(len(actions_for_curr_step)))
+                    exp_weights = exp_weights / exp_weights.sum()
+                    exp_weights = torch.from_numpy(exp_weights).cuda().unsqueeze(dim=1)
+                    raw_action = (actions_for_curr_step * exp_weights).sum(dim=0, keepdim=True)
+                else:
+                    raw_action = all_actions[:, t % query_frequency]
+
+                # Post-process: denormalize, take first 7D (ignore padding dim)
+                action = post_process(raw_action.squeeze(0).cpu().numpy())
+                action = action[:7]  # 8D → 7D OSC_POSE
+
+                env.step(action)
+                if render:
+                    env.render()
+
+                if env._check_success():
+                    episode_success = True
+
+        successes.append(episode_success)
+        status = "SUCCESS" if episode_success else "FAIL"
+        print(f"  [{ep+1}/{num_rollouts}] {status}  (t={t+1})")
+
+    success_rate = sum(successes) / len(successes)
+    print(f"\n{'='*40}")
+    print(f"Task: {task}")
+    print(f"Checkpoint: {ckpt_dir}/{ckpt_name}")
+    print(f"Mode: {'temporal_agg' if temporal_agg else 'chunk'}")
+    print(f"Success: {sum(successes)}/{num_rollouts} ({success_rate*100:.1f}%)")
+    print(f"{'='*40}")
+
+    env.close()
+    return success_rate
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", type=str, required=True,
+                        choices=["precision_grasp", "peg_insertion", "gentle_stack"])
+    parser.add_argument("--ckpt_dir", type=str, default=None,
+                        help="checkpoint dir (default: policy/ACT/checkpoints/{task}_act)")
+    parser.add_argument("--ckpt", type=str, default="policy_best.ckpt")
+    parser.add_argument("--num_rollouts", type=int, default=50)
+    parser.add_argument("--temporal_agg", action="store_true")
+    parser.add_argument("--render", action="store_true", help="visualize with on-screen renderer")
+    parser.add_argument("--cameras", nargs="+", default=["agentview", "eye_in_hand"])
+    args = parser.parse_args()
+
+    if args.ckpt_dir is None:
+        args.ckpt_dir = os.path.join(
+            os.path.dirname(__file__), "..", "policy", "ACT", "checkpoints", f"{args.task}_act"
+        )
+
+    run_eval(
+        task=args.task,
+        ckpt_dir=args.ckpt_dir,
+        ckpt_name=args.ckpt,
+        num_rollouts=args.num_rollouts,
+        temporal_agg=args.temporal_agg,
+        camera_names=args.cameras,
+        render=args.render,
+    )

tactile_tasks/eval_dp.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Evaluate trained Diffusion Policy in robosuite environment.
+
+DP output characteristics:
+  - Predicts `horizon` (8) steps of actions conditioned on `n_obs_steps` (3) frames
+  - Executes `n_action_steps` (6) of them, then re-queries with fresh observations
+  - This "receding horizon" approach naturally handles drift and disturbances
+
+Planner design:
+  - Maintain an observation history buffer of length n_obs_steps
+  - Query policy → get n_action_steps actions → execute all → repeat
+  - No reliance on env.done signal (we control the episode length)
+  - Observations include images (head_cam) and state (agent_pos)
+
+Usage:
+  python tactile_tasks/eval_dp.py --task precision_grasp
+  python tactile_tasks/eval_dp.py --task precision_grasp --render
+  python tactile_tasks/eval_dp.py --task gentle_stack --ckpt /path/to/checkpoint.ckpt
+"""
+
+import os
+import sys
+import argparse
+from collections import deque
+
+import numpy as np
+import torch
+import dill
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+def get_obs(env):
+    """Extract raw observation dict from robosuite env (no normalization - DP handles it)."""
+    robot = env.robots[0]
+    obs = env._get_observations()
+
+    # State: joint_pos(7) + normalized_gripper(1) = 8D
+    joint_pos = np.array(env.sim.data.qpos[robot._ref_joint_pos_indexes])
+    gripper_idx = robot._ref_gripper_joint_pos_indexes.get("right", [])
+    gripper_val = env.sim.data.qpos[gripper_idx][0] / 0.8 if len(gripper_idx) else 0.0
+    state = np.concatenate([joint_pos, [gripper_val]]).astype(np.float32)
+
+    # Image: (H, W, 3) uint8 → (3, H, W) for head_camera
+    head_cam = obs["agentview_image"]  # (256, 256, 3) uint8
+    head_cam = np.moveaxis(head_cam, -1, 0)  # (3, 256, 256)
+
+    return {
+        "head_camera": head_cam,
+        "state": state,
+    }
+
+
+def load_dp_policy(ckpt_path, device="cuda:0"):
+    """Load DP policy from checkpoint, return (policy, cfg)."""
+    payload = torch.load(open(ckpt_path, "rb"), pickle_module=dill, map_location=device)
+    cfg = payload["cfg"]
+
+    # Get n_obs_steps, n_action_steps from config
+    n_obs_steps = cfg.n_obs_steps
+    n_action_steps = cfg.n_action_steps
+
+    # Reconstruct workspace to load ema_model
+    import hydra
+    from diffusion_policy.workspace.robotworkspace import RobotWorkspace
+
+    workspace = RobotWorkspace(cfg)
+    workspace.load_payload(payload)
+
+    # Use EMA model if available (better performance)
+    if workspace.ema_model is not None:
+        policy = workspace.ema_model
+        print("Using EMA model")
+    else:
+        policy = workspace.model
+        print("Using base model")
+
+    policy.to(device)
+    policy.eval()
+
+    print(f"Loaded: {ckpt_path}")
+    print(f"  horizon={cfg.horizon}, n_obs_steps={n_obs_steps}, n_action_steps={n_action_steps}")
+
+    return policy, cfg
+
+
+def run_eval(task, ckpt_path, num_rollouts, render=False, device="cuda:0"):
+    """Run evaluation rollouts with DP policy."""
+
+    # Add DP to path for imports
+    dp_dir = os.path.join(os.path.dirname(__file__), "..", "policy", "DP")
+    sys.path.insert(0, dp_dir)
+
+    policy, cfg = load_dp_policy(ckpt_path, device)
+    n_obs_steps = cfg.n_obs_steps
+    n_action_steps = cfg.n_action_steps
+
+    # Create environment
+    from tactile_tasks.collect_data import create_env, TASK_CONFIGS
+    settle_steps = 50
+    max_timesteps = max(TASK_CONFIGS[task]["horizon"], 900)
+    env = create_env(task, has_renderer=render)
+    env.horizon = max_timesteps + settle_steps
+
+    successes = []
+    for ep in range(num_rollouts):
+        env.reset()
+        # Let objects settle
+        for _ in range(settle_steps):
+            env.step(np.zeros(7))
+
+        # Initialize obs history buffer with current observation repeated
+        obs = get_obs(env)
+        obs_history = deque(maxlen=n_obs_steps)
+        for _ in range(n_obs_steps):
+            obs_history.append(obs)
+
+        episode_success = False
+        t = 0
+
+        with torch.inference_mode():
+            while t < max_timesteps:
+                # Build observation batch: (1, n_obs_steps, ...)
+                head_cams = np.stack([o["head_camera"] for o in obs_history])  # (T_o, 3, H, W)
+                states = np.stack([o["state"] for o in obs_history])  # (T_o, 8)
+
+                obs_dict = {
+                    "head_cam": torch.from_numpy(head_cams / 255.0).float().unsqueeze(0).to(device),
+                    "agent_pos": torch.from_numpy(states).float().unsqueeze(0).to(device),
+                }
+
+                # Query policy → get n_action_steps actions
+                result = policy.predict_action(obs_dict)
+                actions = result["action"].squeeze(0).cpu().numpy()  # (n_action_steps, 7)
+
+                # Execute action chunk
+                for i in range(len(actions)):
+                    if t >= max_timesteps:
+                        break
+
+                    action = actions[i]  # 7D OSC_POSE
+                    env.step(action)
+                    if render:
+                        env.render()
+
+                    # Update obs history
+                    obs = get_obs(env)
+                    obs_history.append(obs)
+
+                    if env._check_success():
+                        episode_success = True
+
+                    t += 1
+
+        successes.append(episode_success)
+        status = "SUCCESS" if episode_success else "FAIL"
+        print(f"  [{ep+1}/{num_rollouts}] {status}  (t={t})")
+
+    success_rate = sum(successes) / len(successes)
+    print(f"\n{'='*40}")
+    print(f"Task: {task}")
+    print(f"Checkpoint: {ckpt_path}")
+    print(f"n_obs_steps={n_obs_steps}, n_action_steps={n_action_steps}")
+    print(f"Success: {sum(successes)}/{num_rollouts} ({success_rate*100:.1f}%)")
+    print(f"{'='*40}")
+
+    env.close()
+    return success_rate
+
+
+def find_best_ckpt(task):
+    """Find the best checkpoint for given task in DP checkpoints directory."""
+    dp_dir = os.path.join(os.path.dirname(__file__), "..", "policy", "DP")
+
+    # Search in checkpoints/ directory (where train.py saves them)
+    search_dirs = [
+        os.path.join(dp_dir, "checkpoints"),
+        os.path.join(dp_dir, "data", "outputs"),
+    ]
+
+    candidates = []
+    for search_dir in search_dirs:
+        if not os.path.isdir(search_dir):
+            continue
+        for root, dirs, files in os.walk(search_dir):
+            # Prefer dirs that match the task name
+            for f in files:
+                if f.endswith(".ckpt"):
+                    path = os.path.join(root, f)
+                    # Prioritize task-matching paths
+                    score = 1 if task in root else 0
+                    candidates.append((score, os.path.getmtime(path), path))
+
+    if candidates:
+        # Sort by task match first, then by modification time
+        candidates.sort(key=lambda x: (x[0], x[1]), reverse=True)
+        return candidates[0][2]
+    return None
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", type=str, required=True,
+                        choices=["precision_grasp", "peg_insertion", "gentle_stack"])
+    parser.add_argument("--ckpt", type=str, default=None,
+                        help="path to DP checkpoint (.ckpt)")
+    parser.add_argument("--num_rollouts", type=int, default=50)
+    parser.add_argument("--render", action="store_true", help="visualize with on-screen renderer")
+    parser.add_argument("--device", type=str, default="cuda:0")
+    args = parser.parse_args()
+
+    if args.ckpt is None:
+        args.ckpt = find_best_ckpt(args.task)
+        if args.ckpt is None:
+            print("No checkpoint found. Specify with --ckpt /path/to/checkpoint.ckpt")
+            sys.exit(1)
+        print(f"Auto-detected checkpoint: {args.ckpt}")
+
+    run_eval(
+        task=args.task,
+        ckpt_path=args.ckpt,
+        num_rollouts=args.num_rollouts,
+        render=args.render,
+        device=args.device,
+    )