scripts/graspnet_task_e/run_graspnet_pick.py

"""Smoke-test a GraspNet-guided Task-E pick-and-place primitive.

This is intentionally separate from ACT training.  It tests whether TunTunClaw
GraspNet can produce a usable grasp centre/yaw from Task-E RGB-D observations.
"""

from __future__ import annotations

import argparse
import os
import subprocess
import sys
from pathlib import Path
import json


REPO_ROOT = Path(__file__).resolve().parents[2]
if str(REPO_ROOT) not in sys.path:
    sys.path.insert(0, str(REPO_ROOT))

from isaaclab.app import AppLauncher


parser = argparse.ArgumentParser(description="Run one Task-E grasp-guided pick trial.")
parser.add_argument("--grasp_provider", choices=["graspnet", "anygrasp", "pca"], default="graspnet")
parser.add_argument("--object", type=int, default=1, choices=[1, 2, 3])
parser.add_argument("--seed", type=int, default=7)
parser.add_argument("--video_path", default="logs/videos/task_e_graspnet/graspnet_pick_obj1.mp4")
parser.add_argument("--tcp_z_offset", type=float, default=0.055)
parser.add_argument("--close_z_offset", type=float, default=None)
parser.add_argument("--pregrasp_z", type=float, default=0.30)
parser.add_argument("--lift_z", type=float, default=0.30)
parser.add_argument("--place_z", type=float, default=0.18)
parser.add_argument("--release_z", type=float, default=0.32)
parser.add_argument("--open_release_z", type=float, default=None)
parser.add_argument("--place_x_offset", type=float, default=0.0)
parser.add_argument("--place_y_offset", type=float, default=0.0)
parser.add_argument("--basket_center_release", action=argparse.BooleanOptionalAction, default=True)
parser.add_argument("--basket_servo_gain", type=float, default=1.0)
parser.add_argument("--basket_servo_max_xy", type=float, default=0.30)
parser.add_argument("--staged_transport", action=argparse.BooleanOptionalAction, default=True)
parser.add_argument("--transport_servo_fraction", type=float, default=0.25)
parser.add_argument("--basket_xy_tol", type=float, default=0.055)
parser.add_argument("--basket_hold_steps", type=int, default=900)
parser.add_argument("--basket_stable_steps", type=int, default=80)
parser.add_argument("--basket_recovery_steps", type=int, default=900)
parser.add_argument("--dynamic_finger_servo", action=argparse.BooleanOptionalAction, default=True)
parser.add_argument("--close_steps", type=int, default=70)
parser.add_argument("--preclose_insert_steps", type=int, default=0)
parser.add_argument("--preclose_insert_dx", type=float, default=0.0)
parser.add_argument("--preclose_insert_dy", type=float, default=0.0)
parser.add_argument("--move_steps", type=int, default=160)
parser.add_argument("--transport_steps", type=int, default=None)
parser.add_argument("--place_steps", type=int, default=None)
parser.add_argument("--settle_steps", type=int, default=120)
parser.add_argument("--force_default_quat", action="store_true")
parser.add_argument("--use_task_quat", action="store_true")
parser.add_argument("--no_finger_servo", action="store_true")
parser.add_argument("--no_object_offset", action="store_true")
parser.add_argument("--post_push", action="store_true")
parser.add_argument("--auto_table_push_on_slip", action=argparse.BooleanOptionalAction, default=True)
parser.add_argument("--post_push_steps", type=int, default=600)
parser.add_argument("--post_push_behind", type=float, default=0.075)
parser.add_argument("--post_push_z", type=float, default=0.055)
parser.add_argument("--drag_recovery_steps", type=int, default=1200)
parser.add_argument("--mask_provider", choices=["oracle", "band", "sam3"], default="oracle")
parser.add_argument(
    "--sam3_python",
    default="/home/ubuntu/Documents/01Proj/sam3d_gs/.venv/bin/python",
    help="Python executable for the isolated SAM3 environment.",
)
parser.add_argument("--sam3_threshold", type=float, default=0.35)
parser.add_argument("--sam3_mask_threshold", type=float, default=0.5)
parser.add_argument(
    "--sam3_prompt",
    action="append",
    default=None,
    help="SAM3 text prompt. Can repeat. Defaults are selected from --object.",
)
parser.add_argument("--save_debug_npz", default="logs/graspnet_task_e/latest_debug.npz")
AppLauncher.add_app_launcher_args(parser)
args_cli = parser.parse_args()
args_cli.enable_cameras = True

app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

import imageio.v2 as imageio
import numpy as np
import torch

from isaaclab.actuators import ImplicitActuatorCfg
from isaaclab.envs import ManagerBasedRLEnv

from atec_rl_lab.tasks.task_e.env_cfg import (
    BASKET_CENTER_X,
    BASKET_CENTER_Y,
    TABLE_TOP_Z,
    TaskEEnvPiperCfg,
)
from atec_rl_lab.utils import CartesianController

from scripts.act.task_e.collector import basket_status_lines, check_objects_in_basket
from scripts.act.task_e.config import (
    ACTION_SCALE,
    ACT_DAMPING,
    ACT_EFFORT_LIMIT,
    ACT_STIFFNESS,
    ACT_VEL_LIMIT,
    ARM_JOINT_NAMES,
    CARRY_Z,
    DEFAULT_PLACE_QUAT_W,
    EE_BODY_NAME,
    GRIPPER_CLOSE_POS,
    GRIPPER_JOINT_NAMES,
    GRIPPER_OPEN_POS,
    OBJ_GRASP_CENTER_OFFSETS,
    OBJ_GRASP_Z_OFFSETS,
    OBJ_CLOSE_Z_OFFSETS,
    OBJ_FINGER_CENTER_SERVO_GAIN,
    OBJ_FINGER_CENTER_SERVO_MAX_XY,
    OBJ_FINGER_CENTER_SERVO_TARGET_Z,
    OBJ_FINGER_CENTER_SERVO_MAX_Z,
    RETRACT_POS_X,
    RETRACT_POS_Y,
)
from scripts.act.task_e.state_machine import compute_grasp_quat
from scripts.graspnet_task_e.tuntun_adapter import (
    camera_arrays,
    infer_grasp_from_camera,
    oracle_object_mask,
    rgbd_band_object_mask,
    pos_to_torch,
    quat_wxyz_to_torch,
)
from scripts.graspnet_task_e.anygrasp_adapter import infer_anygrasp_from_camera
from scripts.graspnet_task_e.pca_aabb_adapter import infer_pca_aabb_from_camera


GRASPNET_CLOSE_Z_DEFAULTS = {
    3: -0.005,
}

SAM_MASK_P85_Z_MAX = {
    1: TABLE_TOP_Z + 0.13,
    2: TABLE_TOP_Z + 0.19,
    3: TABLE_TOP_Z + 0.085,
}


def build_env() -> ManagerBasedRLEnv:
    cfg = TaskEEnvPiperCfg()
    cfg.seed = args_cli.seed
    cfg.scene.num_envs = 1
    cfg.episode_length_s = 90.0
    cfg.scene.robot.actuators["default"] = ImplicitActuatorCfg(
        joint_names_expr=[".*"],
        effort_limit=ACT_EFFORT_LIMIT,
        velocity_limit=ACT_VEL_LIMIT,
        stiffness=ACT_STIFFNESS,
        damping=ACT_DAMPING,
    )
    return ManagerBasedRLEnv(cfg)


def step_pose(
    env,
    robot,
    ik_ctrl,
    arm_ids,
    gripper_ids,
    default_jpos,
    pos_w,
    quat_w,
    gripper,
    frames,
    camera,
    n_steps,
    *,
    obj_idx: int | None = None,
    obj=None,
    finger_body_indices: tuple[int, int] | None = None,
    servo_center_xy: np.ndarray | None = None,
    servo_current_object_xy: bool = False,
    finger_target_xy: np.ndarray | None = None,
    finger_target_z: float | None = None,
    finger_servo_gain: float = 1.0,
    finger_servo_max_xy: float = 0.12,
    finger_servo_max_z: float = 0.04,
    object_target_xy: np.ndarray | None = None,
    object_servo_gain: float = 1.0,
    object_servo_max_xy: float = 0.30,
) -> dict[str, float | list[float] | None]:
    dev = env.unwrapped.device
    pos_np = np.asarray(pos_w, dtype=np.float64)
    quat_t = quat_wxyz_to_torch(np.asarray(quat_w, dtype=np.float64), dev)
    grip_t = torch.tensor([gripper], dtype=torch.float32, device=dev)
    stats: dict[str, float | list[float] | None] = {
        "min_finger_dist": None,
        "min_finger_vec": None,
        "min_finger_gap": None,
        "min_finger_q": None,
        "last_finger_q": None,
    }
    for _ in range(n_steps):
        target_np = pos_np.copy()
        if obj is not None and object_target_xy is not None:
            obj_pos = obj.data.root_pos_w[0].detach()
            target_xy = torch.tensor(object_target_xy, dtype=torch.float32, device=dev)
            xy_error = target_xy - obj_pos[:2]
            correction = xy_error * object_servo_gain
            corr_norm = torch.linalg.norm(correction).clamp(min=1e-6)
            if corr_norm.item() > object_servo_max_xy:
                correction = correction / corr_norm * object_servo_max_xy
            target_np[:2] = target_np[:2] + correction.detach().cpu().numpy()
        if finger_body_indices is not None and not args_cli.no_finger_servo and (
            finger_target_xy is not None or (obj_idx is not None and obj is not None and servo_center_xy is not None)
        ):
            f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach()
            f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach()
            finger_center = 0.5 * (f0 + f1)
            obj_pos = obj.data.root_pos_w[0].detach() if obj is not None else None
            if finger_target_xy is not None:
                target_xy = torch.tensor(finger_target_xy, dtype=torch.float32, device=dev)
            elif servo_current_object_xy and obj_pos is not None:
                target_xy = obj_pos[:2]
            else:
                target_xy = torch.tensor(servo_center_xy, dtype=torch.float32, device=dev)
            grasp_center = torch.tensor(
                [
                    float(target_xy[0].item()),
                    float(target_xy[1].item()),
                    float(obj_pos[2].item()) if obj_pos is not None else float(finger_center[2].item()),
                ],
                dtype=torch.float32,
                device=dev,
            )
            finger_vec = finger_center - grasp_center
            finger_dist = float(torch.linalg.norm(finger_vec).item())
            finger_gap = float(torch.linalg.norm(f0 - f1).item())
            if stats["min_finger_dist"] is None or finger_dist < float(stats["min_finger_dist"]):
                stats["min_finger_dist"] = finger_dist
                stats["min_finger_vec"] = [float(v) for v in finger_vec.detach().cpu().tolist()]
            if stats["min_finger_gap"] is None or finger_gap < float(stats["min_finger_gap"]):
                stats["min_finger_gap"] = finger_gap
                q = robot.data.joint_pos[0, gripper_ids].detach().cpu().numpy()
                stats["min_finger_q"] = [float(q[0]), float(q[1])]
            q = robot.data.joint_pos[0, gripper_ids].detach().cpu().numpy()
            stats["last_finger_q"] = [float(q[0]), float(q[1])]
            xy_error = finger_center[:2] - target_xy
            if finger_target_xy is not None or servo_current_object_xy or torch.linalg.norm(xy_error).item() <= 0.18:
                gain = finger_servo_gain if finger_target_xy is not None else OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85)
                correction = -xy_error * gain
                max_xy = finger_servo_max_xy if finger_target_xy is not None else OBJ_FINGER_CENTER_SERVO_MAX_XY.get(obj_idx, 0.08)
                corr_norm = torch.linalg.norm(correction).clamp(min=1e-6)
                if corr_norm.item() > max_xy:
                    correction = correction / corr_norm * max_xy
                target_np[:2] = target_np[:2] + correction.detach().cpu().numpy()
                if finger_target_z is not None:
                    z_error = finger_target_z - float(finger_center[2].item())
                    z_correction = max(-finger_servo_max_z, min(finger_servo_max_z, z_error * gain))
                    target_np[2] = target_np[2] + z_correction
                elif obj_pos is not None and obj_idx in OBJ_FINGER_CENTER_SERVO_TARGET_Z:
                    target_rel_z = OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx]
                    z_error = target_rel_z - float((finger_center[2] - obj_pos[2]).item())
                    max_z = OBJ_FINGER_CENTER_SERVO_MAX_Z.get(obj_idx, 0.02)
                    z_correction = min(0.0, max(-max_z, z_error * gain))
                    target_np[2] = target_np[2] + z_correction
        pos_t = pos_to_torch(target_np, dev)
        arm_des = ik_ctrl.compute(pos_t, quat_t)
        target = robot.data.joint_pos.clone()
        target[:, arm_ids] = arm_des
        target[:, gripper_ids] = grip_t
        action = (target - default_jpos) / ACTION_SCALE
        env.step(action)
        robot.update(dt=env.unwrapped.physics_dt)
        if frames is not None:
            rgba = camera.data.output["rgb"][0].detach().cpu().numpy()
            frames.append(rgba[..., :3])
    return stats


def step_until_object_center_stable(
    env,
    robot,
    ik_ctrl,
    arm_ids,
    gripper_ids,
    default_jpos,
    pos_w,
    quat_w,
    gripper,
    frames,
    camera,
    *,
    obj,
    target_xy: np.ndarray,
    xy_tol: float,
    stable_steps: int,
    max_steps: int,
    object_servo_gain: float,
    object_servo_max_xy: float,
    obj_idx: int | None = None,
    finger_body_indices: tuple[int, int] | None = None,
    servo_center_xy: np.ndarray | None = None,
    servo_current_object_xy: bool = True,
) -> dict[str, float | int | list[float]]:
    stable = 0
    min_xy_err = 999.0
    last_obj_pos = None
    for step in range(max_steps):
        step_pose(
            env,
            robot,
            ik_ctrl,
            arm_ids,
            gripper_ids,
            default_jpos,
            pos_w,
            quat_w,
            gripper,
            frames,
            camera,
            1,
            obj_idx=obj_idx,
            obj=obj,
            finger_body_indices=finger_body_indices,
            servo_center_xy=servo_center_xy,
            servo_current_object_xy=servo_current_object_xy,
            object_target_xy=target_xy,
            object_servo_gain=object_servo_gain,
            object_servo_max_xy=object_servo_max_xy,
        )
        obj_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
        last_obj_pos = obj_pos
        xy_err = float(np.linalg.norm(obj_pos[:2] - target_xy))
        min_xy_err = min(min_xy_err, xy_err)
        if xy_err <= xy_tol:
            stable += 1
            if stable >= stable_steps:
                break
        else:
            stable = 0
    if last_obj_pos is None:
        last_obj_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
    return {
        "steps": step + 1 if max_steps > 0 else 0,
        "stable": stable,
        "min_xy_err": min_xy_err,
        "final_xy_err": float(np.linalg.norm(last_obj_pos[:2] - target_xy)),
        "final_obj_pos": [float(v) for v in last_obj_pos.tolist()],
    }


def sam3_prompts_for_object(obj_idx: int) -> list[str]:
    defaults = {
        1: ["sugar box", "box", "rectangular object"],
        2: ["mustard bottle", "bottle", "yellow bottle"],
        3: ["banana", "curved yellow object"],
    }
    return defaults.get(obj_idx, ["object"])


def select_sam_candidate_by_world_band(candidates_path: Path, camera, obj_idx: int) -> np.ndarray | None:
    from scipy.spatial.transform import Rotation
    from scripts.act.task_e.config import OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Y_BANDS

    if not candidates_path.exists():
        return None
    data = np.load(candidates_path, allow_pickle=False)
    masks = data["masks"].astype(bool)
    metas = json.loads(str(data["metas"]))
    _rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
    rot_w_cam = Rotation.from_quat(
        [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
    ).as_matrix()
    y0, y1 = OBJ_SPAWN_Y_BANDS[obj_idx]
    scored = []
    for idx, mask in enumerate(masks):
        valid = mask & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
        ys, xs = np.where(valid)
        if len(xs) < 64:
            continue
        z = depth[ys, xs].astype(np.float64)
        x_cam = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z
        y_cam = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z
        pts_cam = np.stack([x_cam, y_cam, z], axis=1)
        pts_w = (rot_w_cam @ pts_cam.T).T + pos_w
        keep = (
            (pts_w[:, 0] >= OBJ_SPAWN_X_MIN - 0.10)
            & (pts_w[:, 0] <= OBJ_SPAWN_X_MAX + 0.10)
            & (pts_w[:, 1] >= y0 - 0.08)
            & (pts_w[:, 1] <= y1 + 0.08)
            & (pts_w[:, 2] >= TABLE_TOP_Z + 0.005)
            & (pts_w[:, 2] <= TABLE_TOP_Z + 0.26)
        )
        band_count = int(np.count_nonzero(keep))
        band_ratio = band_count / max(len(xs), 1)
        if band_count < 64:
            continue
        band_pts = pts_w[keep]
        p85_z = float(np.percentile(band_pts[:, 2], 85))
        if p85_z > SAM_MASK_P85_Z_MAX.get(obj_idx, TABLE_TOP_Z + 0.18):
            continue
        score = float(metas[idx].get("score", 0.0))
        # Prefer masks that live in the object's legal spawn band. Score is
        # secondary because open-vocabulary prompts can rate distractors high.
        scored.append((band_ratio, band_count, score, -p85_z, idx, keep, ys, xs))
    if not scored:
        print("[SAM3] no candidate survived world-band filter; using best SAM3 mask")
        return None
    band_ratio, band_count, score, neg_p85_z, idx, keep, ys, xs = max(scored, key=lambda x: (x[1], x[0], x[2], x[3]))
    refined = np.zeros_like(masks[idx], dtype=np.bool_)
    refined[ys[keep], xs[keep]] = True
    meta = metas[idx]
    print(
        f"[SAM3] selected_candidate={idx} prompt={meta.get('prompt')} score={score:.3f} "
        f"band_ratio={band_ratio:.3f} band_pixels={band_count} p85_z={-neg_p85_z:.3f}"
    )
    return refined


def sam3_object_mask(camera, rgb: np.ndarray, obj_idx: int, debug_dir: Path) -> np.ndarray:
    if not Path(args_cli.sam3_python).exists():
        raise RuntimeError(f"SAM3 python not found: {args_cli.sam3_python}")
    debug_dir.mkdir(parents=True, exist_ok=True)
    image_path = debug_dir / f"sam3_obj{obj_idx}_rgb.png"
    mask_path = debug_dir / f"sam3_obj{obj_idx}_mask.npy"
    meta_path = debug_dir / f"sam3_obj{obj_idx}_meta.json"
    candidates_path = debug_dir / f"sam3_obj{obj_idx}_candidates.npz"
    imageio.imwrite(str(image_path), rgb.astype(np.uint8))
    prompts = args_cli.sam3_prompt or sam3_prompts_for_object(obj_idx)
    cmd = [
        args_cli.sam3_python,
        str(Path(__file__).with_name("sam3_segment_image.py")),
        "--image",
        str(image_path),
        "--out_mask",
        str(mask_path),
        "--out_meta",
        str(meta_path),
        "--out_candidates",
        str(candidates_path),
        "--threshold",
        str(args_cli.sam3_threshold),
        "--mask_threshold",
        str(args_cli.sam3_mask_threshold),
    ]
    for prompt in prompts:
        cmd.extend(["--prompt", prompt])
    print(f"[SAM3] prompts={prompts} image={image_path}")
    subprocess.run(cmd, check=True)
    mask = np.load(mask_path).astype(bool)
    if candidates_path.exists():
        refined = select_sam_candidate_by_world_band(candidates_path, camera=camera, obj_idx=obj_idx)
        if refined is not None:
            mask = refined
            np.save(mask_path, mask.astype(np.bool_))
    print(f"[SAM3] mask_pixels={int(mask.sum())} meta={meta_path}")
    return mask


def object_z_gain(env, obj_idx: int, z0: float) -> float:
    pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
    return float(pos[2].item() - z0)


def run_table_push_recovery(
    env,
    robot,
    ik_ctrl,
    arm_ids,
    gripper_ids,
    default_jpos,
    frames,
    camera,
    obj,
    topdown_quat,
    finger_body_indices: tuple[int, int] | None,
) -> None:
    cur = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
    push_z = TABLE_TOP_Z + args_cli.post_push_z
    behind = args_cli.post_push_behind
    # Approach from the positive-Y side and push toward the basket center.  This
    # is the deterministic fallback when the object has slipped back to the table.
    push_start = np.array([cur[0], cur[1] + behind, push_z], dtype=np.float64)
    push_mid = np.array([BASKET_CENTER_X, BASKET_CENTER_Y + behind, push_z], dtype=np.float64)
    push_end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y + behind * 0.20, push_z], dtype=np.float64)
    print(
        f"[TABLE_PUSH] cur=({cur[0]:.3f},{cur[1]:.3f},{cur[2]:.3f}) "
        f"start=({push_start[0]:.3f},{push_start[1]:.3f},{push_start[2]:.3f}) "
        f"mid=({push_mid[0]:.3f},{push_mid[1]:.3f},{push_mid[2]:.3f}) "
        f"end=({push_end[0]:.3f},{push_end[1]:.3f},{push_end[2]:.3f})"
    )
    contact_z = TABLE_TOP_Z + max(args_cli.post_push_z, 0.025)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_start, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 120, finger_body_indices=finger_body_indices, finger_target_xy=push_start[:2], finger_target_z=contact_z)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_start, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, 80, finger_body_indices=finger_body_indices, finger_target_xy=push_start[:2], finger_target_z=contact_z)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_mid, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.post_push_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=push_mid[:2], finger_target_z=contact_z)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_end, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.post_push_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=push_end[:2], finger_target_z=contact_z)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_end, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 80)


def run_closed_drag_recovery(
    env,
    robot,
    ik_ctrl,
    arm_ids,
    gripper_ids,
    default_jpos,
    frames,
    camera,
    obj,
    quat_w,
    finger_body_indices: tuple[int, int] | None,
) -> None:
    cur = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
    drag_z = TABLE_TOP_Z + max(args_cli.post_push_z, 0.025)
    # Keep the gripper closed and continue from the current contact region.
    # The intermediate target stays slightly behind the basket center so the
    # object is swept into the success box instead of being abandoned early.
    drag_start = np.array([cur[0], cur[1], drag_z], dtype=np.float64)
    drag_mid = np.array([BASKET_CENTER_X, (cur[1] + BASKET_CENTER_Y) * 0.5, drag_z], dtype=np.float64)
    drag_end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y, drag_z], dtype=np.float64)
    print(
        f"[CLOSED_DRAG] cur=({cur[0]:.3f},{cur[1]:.3f},{cur[2]:.3f}) "
        f"start=({drag_start[0]:.3f},{drag_start[1]:.3f},{drag_start[2]:.3f}) "
        f"mid=({drag_mid[0]:.3f},{drag_mid[1]:.3f},{drag_mid[2]:.3f}) "
        f"end=({drag_end[0]:.3f},{drag_end[1]:.3f},{drag_end[2]:.3f})"
    )
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_start, quat_w, GRIPPER_CLOSE_POS, frames, camera, 120, finger_body_indices=finger_body_indices, finger_target_xy=drag_start[:2], finger_target_z=drag_z)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_mid, quat_w, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.drag_recovery_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=drag_mid[:2], finger_target_z=drag_z)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_end, quat_w, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.drag_recovery_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=drag_end[:2], finger_target_z=drag_z)


def main() -> None:
    env = build_env()
    dev = env.unwrapped.device
    env.reset()

    robot = env.unwrapped.scene.articulations["robot"]
    robot.write_joint_state_to_sim(robot.data.default_joint_pos, torch.zeros_like(robot.data.default_joint_vel))
    default_jpos = robot.data.default_joint_pos.clone()
    arm_ids, _ = robot.find_joints(ARM_JOINT_NAMES)
    gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES)
    link7_ids, _ = robot.find_bodies("link7")
    link8_ids, _ = robot.find_bodies("link8")
    finger_body_indices = None
    if len(link7_ids) > 0 and len(link8_ids) > 0:
        finger_body_indices = (int(link7_ids[0]), int(link8_ids[0]))
    camera = env.unwrapped.scene["video_cam"]

    ik_ctrl = CartesianController(
        robot=robot,
        ee_body_name=EE_BODY_NAME,
        arm_joint_names=ARM_JOINT_NAMES,
        num_envs=1,
        device=dev,
        command_type="pose",
        lambda_val=0.05,
        max_joint_delta=0.18,
    )
    ik_ctrl.reset()

    frames: list[np.ndarray] = []
    home = np.array([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], dtype=np.float64)
    topdown_quat = np.asarray(DEFAULT_PLACE_QUAT_W, dtype=np.float64)
    for _ in range(2):
        step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, home, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 80)

    obj = env.unwrapped.scene.rigid_objects[f"object_{args_cli.object}"]
    obj_initial = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)

    rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
    debug_dir = Path(args_cli.save_debug_npz).with_suffix("")
    if args_cli.mask_provider == "band":
        mask = rgbd_band_object_mask(camera, args_cli.object)
    elif args_cli.mask_provider == "sam3":
        mask = sam3_object_mask(camera, rgb, args_cli.object, debug_dir)
    else:
        mask = oracle_object_mask(env, camera, args_cli.object)
    Path(args_cli.save_debug_npz).parent.mkdir(parents=True, exist_ok=True)
    np.savez_compressed(
        args_cli.save_debug_npz,
        rgb=rgb,
        depth=depth,
        mask=mask,
        K=K,
        camera_pos_w=pos_w,
        camera_quat_wxyz_ros=quat_wxyz_ros,
        object_initial=obj_initial,
    )
    if args_cli.grasp_provider == "anygrasp":
        grasp = infer_anygrasp_from_camera(camera, mask)
    elif args_cli.grasp_provider == "pca":
        grasp = infer_pca_aabb_from_camera(camera, mask, object_index=args_cli.object)
    else:
        grasp = infer_grasp_from_camera(camera, mask)
    print(
        f"[GRASP] provider={args_cli.grasp_provider} obj={args_cli.object} "
        f"score={grasp.score:.4f} width={grasp.width:.4f} "
        f"t_w=({grasp.translation_w[0]:.3f},{grasp.translation_w[1]:.3f},{grasp.translation_w[2]:.3f})"
    )

    pick_xy = grasp.translation_w[:2].copy()
    if not args_cli.no_object_offset:
        pick_xy += np.asarray(OBJ_GRASP_CENTER_OFFSETS.get(args_cli.object, (0.0, 0.0, 0.0))[:2], dtype=np.float64)
    grasp_z = max(float(grasp.translation_w[2] + args_cli.tcp_z_offset), TABLE_TOP_Z + 0.055)
    close_offset = (
        GRASPNET_CLOSE_Z_DEFAULTS.get(
            args_cli.object,
            OBJ_CLOSE_Z_OFFSETS.get(args_cli.object, OBJ_GRASP_Z_OFFSETS.get(args_cli.object, args_cli.tcp_z_offset)),
        )
        if args_cli.close_z_offset is None
        else args_cli.close_z_offset
    )
    close_z = max(float(obj_initial[2] + close_offset), TABLE_TOP_Z + 0.030)
    if args_cli.force_default_quat:
        grasp_quat = topdown_quat
    elif args_cli.use_task_quat:
        grasp_quat = compute_grasp_quat(obj.data.root_quat_w[0], dev).detach().cpu().numpy().astype(np.float64)
    else:
        grasp_quat = grasp.quat_wxyz_w
    pre = np.array([pick_xy[0], pick_xy[1], TABLE_TOP_Z + args_cli.pregrasp_z], dtype=np.float64)
    reach = np.array([pick_xy[0], pick_xy[1], grasp_z], dtype=np.float64)
    close = np.array([pick_xy[0], pick_xy[1], close_z], dtype=np.float64)
    lift = np.array([pick_xy[0], pick_xy[1], TABLE_TOP_Z + args_cli.lift_z], dtype=np.float64)
    place = np.array(
        [BASKET_CENTER_X + args_cli.place_x_offset, BASKET_CENTER_Y + args_cli.place_y_offset, TABLE_TOP_Z + args_cli.place_z],
        dtype=np.float64,
    )
    release = np.array(
        [BASKET_CENTER_X + args_cli.place_x_offset, BASKET_CENTER_Y + args_cli.place_y_offset, TABLE_TOP_Z + args_cli.release_z],
        dtype=np.float64,
    )
    open_release = release.copy()
    if args_cli.open_release_z is not None:
        open_release[2] = TABLE_TOP_Z + float(args_cli.open_release_z)
    basket_target_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64)
    transport_steps = args_cli.transport_steps if args_cli.transport_steps is not None else args_cli.move_steps
    place_steps = args_cli.place_steps if args_cli.place_steps is not None else args_cli.move_steps
    print(
        f"[PLAN] pick=({pick_xy[0]:.3f},{pick_xy[1]:.3f}) "
        f"reach_z={reach[2]:.3f} close_z={close[2]:.3f} lift_z={lift[2]:.3f} "
        f"place=({place[0]:.3f},{place[1]:.3f},{place[2]:.3f}) "
        f"release=({release[0]:.3f},{release[1]:.3f},{release[2]:.3f}) "
        f"open_release=({open_release[0]:.3f},{open_release[1]:.3f},{open_release[2]:.3f}) "
        f"transport_steps={transport_steps} place_steps={place_steps} "
        f"quat=({grasp_quat[0]:.3f},{grasp_quat[1]:.3f},{grasp_quat[2]:.3f},{grasp_quat[3]:.3f})"
    )

    servo_center_xy = pick_xy.astype(np.float64)
    close_servo_xy = servo_center_xy.copy()
    if args_cli.preclose_insert_steps > 0:
        close_servo_xy = close_servo_xy + np.array(
            [args_cli.preclose_insert_dx, args_cli.preclose_insert_dy],
            dtype=np.float64,
        )
        print(
            f"[PRECLOSE_INSERT] steps={args_cli.preclose_insert_steps} "
            f"finger_target=({close_servo_xy[0]:.3f},{close_servo_xy[1]:.3f}) "
            f"offset=({args_cli.preclose_insert_dx:+.3f},{args_cli.preclose_insert_dy:+.3f})"
        )
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, pre, grasp_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.move_steps)
    reach_stats = step_pose(
        env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, reach, grasp_quat, GRIPPER_OPEN_POS,
        frames, camera, args_cli.move_steps, obj_idx=args_cli.object, obj=obj,
        finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy,
    )
    insert_stats = None
    if args_cli.preclose_insert_steps > 0:
        insert_stats = step_pose(
            env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, close, grasp_quat, GRIPPER_OPEN_POS,
            frames, camera, args_cli.preclose_insert_steps, obj_idx=args_cli.object, obj=obj,
            finger_body_indices=finger_body_indices, finger_target_xy=close_servo_xy,
            finger_target_z=close[2], finger_servo_gain=1.0,
            finger_servo_max_xy=0.16, finger_servo_max_z=0.04,
        )
    close_stats = step_pose(
        env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, close, grasp_quat, GRIPPER_CLOSE_POS,
        frames, camera, args_cli.close_steps, obj_idx=args_cli.object, obj=obj,
        finger_body_indices=finger_body_indices, servo_center_xy=close_servo_xy,
    )
    z_gain_close = object_z_gain(env, args_cli.object, float(obj_initial[2]))
    lift_stats = step_pose(
        env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, lift, grasp_quat, GRIPPER_CLOSE_POS,
        frames, camera, args_cli.move_steps, obj_idx=args_cli.object, obj=obj,
        finger_body_indices=finger_body_indices, servo_center_xy=close_servo_xy,
    )
    z_gain_lift = object_z_gain(env, args_cli.object, float(obj_initial[2]))
    place_quat = grasp_quat if args_cli.object in (1, 2) else topdown_quat
    place_servo_xy = basket_target_xy if args_cli.basket_center_release else None
    release_stable = True
    if args_cli.staged_transport and transport_steps >= 3:
        servo_steps = int(round(transport_steps * max(0.0, min(1.0, args_cli.transport_servo_fraction))))
        servo_steps = min(max(servo_steps, 1 if place_servo_xy is not None else 0), max(transport_steps - 2, 0))
        carry_steps = max(transport_steps - servo_steps, 2)
        first_steps = max(carry_steps // 2, 1)
        second_steps = max(carry_steps - first_steps, 1)
        mid = np.array(
            [
                (lift[0] + release[0]) * 0.5,
                (lift[1] + release[1]) * 0.5,
                max(lift[2], release[2]),
            ],
            dtype=np.float64,
        )
        print(
            f"[TRANSPORT] staged first={first_steps} second={second_steps} servo={servo_steps} "
            f"mid=({mid[0]:.3f},{mid[1]:.3f},{mid[2]:.3f})"
        )
        step_pose(
            env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, mid, place_quat, GRIPPER_CLOSE_POS,
            frames, camera, first_steps, obj_idx=args_cli.object, obj=obj,
            finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy,
            servo_current_object_xy=args_cli.dynamic_finger_servo,
        )
        step_pose(
            env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS,
            frames, camera, second_steps, obj_idx=args_cli.object, obj=obj,
            finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy,
            servo_current_object_xy=args_cli.dynamic_finger_servo,
        )
        if servo_steps > 0:
            step_pose(
                env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS,
                frames, camera, servo_steps, obj_idx=args_cli.object, obj=obj,
                finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy,
                servo_current_object_xy=args_cli.dynamic_finger_servo,
                object_target_xy=place_servo_xy,
                object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy,
            )
    else:
        step_pose(
            env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS,
            frames, camera, transport_steps, obj_idx=args_cli.object, obj=obj,
            finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy,
            servo_current_object_xy=args_cli.dynamic_finger_servo,
            object_target_xy=place_servo_xy,
            object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy,
        )
    transport_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
    transport_xy_err = float(np.linalg.norm(transport_pos[:2] - basket_target_xy))
    print(
        f"[TRANSPORT_END] obj=({transport_pos[0]:.3f},{transport_pos[1]:.3f},{transport_pos[2]:.3f}) "
        f"xy_err={transport_xy_err:.3f} lifted_z_gain={transport_pos[2] - obj_initial[2]:.3f}"
    )
    hold_stats = None
    if place_servo_xy is not None:
        hold_stats = step_until_object_center_stable(
            env,
            robot,
            ik_ctrl,
            arm_ids,
            gripper_ids,
            default_jpos,
            release,
            place_quat,
            GRIPPER_CLOSE_POS,
            frames,
            camera,
            obj=obj,
            target_xy=place_servo_xy,
            xy_tol=args_cli.basket_xy_tol,
            stable_steps=args_cli.basket_stable_steps,
            max_steps=args_cli.basket_hold_steps,
            object_servo_gain=args_cli.basket_servo_gain,
            object_servo_max_xy=args_cli.basket_servo_max_xy,
            obj_idx=args_cli.object,
            finger_body_indices=finger_body_indices,
            servo_center_xy=servo_center_xy,
            servo_current_object_xy=args_cli.dynamic_finger_servo,
        )
        print(f"[BASKET_HOLD] {hold_stats}")
        if int(hold_stats["stable"]) < args_cli.basket_stable_steps:
            print("[BASKET_HOLD] not stable; keeping gripper closed and running recovery servo before release")
            hold_stats = step_until_object_center_stable(
                env,
                robot,
                ik_ctrl,
                arm_ids,
                gripper_ids,
                default_jpos,
                place,
                place_quat,
                GRIPPER_CLOSE_POS,
                frames,
                camera,
                obj=obj,
                target_xy=place_servo_xy,
                xy_tol=args_cli.basket_xy_tol,
                stable_steps=args_cli.basket_stable_steps,
                max_steps=args_cli.basket_recovery_steps,
                object_servo_gain=args_cli.basket_servo_gain,
                object_servo_max_xy=args_cli.basket_servo_max_xy,
                obj_idx=args_cli.object,
                finger_body_indices=finger_body_indices,
                servo_center_xy=servo_center_xy,
                servo_current_object_xy=args_cli.dynamic_finger_servo,
            )
            print(f"[BASKET_RECOVERY] {hold_stats}")
        if int(hold_stats["stable"]) < args_cli.basket_stable_steps:
            print("[BASKET_HOLD] still not stable; skipping open release to avoid early drop")
            place_steps = 0
            release_stable = False
    open_target = open_release if args_cli.open_release_z is not None else release
    if args_cli.open_release_z is not None:
        step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_CLOSE_POS, frames, camera, 120)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_CLOSE_POS, frames, camera, 60)
    if place_steps > 0:
        step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_OPEN_POS, frames, camera, place_steps)
    slipped_to_table = float(obj.data.root_pos_w[0, 2].item()) <= TABLE_TOP_Z + 0.08
    need_push = not check_objects_in_basket(env, [args_cli.object]) and (
        args_cli.post_push or (args_cli.auto_table_push_on_slip and (slipped_to_table or not release_stable))
    )
    if need_push:
        run_closed_drag_recovery(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, place_quat, finger_body_indices)
        if not check_objects_in_basket(env, [args_cli.object]):
            run_table_push_recovery(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, topdown_quat, finger_body_indices)
    step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, home, topdown_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.settle_steps)

    final_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
    inside = check_objects_in_basket(env, [args_cli.object])
    print(
        f"[RESULT] obj={args_cli.object} inside={inside} "
        f"z_gain_close={z_gain_close:.3f} z_gain_lift={z_gain_lift:.3f} "
        f"final=({final_pos[0]:.3f},{final_pos[1]:.3f},{final_pos[2]:.3f})"
    )
    print(f"[TRACE] reach={reach_stats} insert={insert_stats} close={close_stats} lift={lift_stats}")
    for line in basket_status_lines(env, [args_cli.object]):
        print(f"[BASKET] {line}")

    video_path = Path(args_cli.video_path)
    video_path.parent.mkdir(parents=True, exist_ok=True)
    if frames:
        imageio.mimwrite(str(video_path), frames, fps=50, quality=7)
        print(f"[VIDEO] {video_path.resolve()}")
    env.close()


if __name__ == "__main__":
    try:
        main()
    finally:
        simulation_app.close()