demo/solution_pca.py

"""Observation-only GraspGen-style PCA/AABB controller for ATEC Task E.

This is an experimental submit-style policy: it uses only proprioception plus
the fixed external RGB-D camera observation to estimate object centres, then
drives a calibrated Piper pick/place primitive with local kinematics.
"""

from __future__ import annotations

import os
from dataclasses import dataclass

import numpy as np
import torch

try:
    import pinocchio as pin
except Exception:  # pragma: no cover - handled at runtime by the judge/server
    pin = None


TABLE_CENTER_X = 1.00
TABLE_CENTER_Y = 0.00
TABLE_DIMS_AT_0P008 = (0.6468062441005529, 0.9084968693231588, 0.6613141183247961)
TABLE_SCALE = 0.01
TABLE_DIMS = tuple(dim * (TABLE_SCALE / 0.008) for dim in TABLE_DIMS_AT_0P008)
TABLE_HALF_X = TABLE_DIMS[0] * 0.5
TABLE_TOP_Z = TABLE_DIMS[2]
BASKET_CENTER_X = TABLE_CENTER_X + 0.08
BASKET_CENTER_Y = TABLE_CENTER_Y - 0.30

DEFAULT_Q = np.array([0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035], dtype=np.float64)
HOME_Q = np.array([-0.000033, 0.924525, -1.514983, 0.000011, 1.219900, -0.000033, 0.035, -0.035], dtype=np.float64)
ACTION_SCALE = 0.5
GRIP_OPEN = np.array([0.035, -0.035], dtype=np.float64)
GRIP_HALF = np.array([0.018, -0.018], dtype=np.float64)
GRIP_CLOSE = np.array([0.0, 0.0], dtype=np.float64)
OBJ1_HOLD_GAP = 0.0415
OBJ3_HOLD_GAP = float(os.environ.get("ATEC_PCA_OBJ3_HOLD_GAP", "0.0675"))
OBJ3_CLOSE_MIN_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_CLOSE_MIN_STEPS", "160"))
OBJ3_LOW_HOLD_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_LOW_HOLD_STEPS", "0"))
OBJ3_LIFT_CLEARANCE = float(os.environ.get("ATEC_PCA_OBJ3_LIFT_CLEARANCE", "0.12"))
OBJ3_CARRY_CLEARANCE = float(os.environ.get("ATEC_PCA_OBJ3_CARRY_CLEARANCE", "0.145"))
OBJ3_OBJECT_SERVO_GAIN = float(os.environ.get("ATEC_PCA_OBJ3_OBJECT_SERVO_GAIN", "1.0"))
OBJ3_OBJECT_SERVO_MAX_XY = float(os.environ.get("ATEC_PCA_OBJ3_OBJECT_SERVO_MAX_XY", "0.300"))
OBJ3_FINGER_SERVO_MAX_XY = float(os.environ.get("ATEC_PCA_OBJ3_FINGER_SERVO_MAX_XY", "0.240"))
OBJ3_APPROACH_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_APPROACH_FINGER_Z", str(TABLE_TOP_Z + 0.090)))
OBJ3_CLOSE_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_CLOSE_FINGER_Z", str(TABLE_TOP_Z + 0.000)))
OBJ3_LIFT_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_LIFT_FINGER_Z", str(TABLE_TOP_Z + 0.045)))
OBJ3_ENABLE_INSERT = os.environ.get("ATEC_PCA_OBJ3_ENABLE_INSERT", "0") != "0"
OBJ3_PREGRASP_OFFSET = np.array(
    [
        float(os.environ.get("ATEC_PCA_OBJ3_PREGRASP_X_OFFSET", "0.000")),
        float(os.environ.get("ATEC_PCA_OBJ3_PREGRASP_Y_OFFSET", "0.080")),
    ],
    dtype=np.float64,
)
OBJ3_SIDE_APPROACH_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_SIDE_APPROACH_STEPS", "160"))
OBJ3_SIDE_LOW_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_SIDE_LOW_STEPS", "140"))
OBJ3_INSERT_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_INSERT_STEPS", "220"))
OBJ3_PREGRASP_LOW_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_PREGRASP_LOW_FINGER_Z", str(TABLE_TOP_Z + 0.024)))
OBJ3_FALLBACK_DRAG_Z = float(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_DRAG_Z", str(TABLE_TOP_Z + 0.035)))
OBJ3_FALLBACK_START_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_START_STEPS", "60"))
OBJ3_FALLBACK_MID_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_MID_STEPS", "260"))
OBJ3_FALLBACK_END_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_END_STEPS", "260"))
OBJ3_FALLBACK_OPEN_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_OPEN_STEPS", "100"))
OBJ3_DRAG_START_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_START_STEPS", "80"))
OBJ3_DRAG_MID_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_MID_STEPS", "360"))
OBJ3_DRAG_END_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_END_STEPS", "360"))
OBJ3_DRAG_SETTLE_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_SETTLE_STEPS", "120"))
PCA_DLS_MAX_DELTA = float(os.environ.get("ATEC_PCA_DLS_MAX_DELTA", "0.18"))
PCA_FINGER_IK_MAX_DELTA = float(os.environ.get("ATEC_PCA_FINGER_IK_MAX_DELTA", "0.18"))
OBJ3_GRIPPER_MAX_DELTA = float(os.environ.get("ATEC_PCA_OBJ3_GRIPPER_MAX_DELTA", "0.003"))
OBJ3_HOLD_GRIP_DEFAULT = np.array(
    [
        float(os.environ.get("ATEC_PCA_OBJ3_HOLD_Q_POS", "0.0000")),
        float(os.environ.get("ATEC_PCA_OBJ3_HOLD_Q_NEG", "0.0000")),
    ],
    dtype=np.float64,
)

BASE_POS_W = np.array([TABLE_CENTER_X + TABLE_HALF_X, TABLE_CENTER_Y, TABLE_TOP_Z], dtype=np.float64)
R_W_B = np.diag([-1.0, -1.0, 1.0])
K_VIDEO = np.array([[732.99927, 0.0, 320.0], [0.0, 732.99927, 240.0], [0.0, 0.0, 1.0]], dtype=np.float64)
CAM_POS_W = np.array([-0.2, 0.0, 1.6266427], dtype=np.float64)
CAM_QUAT_WXYZ = np.array([-0.33350849, 0.62351596, -0.62351584, 0.33350849], dtype=np.float64)

OBJ_Y_BANDS = {
    1: (TABLE_CENTER_Y + 0.25, TABLE_CENTER_Y + 0.29),
    2: (TABLE_CENTER_Y + 0.14, TABLE_CENTER_Y + 0.20),
    3: (TABLE_CENTER_Y + 0.03, TABLE_CENTER_Y + 0.09),
}
OBJ_Z_LIMITS = {
    1: (TABLE_TOP_Z + 0.035, TABLE_TOP_Z + 0.130),
    2: (TABLE_TOP_Z + 0.020, TABLE_TOP_Z + 0.190),
    3: (TABLE_TOP_Z + 0.012, TABLE_TOP_Z + 0.095),
}
OBJ_GRASP_CENTER_OFFSETS = {
    1: np.array([0.0, 0.0], dtype=np.float64),
    2: np.array([0.060, 0.0], dtype=np.float64),
    3: np.array([float(os.environ.get("ATEC_PCA_OBJ3_X_OFFSET", "0.0")), 0.0], dtype=np.float64),
}
OBJ_CENTER_COMPLETION_OFFSETS = {
    # The fixed camera sees object_1 from the lower-y side when it is near the
    # top band edge; RGB-D AABB/median centres land on the visible side instead
    # of the root/contact centre.  This completes the centre before applying
    # the Piper finger offset below.
    1: np.array([0.020, 0.0], dtype=np.float64),
    2: np.array([0.0, 0.0], dtype=np.float64),
    3: np.array(
        [
            0.0,
            float(os.environ.get("ATEC_PCA_OBJ3_CENTER_Y_OFFSET", "0.000")),
        ],
        dtype=np.float64,
    ),
}
OBJ_TCP_Z = {1: 0.140, 2: 0.040, 3: 0.090}
OBJ_CLOSE_Z_OFFSETS = {1: 0.020, 2: 0.020, 3: float(os.environ.get("ATEC_PCA_OBJ3_CLOSE_Z_OFFSET", "-0.005"))}
OBJ_CLOSE_Z = {
    1: TABLE_TOP_Z + 0.030,  # low close plane; compensate submit IK's high-contact bias
    2: TABLE_TOP_Z + 0.030,
    3: TABLE_TOP_Z + 0.030,
}
OBJ_ROOT_Z_EST = {
    1: TABLE_TOP_Z + 0.045,
    2: TABLE_TOP_Z + 0.055,
    3: TABLE_TOP_Z + 0.035,
}
OBJ_PRECLOSE_INSERT_OFFSETS = {
    1: np.array([0.0, 0.0], dtype=np.float64),
}
OBJ_FINGER_XY_OFFSETS = {
    # Calibrated from successful 2026-05-20 scripted traces.  Banana succeeds
    # when the actual link7/link8 centre is slightly on the -X side of the
    # object root, cradling the curve instead of pushing from the +X side.
    3: np.array(
        [
            float(os.environ.get("ATEC_PCA_OBJ3_FINGER_X_OFFSET", "-0.010")),
            float(os.environ.get("ATEC_PCA_OBJ3_FINGER_Y_OFFSET", "0.000")),
        ],
        dtype=np.float64,
    ),
}
OBJ_FINGER_TARGET_REL_Z = {
    1: -0.025,
    3: float(os.environ.get("ATEC_PCA_OBJ3_FINGER_REL_Z", "0.027")),
}
OBJ_FINGER_SERVO_MAX_Z = {1: 0.050, 3: 0.040}
OBJ_REACH_STEPS = {1: 200, 2: 200, 3: 200}
OBJ_CLOSE_STEPS = {1: 220, 2: 180, 3: int(os.environ.get("ATEC_PCA_OBJ3_CLOSE_STEPS", "90"))}
OBJ_LIFT_STEPS = {1: 300, 2: 200, 3: int(os.environ.get("ATEC_PCA_OBJ3_LIFT_STEPS", "35"))}
OBJ_TRANSPORT_STEPS = {1: 1400, 2: 1400, 3: int(os.environ.get("ATEC_PCA_OBJ3_TRANSPORT_STEPS", "440"))}
OBJ_PLACE_STEPS = {1: 260, 2: 260, 3: 220}
OBJ_OPEN_STEPS = {1: 260, 2: 260, 3: 220}
OBJ_PLACE_XY_OFFSETS = {
    1: np.array([0.0, 0.0], dtype=np.float64),
    3: np.array(
        [
            float(os.environ.get("ATEC_PCA_OBJ3_PLACE_X_OFFSET", "0.0")),
            float(os.environ.get("ATEC_PCA_OBJ3_PLACE_Y_OFFSET", "0.0")),
        ],
        dtype=np.float64,
    ),
}


def _quat_wxyz_to_rot(q: np.ndarray) -> np.ndarray:
    q = np.asarray(q, dtype=np.float64)
    q = q / max(np.linalg.norm(q), 1e-12)
    w, x, y, z = q
    return np.array(
        [
            [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
            [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
            [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)],
        ],
        dtype=np.float64,
    )


def _rot_error(current: np.ndarray, target: np.ndarray) -> np.ndarray:
    err = target @ current.T
    return 0.5 * np.array(
        [err[2, 1] - err[1, 2], err[0, 2] - err[2, 0], err[1, 0] - err[0, 1]],
        dtype=np.float64,
    )


def _world_to_base_pos(pos_w: np.ndarray) -> np.ndarray:
    return R_W_B.T @ (np.asarray(pos_w, dtype=np.float64) - BASE_POS_W)


def _world_to_base_rot(rot_w: np.ndarray) -> np.ndarray:
    return R_W_B.T @ rot_w


@dataclass
class PoseTarget:
    pos_w: np.ndarray
    rot_w: np.ndarray
    grip: np.ndarray
    steps: int
    finger_xy: np.ndarray | None = None
    finger_z: float | None = None
    servo_obj_z: float | None = None
    servo_target_rel_z: float | None = None
    freeze_arm: bool = False
    label: str = ""


class _PiperIK:
    def __init__(self):
        if pin is None:
            raise RuntimeError("pinocchio is required for solution_pca.py")
        root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        urdf = os.path.join(root, "third_party", "Agilex-College", "piper", "handpose_det", "models", "modified_piper_without_camera.urdf")
        if not os.path.exists(urdf):
            urdf = os.environ.get("ATEC_PIPER_URDF", urdf)
        self.model = pin.buildModelFromUrdf(urdf)
        self.data = self.model.createData()
        self.frame_id = self.model.getFrameId("gripper_base")
        self.link7_id = self.model.getFrameId("link7")
        self.link8_id = self.model.getFrameId("link8")
        self._last_q = HOME_Q[:6].copy()

    def fk_base(self, q6: np.ndarray):
        q = np.concatenate([np.asarray(q6, dtype=np.float64), GRIP_OPEN])
        pin.forwardKinematics(self.model, self.data, q)
        pin.updateFramePlacements(self.model, self.data)
        M = self.data.oMf[self.frame_id]
        return M.translation.copy(), M.rotation.copy()

    def solve(self, q_current8: np.ndarray, pos_w: np.ndarray, rot_w: np.ndarray) -> np.ndarray:
        target_pos_b = _world_to_base_pos(pos_w)
        target_rot_b = _world_to_base_rot(rot_w)
        q6 = np.asarray(q_current8[:6], dtype=np.float64).copy()
        if not np.all(np.isfinite(q6)):
            q6 = self._last_q.copy()
        for _ in range(35):
            pos_b, rot_b = self.fk_base(q6)
            err = np.concatenate([target_pos_b - pos_b, _rot_error(rot_b, target_rot_b)])
            if np.linalg.norm(err[:3]) < 0.003 and np.linalg.norm(err[3:]) < 0.03:
                break
            J = pin.computeFrameJacobian(
                self.model,
                self.data,
                np.concatenate([q6, GRIP_OPEN]),
                self.frame_id,
                pin.ReferenceFrame.LOCAL_WORLD_ALIGNED,
            )[:, :6]
            damping = 0.020
            dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(6), err)
            dq = np.clip(dq, -0.20, 0.20)
            q6 = np.clip(q6 + dq, [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944], [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944])
        # Near contact, being centimetres high is worse than a small wrist
        # orientation error.  The successful simulator runner effectively
        # servos the link7/link8 centre every step; this position-only cleanup
        # gives the submit-style IK the same priority.
        for _ in range(20):
            pos_b, _ = self.fk_base(q6)
            pos_err = target_pos_b - pos_b
            if np.linalg.norm(pos_err) < 0.002:
                break
            J = pin.computeFrameJacobian(
                self.model,
                self.data,
                np.concatenate([q6, GRIP_OPEN]),
                self.frame_id,
                pin.ReferenceFrame.LOCAL_WORLD_ALIGNED,
            )[:3, :6]
            damping = 0.012
            dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(3), pos_err)
            dq = np.clip(dq, -0.18, 0.18)
            q6 = np.clip(q6 + dq, [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944], [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944])
        self._last_q = q6.copy()
        return q6

    def step_dls(
        self,
        q_current8: np.ndarray,
        pos_w: np.ndarray,
        rot_w: np.ndarray,
        *,
        lambda_val: float = 0.05,
        max_joint_delta: float = PCA_DLS_MAX_DELTA,
        position_only: bool = False,
    ) -> np.ndarray:
        """One DifferentialIK-style DLS update from the current joint state.

        The successful simulator runner uses IsaacLab's CartesianController,
        which computes a small damped least-squares update from the current
        PhysX state on every frame.  This mirrors that behavior more closely
        than solving a full IK target and then clipping the final joint target.
        """
        target_pos_b = _world_to_base_pos(pos_w)
        target_rot_b = _world_to_base_rot(rot_w)
        q6 = np.asarray(q_current8[:6], dtype=np.float64).copy()
        if not np.all(np.isfinite(q6)):
            q6 = self._last_q.copy()
        q8 = np.concatenate([q6, GRIP_OPEN])
        pos_b, rot_b = self.fk_base(q6)
        J_full = pin.computeFrameJacobian(
            self.model,
            self.data,
            q8,
            self.frame_id,
            pin.ReferenceFrame.LOCAL_WORLD_ALIGNED,
        )[:, :6]
        if position_only:
            err = target_pos_b - pos_b
            J = J_full[:3, :]
        else:
            err = np.concatenate([target_pos_b - pos_b, _rot_error(rot_b, target_rot_b)])
            J = J_full
        damping = float(lambda_val)
        dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(J.shape[0]), err)
        dq = np.clip(dq, -max_joint_delta, max_joint_delta)
        q6 = np.clip(
            q6 + dq,
            [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944],
            [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944],
        )
        self._last_q = q6.copy()
        return q6

    def finger_center_world(self, q_current8: np.ndarray) -> np.ndarray:
        q = np.asarray(q_current8, dtype=np.float64).copy()
        pin.forwardKinematics(self.model, self.data, q)
        pin.updateFramePlacements(self.model, self.data)
        p7 = self.data.oMf[self.link7_id].translation
        p8 = self.data.oMf[self.link8_id].translation
        center_b = 0.5 * (p7 + p8)
        return BASE_POS_W + R_W_B @ center_b

    def finger_gap(self, q_current8: np.ndarray) -> float:
        q = np.asarray(q_current8, dtype=np.float64).copy()
        pin.forwardKinematics(self.model, self.data, q)
        pin.updateFramePlacements(self.model, self.data)
        p7 = self.data.oMf[self.link7_id].translation
        p8 = self.data.oMf[self.link8_id].translation
        return float(np.linalg.norm(p7 - p8))

    def solve_finger(self, q_current8: np.ndarray, finger_w: np.ndarray, rot_w: np.ndarray) -> np.ndarray:
        """IK on the actual link7/link8 centre, not the gripper_base proxy."""
        target_pos_b = _world_to_base_pos(finger_w)
        target_rot_b = _world_to_base_rot(rot_w)
        q_current8 = np.asarray(q_current8, dtype=np.float64).copy()
        q6 = q_current8[:6].copy()
        grip = q_current8[6:8].copy()
        if not np.all(np.isfinite(q6)):
            q6 = self._last_q.copy()
        for _ in range(40):
            q8 = np.concatenate([q6, grip])
            pin.forwardKinematics(self.model, self.data, q8)
            pin.updateFramePlacements(self.model, self.data)
            p7 = self.data.oMf[self.link7_id].translation
            p8 = self.data.oMf[self.link8_id].translation
            center_b = 0.5 * (p7 + p8)
            gb_rot = self.data.oMf[self.frame_id].rotation
            pos_err = target_pos_b - center_b
            rot_err = _rot_error(gb_rot, target_rot_b)
            if np.linalg.norm(pos_err) < 0.002 and np.linalg.norm(rot_err) < 0.05:
                break
            J7 = pin.computeFrameJacobian(self.model, self.data, q8, self.link7_id, pin.ReferenceFrame.LOCAL_WORLD_ALIGNED)[:3, :6]
            J8 = pin.computeFrameJacobian(self.model, self.data, q8, self.link8_id, pin.ReferenceFrame.LOCAL_WORLD_ALIGNED)[:3, :6]
            Jpos = 0.5 * (J7 + J8)
            Jrot = pin.computeFrameJacobian(self.model, self.data, q8, self.frame_id, pin.ReferenceFrame.LOCAL_WORLD_ALIGNED)[3:, :6]
            rot_wt = 0.05
            J = np.vstack([Jpos, rot_wt * Jrot])
            err = np.concatenate([pos_err, rot_wt * rot_err])
            damping = 0.018
            dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(6), err)
            dq = np.clip(dq, -PCA_FINGER_IK_MAX_DELTA, PCA_FINGER_IK_MAX_DELTA)
            q6 = np.clip(q6 + dq, [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944], [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944])
        self._last_q = q6.copy()
        return q6


class AlgSolution:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.ik = _PiperIK()
        self.reset()

    def reset(self, **_kwargs):
        self.t = 0
        self.home_count = 0
        self.plan: list[PoseTarget] = []
        self.plan_idx = 0
        self.step_in_target = 0
        self.detected = False
        self.fallback_done = False
        self.objects: tuple[int, ...] = ()
        self._last_action = np.zeros(8, dtype=np.float64)
        self._obj1_hold_grip: np.ndarray | None = None
        self._obj3_hold_grip: np.ndarray | None = None
        self._obj3_carry_offset_xy: np.ndarray | None = None
        self._detected_centers: dict[int, np.ndarray] = {}

    def reset_episode(self):
        self.reset()

    def _obs_qpos(self, obs: dict) -> np.ndarray:
        proprio = obs["proprio"]
        if isinstance(proprio, torch.Tensor):
            p = proprio.detach().cpu().numpy()[0]
        else:
            p = np.asarray(proprio)[0]
        return p[:8].astype(np.float64) + DEFAULT_Q

    def _video_rgb_depth(self, obs: dict) -> tuple[np.ndarray, np.ndarray]:
        rgb = obs["image"]["video_rgb"]
        if isinstance(rgb, torch.Tensor):
            rgb_arr = rgb.detach().cpu().numpy()[0]
        else:
            rgb_arr = np.asarray(rgb)[0]
        if rgb_arr.ndim == 3 and rgb_arr.shape[0] in (3, 4):
            rgb_arr = np.transpose(rgb_arr[:3], (1, 2, 0))
        if rgb_arr.shape[-1] == 4:
            rgb_arr = rgb_arr[..., :3]
        if np.issubdtype(rgb_arr.dtype, np.floating):
            rgb_arr = (rgb_arr * 255.0).clip(0, 255).astype(np.uint8)

        depth = obs["image"]["video_depth"]
        if isinstance(depth, torch.Tensor):
            arr = depth.detach().cpu().numpy()[0]
        else:
            arr = np.asarray(depth)[0]
        if arr.ndim == 3:
            arr = arr[..., 0]
        return rgb_arr.astype(np.uint8, copy=False), arr.astype(np.float64)

    def _points_for_object(
        self,
        rgb: np.ndarray,
        depth: np.ndarray,
        obj_idx: int,
        *,
        wide: bool = False,
        fill_holes: bool = True,
    ) -> np.ndarray:
        h, w = depth.shape
        ys, xs = np.where(np.isfinite(depth) & (depth > 0.0) & (depth < 6.0))
        if len(xs) == 0:
            return np.zeros((0, 3), dtype=np.float64)
        z = depth[ys, xs]
        x = (xs.astype(np.float64) - K_VIDEO[0, 2]) / K_VIDEO[0, 0] * z
        y = (ys.astype(np.float64) - K_VIDEO[1, 2]) / K_VIDEO[1, 1] * z
        pts_cam = np.stack([x, y, z], axis=1)
        rot_w_cam = _quat_wxyz_to_rot(CAM_QUAT_WXYZ)
        pts = (rot_w_cam @ pts_cam.T).T + CAM_POS_W
        y0, y1 = OBJ_Y_BANDS[obj_idx]
        if wide:
            y0 = BASKET_CENTER_Y - 0.10
            y1 = OBJ_Y_BANDS[obj_idx][1] + (0.045 if obj_idx == 3 else 0.10)
        z0, z1 = OBJ_Z_LIMITS[obj_idx]
        if wide:
            z0 = TABLE_TOP_Z + 0.005
            if obj_idx == 3:
                z1 = TABLE_TOP_Z + 0.220
        rgb_pts = rgb[ys, xs].astype(np.float32)
        maxc = rgb_pts.max(axis=1)
        minc = rgb_pts.min(axis=1)
        non_gray = ((maxc - minc) > 18.0) | (maxc > 170.0)
        if obj_idx == 3:
            # Use the banana's yellow appearance for dynamic tracking.  The broad
            # world band can include the pink basket, white gripper, and mustard;
            # a simple color gate is more reliable than generic non-gray there.
            r, g, b = rgb_pts[:, 0], rgb_pts[:, 1], rgb_pts[:, 2]
            non_gray = (r > 105.0) & (g > 75.0) & (b < 130.0) & ((r - b) > 35.0)
        keep = (
            (pts[:, 0] >= TABLE_CENTER_X - 0.18)
            & (pts[:, 0] <= TABLE_CENTER_X + 0.18)
            & (pts[:, 1] >= y0 - 0.035)
            & (pts[:, 1] <= y1 + 0.035)
            & (pts[:, 2] >= z0)
            & (pts[:, 2] <= z1)
            & non_gray
        )
        if np.count_nonzero(keep) == 0:
            return pts[keep]
        if not fill_holes:
            return pts[keep]
        # Mirror rgbd_band_object_mask(): fill shallow holes inside the detected
        # component ROI, still constrained by the legal world band and z gate.
        yy = ys[keep]
        xx = xs[keep]
        x1, x2 = int(xx.min()), int(xx.max())
        y1p, y2p = int(yy.min()), int(yy.max())
        in_roi = (xs >= x1) & (xs <= x2) & (ys >= y1p) & (ys <= y2p)
        fill_keep = (
            in_roi
            & (pts[:, 0] >= TABLE_CENTER_X - 0.18)
            & (pts[:, 0] <= TABLE_CENTER_X + 0.18)
            & (pts[:, 1] >= y0 - 0.035)
            & (pts[:, 1] <= y1 + 0.035)
            & (pts[:, 2] >= z0)
            & (pts[:, 2] <= z1)
        )
        return pts[fill_keep]

    def _estimate_grasp(self, rgb: np.ndarray, depth: np.ndarray, obj_idx: int, *, wide: bool = False) -> tuple[np.ndarray, np.ndarray]:
        pts = self._points_for_object(rgb, depth, obj_idx, wide=wide, fill_holes=(obj_idx != 1))
        if len(pts) < 64:
            # Spawn-band fallback keeps the controller alive if one frame is bad.
            y0, y1 = OBJ_Y_BANDS[obj_idx]
            center = np.array([TABLE_CENTER_X, 0.5 * (y0 + y1), TABLE_TOP_Z + 0.06], dtype=np.float64)
            return center, _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
        center = pts.mean(axis=0)
        world_aabb_center = 0.5 * (pts.min(axis=0) + pts.max(axis=0))
        cov = (pts - center).T @ (pts - center) / max(len(pts) - 1, 1)
        vals, vecs = np.linalg.eigh(cov)
        order = np.argsort(vals)[::-1]
        axes = vecs[:, order]
        if np.linalg.det(axes) < 0:
            axes[:, 2] *= -1
        local = (axes.T @ (pts - center).T).T
        mn, mx = local.min(axis=0), local.max(axis=0)
        aabb_center = axes @ ((mn + mx) * 0.5) + center
        extents = mx - mn
        if obj_idx == 3:
            exec_center = aabb_center.copy()
            # The banana is curved; when the visible PCA/AABB centre drifts
            # toward the far end of the crescent, the calibrated -X finger
            # offset is cancelled and the gripper closes on the outside.  In
            # that case the RGB-D point mean is a better proxy for the contact
            # root used by the successful runner traces.
            if abs(float(aabb_center[0] - center[0])) > float(os.environ.get("ATEC_PCA_OBJ3_AABB_MEAN_X_SWITCH", "0.025")):
                exec_center[0] = center[0] + float(os.environ.get("ATEC_PCA_OBJ3_MEAN_X_BIAS", "0.005"))
        else:
            upper = pts[pts[:, 2] >= np.percentile(pts[:, 2], 70)]
            # Object 1/2 visible-surface medians can be biased toward the
            # camera-facing side by 2+ cm.  Use the world AABB centre for XY
            # completion, while keeping a high visible-surface z for approach.
            exec_center = world_aabb_center.copy()
            z_src = upper if len(upper) else pts
            exec_center[2] = float(np.percentile(z_src[:, 2], 85))
        if os.environ.get("ATEC_PCA_DEBUG_TARGET"):
            upper = pts[pts[:, 2] >= np.percentile(pts[:, 2], 70)]
            upper_med = np.median(upper if len(upper) else pts, axis=0)
            print(
                f"[PCA_EST] obj={obj_idx} n={len(pts)} "
                f"mean=({center[0]:.3f},{center[1]:.3f},{center[2]:.3f}) "
                f"world_aabb=({world_aabb_center[0]:.3f},{world_aabb_center[1]:.3f},{world_aabb_center[2]:.3f}) "
                f"upper_med=({upper_med[0]:.3f},{upper_med[1]:.3f},{upper_med[2]:.3f}) "
                f"exec=({exec_center[0]:.3f},{exec_center[1]:.3f},{exec_center[2]:.3f})",
                flush=True,
            )

        grasp_axis = int(np.argmin(extents))
        if grasp_axis == 0:
            jaw_hint_w = axes[:, 1]
        else:
            jaw_hint_w = axes[:, 0]
        jaw_xy = np.array([jaw_hint_w[0], jaw_hint_w[1], 0.0], dtype=np.float64)
        if np.linalg.norm(jaw_xy) < 1e-6:
            jaw_xy = np.array([0.0, 1.0, 0.0], dtype=np.float64)
        jaw_xy /= np.linalg.norm(jaw_xy)
        grip_z = np.array([0.0, 0.0, -1.0], dtype=np.float64)
        align_x = np.cross(jaw_xy, grip_z)
        align_x /= max(np.linalg.norm(align_x), 1e-6)
        jaw_y = np.cross(grip_z, align_x)
        jaw_y /= max(np.linalg.norm(jaw_y), 1e-6)
        rot_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1)
        return exec_center.astype(np.float64), rot_w_tool.astype(np.float64)

    def _estimate_object3_current_center(self, obs: dict) -> np.ndarray | None:
        rgb, depth = self._video_rgb_depth(obs)
        pts = self._points_for_object(rgb, depth, 3, wide=True, fill_holes=True)
        if len(pts) < 64:
            return None
        center = 0.5 * (pts.min(axis=0) + pts.max(axis=0))
        # Track the table-near/lifted banana body, not high gripper occluders.
        center[2] = float(np.percentile(pts[:, 2], 65))
        center[:2] += OBJ_CENTER_COMPLETION_OFFSETS[3]
        if not np.all(np.isfinite(center)):
            return None
        if not (TABLE_CENTER_X - 0.22 <= center[0] <= TABLE_CENTER_X + 0.22):
            return None
        if not (BASKET_CENTER_Y - 0.14 <= center[1] <= OBJ_Y_BANDS[3][1] + 0.10):
            return None
        return center.astype(np.float64)

    def _build_object3_drag_fallback(self, obs: dict) -> bool:
        topdown = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
        # Re-localize the banana at fallback time.  Use the same narrow
        # closed-drag recovery that succeeded in run_graspnet_pick.py: keep the
        # gripper closed and drag from the current object centre to the basket
        # centre in two smooth segments.
        drag_z = OBJ3_FALLBACK_DRAG_Z
        c_live = self._estimate_object3_current_center(obs)
        c0 = c_live if c_live is not None else self._detected_centers.get(
            3, np.array([TABLE_CENTER_X, OBJ_Y_BANDS[3][0], TABLE_TOP_Z], dtype=np.float64)
        )
        start = np.array([c0[0], c0[1], drag_z], dtype=np.float64)
        mid = np.array([BASKET_CENTER_X, 0.5 * (c0[1] + BASKET_CENTER_Y), drag_z], dtype=np.float64)
        end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y, drag_z], dtype=np.float64)
        print(
            f"[PCA_FALLBACK] object_3 closed_drag cur=({c0[0]:.3f},{c0[1]:.3f},{c0[2]:.3f}) "
            f"mid=({mid[0]:.3f},{mid[1]:.3f},{mid[2]:.3f}) "
            f"end=({end[0]:.3f},{end[1]:.3f},{end[2]:.3f})",
            flush=True,
        )
        self.plan = []
        self.plan_idx = 0
        self.step_in_target = 0
        hold_grip = self._obj3_hold_grip.copy() if self._obj3_hold_grip is not None else OBJ3_HOLD_GRIP_DEFAULT.copy()
        finger_offset = OBJ_FINGER_XY_OFFSETS[3]
        start_finger = start[:2] + finger_offset
        mid_finger = mid[:2] + finger_offset
        end_finger = end[:2] + finger_offset
        self._add_pose([start_finger[0], start_finger[1], drag_z], topdown, hold_grip, OBJ3_FALLBACK_START_STEPS, finger_xy=start_finger, finger_z=drag_z, label="fallback_closed_drag_start")
        self._add_pose([mid_finger[0], mid_finger[1], drag_z], topdown, hold_grip, OBJ3_FALLBACK_MID_STEPS, finger_xy=mid_finger, finger_z=drag_z, label="fallback_closed_drag_mid")
        self._add_pose([end_finger[0], end_finger[1], drag_z], topdown, hold_grip, OBJ3_FALLBACK_END_STEPS, finger_xy=end_finger, finger_z=drag_z, label="fallback_closed_drag_end")
        self._add_pose([end_finger[0], end_finger[1], drag_z], topdown, GRIP_OPEN, OBJ3_FALLBACK_OPEN_STEPS, finger_xy=end_finger, finger_z=drag_z, label="fallback_closed_drag_open")
        self._add_pose([BASKET_CENTER_X, BASKET_CENTER_Y, TABLE_TOP_Z + 0.18], topdown, GRIP_OPEN, 120, label="fallback_retract")
        return True

    def _build_object1_drag_rescue(self, obs: dict) -> bool:
        rgb, depth = self._video_rgb_depth(obs)
        pts = self._points_for_object(rgb, depth, 1, wide=True, fill_holes=False)
        if len(pts) < 64:
            print(f"[PCA_RESCUE] skip object_1 drag: only {len(pts)} points", flush=True)
            return False
        # After transport failures object_1 is usually back on the table.  The
        # high visible points can be the gripper/finger occluder or a lifted
        # face, so estimate the rescue push centre from table-near points only.
        low = pts[(pts[:, 2] >= TABLE_TOP_Z + 0.030) & (pts[:, 2] <= TABLE_TOP_Z + 0.110)]
        if len(low) >= 32:
            c = 0.5 * (low.min(axis=0) + low.max(axis=0))
            c[2] = float(np.median(low[:, 2]))
        else:
            c, _ = self._estimate_grasp(rgb, depth, 1, wide=True)
        if not np.all(np.isfinite(c)):
            return False
        topdown = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
        drag_z = TABLE_TOP_Z + 0.055
        # Push from the object's positive-y side toward the basket.  A fixed
        # start_y misses the cube after ACT/hybrid rollouts because object_1
        # often remains around y=0.26..0.34.
        lanes_x = [
            float(np.clip(c[0] - 0.045, TABLE_CENTER_X - 0.16, TABLE_CENTER_X + 0.22)),
            float(np.clip(c[0], TABLE_CENTER_X - 0.16, TABLE_CENTER_X + 0.22)),
            float(np.clip(c[0] + 0.045, TABLE_CENTER_X - 0.16, TABLE_CENTER_X + 0.22)),
        ]
        start_y = float(np.clip(c[1] + 0.085, TABLE_CENTER_Y + 0.085, TABLE_CENTER_Y + 0.46))
        end_y = BASKET_CENTER_Y
        print(
            f"[PCA_RESCUE] object_1 drag c=({c[0]:.3f},{c[1]:.3f},{c[2]:.3f}) "
            f"low_n={len(low)} "
            f"lanes={','.join(f'{x:.2f}' for x in lanes_x)} y=({start_y:.3f}->{end_y:.3f})",
            flush=True,
        )
        self.objects = (1,)
        self.plan = []
        self.plan_idx = 0
        self.step_in_target = 0
        for i, lane_x in enumerate(lanes_x):
            start = np.array([lane_x, start_y, drag_z], dtype=np.float64)
            end = np.array([lane_x, end_y, drag_z], dtype=np.float64)
            self._add_pose([lane_x, start_y, TABLE_TOP_Z + 0.20], topdown, GRIP_OPEN, 70, label=f"obj1_rescue_lane{i}_pre")
            self._add_pose(start, topdown, GRIP_OPEN, 100, finger_xy=start[:2], finger_z=drag_z, label=f"obj1_rescue_lane{i}_start")
            self._add_pose(end, topdown, GRIP_OPEN, 520, finger_xy=end[:2], finger_z=drag_z, label=f"obj1_rescue_lane{i}_mid")
        self._add_pose([BASKET_CENTER_X, BASKET_CENTER_Y, TABLE_TOP_Z + 0.15], topdown, GRIP_OPEN, 160, label="obj1_rescue_open")
        self._add_pose([RETRACT_X, RETRACT_Y, TABLE_TOP_Z + 0.40], topdown, GRIP_OPEN, 80, label="obj1_rescue_retract")
        return True

    def _build_plan(self, obs: dict):
        rgb, depth = self._video_rgb_depth(obs)
        topdown = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
        self.plan = []
        objects = tuple(int(x) for x in os.environ.get("ATEC_PCA_OBJECTS", "3,2,1").replace(" ", ",").split(",") if x)
        self.objects = objects
        for obj_idx in objects:
            c, grasp_rot = self._estimate_grasp(rgb, depth, obj_idx)
            if obj_idx == 1:
                grasp_rot = _quat_wxyz_to_rot(np.array([0.0, 0.709, 0.705, 0.0], dtype=np.float64))
            # The submit-style RGB-D PCA estimate is biased toward the visible
            # left crescent of the banana.  Keep GraspGen/PCA for its centre,
            # but use the task-calibrated top-down wrist pose that the runner
            # already validated for object_3.
            if obj_idx == 3 and os.environ.get("ATEC_PCA_OBJ3_USE_PCA_ROT") != "1":
                grasp_rot = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.004, 0.0], dtype=np.float64))
            c[:2] += OBJ_CENTER_COMPLETION_OFFSETS[obj_idx]
            self._detected_centers[obj_idx] = c.copy()
            pick_xy = c[:2] + OBJ_GRASP_CENTER_OFFSETS[obj_idx]
            yaw = float(np.arctan2(grasp_rot[1, 1], grasp_rot[0, 1]))
            print(
                f"[PCA_PLAN] obj={obj_idx} center=({c[0]:.3f},{c[1]:.3f},{c[2]:.3f}) "
                f"pick=({pick_xy[0]:.3f},{pick_xy[1]:.3f}) jaw_yaw={yaw:+.2f}",
                flush=True,
            )
            reach_z = max(float(c[2] + OBJ_TCP_Z[obj_idx]), TABLE_TOP_Z + 0.055)
            # The PCA point cloud z is a visible-surface estimate, not the USD
            # object root z used by the validated runner.  Closing from
            # c[2]+offset is too high for object_1 and makes the gripper miss
            # the cube.  Use the calibrated task close plane instead.
            root_z_est = OBJ_ROOT_Z_EST.get(obj_idx, TABLE_TOP_Z + 0.045)
            close_z = max(root_z_est + OBJ_CLOSE_Z_OFFSETS.get(obj_idx, 0.020), TABLE_TOP_Z + 0.030)
            lift_z = TABLE_TOP_Z + (OBJ3_LIFT_CLEARANCE if obj_idx == 3 else 0.30)
            release_z = TABLE_TOP_Z + (OBJ3_CARRY_CLEARANCE if obj_idx == 3 else (0.32 if obj_idx == 1 else 0.24))
            open_z = TABLE_TOP_Z + (OBJ3_CARRY_CLEARANCE if obj_idx == 3 else (0.24 if obj_idx == 1 else 0.15))
            place_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y]) + OBJ_PLACE_XY_OFFSETS.get(
                obj_idx, np.zeros(2, dtype=np.float64)
            )
            # Keep the calibrated top-down task quaternion for all objects.  The
            # PCA/AABB centre supplies translation; Task-E contact tuning supplies
            # the wrist orientation and release heights.
            finger_xy = pick_xy.copy() + OBJ_FINGER_XY_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64)) if obj_idx in (1, 2, 3) else None
            close_finger_xy = (
                pick_xy
                + OBJ_PRECLOSE_INSERT_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64))
                + OBJ_FINGER_XY_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64))
            )
            closed_grip = OBJ3_HOLD_GRIP_DEFAULT.copy() if obj_idx == 3 else GRIP_CLOSE
            finger_z = reach_z if obj_idx in (1, 2) else None
            place_rot = grasp_rot if obj_idx in (1, 2) else topdown
            self._add_pose([pick_xy[0], pick_xy[1], TABLE_TOP_Z + 0.30], grasp_rot, GRIP_OPEN, 90, label=f"obj{obj_idx}_pre")
            servo_rel_z = OBJ_FINGER_TARGET_REL_Z.get(obj_idx)
            if obj_idx == 3 and OBJ3_ENABLE_INSERT:
                # Diagnostic-only guarded side approach.  Local tests showed
                # low open-finger insertion can shove the banana laterally, so
                # the default path below matches the successful GraspNet runner:
                # reach the calibrated contact point first, then close there.
                side_finger_xy = close_finger_xy + OBJ3_PREGRASP_OFFSET
                self._add_pose(
                    [side_finger_xy[0], side_finger_xy[1], reach_z],
                    grasp_rot,
                    GRIP_OPEN,
                    OBJ3_SIDE_APPROACH_STEPS,
                    finger_xy=side_finger_xy,
                    finger_z=OBJ3_APPROACH_FINGER_Z,
                    servo_obj_z=root_z_est,
                    servo_target_rel_z=None,
                    label=f"obj{obj_idx}_side_pre",
                )
                self._add_pose(
                    [side_finger_xy[0], side_finger_xy[1], close_z],
                    grasp_rot,
                    GRIP_OPEN,
                    OBJ3_SIDE_LOW_STEPS,
                    finger_xy=side_finger_xy,
                    finger_z=OBJ3_PREGRASP_LOW_FINGER_Z,
                    servo_obj_z=root_z_est,
                    servo_target_rel_z=None,
                    label=f"obj{obj_idx}_side_low",
                )
                self._add_pose(
                    [close_finger_xy[0], close_finger_xy[1], close_z],
                    grasp_rot,
                    GRIP_OPEN,
                    OBJ3_INSERT_STEPS,
                    finger_xy=close_finger_xy,
                    finger_z=OBJ3_PREGRASP_LOW_FINGER_Z,
                    servo_obj_z=root_z_est,
                    servo_target_rel_z=None,
                    label=f"obj{obj_idx}_insert",
                )
            else:
                self._add_pose(
                    [pick_xy[0], pick_xy[1], reach_z],
                    grasp_rot,
                    GRIP_OPEN,
                    OBJ_REACH_STEPS[obj_idx],
                    finger_xy=finger_xy,
                    finger_z=None,
                    servo_obj_z=root_z_est,
                    servo_target_rel_z=None,
                    label=f"obj{obj_idx}_reach",
                )
            if obj_idx != 3 and np.linalg.norm(OBJ_PRECLOSE_INSERT_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64))) > 1e-6:
                self._add_pose(
                    [close_finger_xy[0], close_finger_xy[1], close_z],
                    grasp_rot,
                    GRIP_OPEN,
                    180,
                    finger_xy=close_finger_xy,
                    finger_z=None,
                    servo_obj_z=root_z_est,
                    servo_target_rel_z=servo_rel_z,
                    label=f"obj{obj_idx}_insert",
                )
            obj3_finger_z = OBJ3_CLOSE_FINGER_Z if obj_idx == 3 else None
            self._add_pose(
                [close_finger_xy[0], close_finger_xy[1], close_z],
                grasp_rot,
                closed_grip,
                OBJ_CLOSE_STEPS[obj_idx],
                finger_xy=close_finger_xy,
                finger_z=obj3_finger_z,
                servo_obj_z=root_z_est,
                servo_target_rel_z=None if obj_idx == 3 else servo_rel_z,
                label=f"obj{obj_idx}_close",
            )
            if obj_idx == 3:
                self._add_pose(
                    [close_finger_xy[0], close_finger_xy[1], close_z],
                    grasp_rot,
                    closed_grip,
                    OBJ3_LOW_HOLD_STEPS,
                    finger_xy=close_finger_xy,
                    finger_z=OBJ3_CLOSE_FINGER_Z,
                    servo_obj_z=root_z_est,
                    servo_target_rel_z=None,
                    label=f"obj{obj_idx}_low_hold",
                )
            if obj_idx == 1:
                self._add_pose(
                    [close_finger_xy[0], close_finger_xy[1], close_z],
                    grasp_rot,
                    GRIP_CLOSE,
                    160,
                    finger_xy=None,
                    finger_z=None,
                    freeze_arm=True,
                    label=f"obj{obj_idx}_squeeze",
                )
            self._add_pose(
                [close_finger_xy[0], close_finger_xy[1], lift_z],
                grasp_rot,
                closed_grip,
                OBJ_LIFT_STEPS[obj_idx],
                finger_xy=close_finger_xy,
                finger_z=OBJ3_LIFT_FINGER_Z if obj_idx == 3 else None,
                servo_obj_z=None if obj_idx == 3 else root_z_est,
                servo_target_rel_z=None if obj_idx == 3 else servo_rel_z,
                label=f"obj{obj_idx}_lift",
            )
            if obj_idx == 3:
                # After a short lift confirms contact, do not keep a high-air
                # friction grasp.  Banana is contact-sensitive in official
                # physics; a low closed-drag/cradle path preserves contact and
                # avoids the DLS high-transport singularity seen in videos.
                drag_z = OBJ3_FALLBACK_DRAG_Z
                drag_start_finger = close_finger_xy.copy()
                drag_mid_obj = np.array([BASKET_CENTER_X, 0.5 * (pick_xy[1] + BASKET_CENTER_Y)], dtype=np.float64)
                drag_end_obj = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64)
                drag_mid_finger = drag_mid_obj + OBJ_FINGER_XY_OFFSETS[3]
                drag_end_finger = drag_end_obj + OBJ_FINGER_XY_OFFSETS[3]
                self._add_pose(
                    [drag_start_finger[0], drag_start_finger[1], drag_z],
                    topdown,
                    closed_grip,
                    OBJ3_DRAG_START_STEPS,
                    finger_xy=drag_start_finger,
                    finger_z=drag_z,
                    label=f"obj{obj_idx}_drag_start",
                )
                self._add_pose(
                    [drag_mid_finger[0], drag_mid_finger[1], drag_z],
                    topdown,
                    closed_grip,
                    OBJ3_DRAG_MID_STEPS,
                    finger_xy=drag_mid_finger,
                    finger_z=drag_z,
                    label=f"obj{obj_idx}_drag_mid",
                )
                self._add_pose(
                    [drag_end_finger[0], drag_end_finger[1], drag_z],
                    topdown,
                    closed_grip,
                    OBJ3_DRAG_END_STEPS,
                    finger_xy=drag_end_finger,
                    finger_z=drag_z,
                    label=f"obj{obj_idx}_drag_end",
                )
                self._add_pose(
                    [drag_end_finger[0], drag_end_finger[1], drag_z],
                    topdown,
                    closed_grip,
                    OBJ3_DRAG_SETTLE_STEPS,
                    finger_xy=drag_end_finger,
                    finger_z=drag_z,
                    label=f"obj{obj_idx}_drag_settle",
                )
                self._add_pose(
                    [drag_end_finger[0], drag_end_finger[1], drag_z],
                    topdown,
                    GRIP_OPEN,
                    OBJ_OPEN_STEPS[obj_idx],
                    finger_xy=drag_end_finger,
                    finger_z=drag_z,
                    label=f"obj{obj_idx}_drag_open",
                )
                self._add_pose([RETRACT_X, RETRACT_Y, TABLE_TOP_Z + 0.40], topdown, GRIP_OPEN, 80, label=f"obj{obj_idx}_retract")
                continue
            mid = np.array([(close_finger_xy[0] + place_xy[0]) * 0.5, (close_finger_xy[1] + place_xy[1]) * 0.5, release_z])
            if obj_idx == 3:
                carry_mid_finger = mid[:2] + OBJ_FINGER_XY_OFFSETS[3]
                release_finger = place_xy + OBJ_FINGER_XY_OFFSETS[3]
            else:
                carry_mid_finger = mid[:2] if obj_idx in (1, 2) else None
                release_finger = place_xy if obj_idx in (1, 2) else None
            carry_finger_z = OBJ3_LIFT_FINGER_Z if obj_idx == 3 else None
            self._add_pose(
                mid,
                place_rot,
                closed_grip,
                max(OBJ_TRANSPORT_STEPS[obj_idx] // 2, 1),
                finger_xy=carry_mid_finger,
                finger_z=carry_finger_z,
                label=f"obj{obj_idx}_mid",
            )
            if obj_idx == 1:
                self._add_pose(
                    mid,
                    place_rot,
                    GRIP_CLOSE,
                    140,
                    freeze_arm=True,
                    label=f"obj{obj_idx}_mid_squeeze",
                )
            self._add_pose(
                [place_xy[0], place_xy[1], release_z],
                place_rot,
                closed_grip,
                max(OBJ_TRANSPORT_STEPS[obj_idx] - OBJ_TRANSPORT_STEPS[obj_idx] // 2, 1),
                finger_xy=release_finger,
                finger_z=carry_finger_z,
                label=f"obj{obj_idx}_release",
            )
            if obj_idx == 3:
                # Match the runner's basket-hold phase: keep the gripper closed
                # above the release pose while the object centre is servoed into
                # the real basket centre before opening.
                self._add_pose(
                    [place_xy[0], place_xy[1], release_z],
                    place_rot,
                    closed_grip,
                    420,
                    finger_xy=release_finger,
                    finger_z=carry_finger_z,
                    label=f"obj{obj_idx}_basket_hold",
                )
            if obj_idx == 1 and os.environ.get("ATEC_PCA_ENABLE_OBJ1_RESCUE") == "1":
                self._add_pose([place_xy[0], place_xy[1], release_z], place_rot, GRIP_CLOSE, 1, label="obj1_relocalize_drag")
            settle_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64) if obj_idx == 1 else place_xy
            settle_finger = release_finger if obj_idx == 3 else (settle_xy if obj_idx in (1, 2) else None)
            self._add_pose([settle_xy[0], settle_xy[1], open_z], place_rot, closed_grip, 80 if obj_idx != 3 else 120, finger_xy=settle_finger, label=f"obj{obj_idx}_settle")
            self._add_pose([settle_xy[0], settle_xy[1], open_z], place_rot, GRIP_OPEN, OBJ_OPEN_STEPS[obj_idx], label=f"obj{obj_idx}_open")
            self._add_pose([RETRACT_X, RETRACT_Y, TABLE_TOP_Z + 0.40], topdown, GRIP_OPEN, 80, label=f"obj{obj_idx}_retract")
        self.detected = True

    def _add_pose(
        self,
        pos,
        rot,
        grip,
        steps,
        finger_xy=None,
        finger_z=None,
        servo_obj_z=None,
        servo_target_rel_z=None,
        freeze_arm=False,
        label="",
    ):
        if int(steps) <= 0:
            return
        self.plan.append(
            PoseTarget(
                np.asarray(pos, dtype=np.float64),
                np.asarray(rot, dtype=np.float64),
                np.asarray(grip, dtype=np.float64),
                int(steps),
                None if finger_xy is None else np.asarray(finger_xy, dtype=np.float64),
                None if finger_z is None else float(finger_z),
                None if servo_obj_z is None else float(servo_obj_z),
                None if servo_target_rel_z is None else float(servo_target_rel_z),
                bool(freeze_arm),
                str(label),
            )
        )

    def predicts(self, obs, current_score):
        qpos = self._obs_qpos(obs)
        if self.t < 25:
            self.t += 1
            return {"action": np.zeros((1, 8), dtype=np.float32).tolist(), "giveup": False}
        if self.home_count < 80:
            self.home_count += 1
            action = np.clip((HOME_Q - DEFAULT_Q) / ACTION_SCALE, -3.0, 3.0)
            return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
        if not self.detected:
            if (
                os.environ.get("ATEC_PCA_OBJ1_DIRECT_RESCUE") == "1"
                and tuple(int(x) for x in os.environ.get("ATEC_PCA_OBJECTS", "3,2,1").replace(" ", ",").split(",") if x) == (1,)
                and self._build_object1_drag_rescue(obs)
            ):
                self.detected = True
            else:
                self._build_plan(obs)
        if self.plan_idx >= len(self.plan):
            if (
                not self.fallback_done
                and 3 in self.objects
                and os.environ.get("ATEC_PCA_ENABLE_FALLBACK") == "1"
            ):
                self.fallback_done = True
                if self._build_object3_drag_fallback(obs):
                    target = self.plan[self.plan_idx]
                    pos_w = target.pos_w.copy()
                else:
                    action = np.clip((HOME_Q - DEFAULT_Q) / ACTION_SCALE, -3.0, 3.0)
                    return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
            else:
                action = np.clip((HOME_Q - DEFAULT_Q) / ACTION_SCALE, -3.0, 3.0)
                return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
        else:
            target = self.plan[self.plan_idx]
            pos_w = target.pos_w.copy()
        if target.label == "obj1_relocalize_drag":
            if self._build_object1_drag_rescue(obs):
                target = self.plan[self.plan_idx]
                pos_w = target.pos_w.copy()
            else:
                self.plan_idx += 1
                return {"action": np.zeros((1, 8), dtype=np.float32).tolist(), "giveup": False}
        raw_pos_w = pos_w.copy()
        dynamic_finger_xy = None
        finger_target_w = None
        if target.label in ("obj3_basket_hold", "obj3_settle") and os.environ.get(
            "ATEC_PCA_OBJ3_OBJECT_SERVO", "1"
        ) != "0":
            c_now = self._estimate_object3_current_center(obs)
            if c_now is not None:
                if self._obj3_carry_offset_xy is None:
                    finger_now = self.ik.finger_center_world(qpos)
                    observed_offset = finger_now[:2] - c_now[:2]
                    # Preserve the actual contact relation reached at lift,
                    # but bound it so a bad visual frame cannot launch the arm.
                    observed_offset = np.clip(observed_offset, [-0.055, -0.055], [0.055, 0.055])
                    if np.all(np.isfinite(observed_offset)):
                        self._obj3_carry_offset_xy = observed_offset.astype(np.float64)
                carry_offset = (
                    self._obj3_carry_offset_xy
                    if self._obj3_carry_offset_xy is not None
                    else OBJ_FINGER_XY_OFFSETS[3]
                )
                object_target_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64)
                correction = np.zeros(2, dtype=np.float64)
                correction = (object_target_xy - c_now[:2]) * OBJ3_OBJECT_SERVO_GAIN
                corr_norm = float(np.linalg.norm(correction))
                max_corr = OBJ3_OBJECT_SERVO_MAX_XY
                if corr_norm > max_corr:
                    correction = correction / max(corr_norm, 1e-6) * max_corr
                pos_w[:2] = raw_pos_w[:2] + correction
                raw_pos_w = pos_w.copy()
                # Keep the same finger-to-object contact relation while
                # servoing the object centre into the basket.  Pointing the
                # finger target at c_now pins the hand near the old table pose
                # and fights the basket correction.
                dynamic_finger_xy = object_target_xy + carry_offset
                if (
                    os.environ.get("ATEC_PCA_ENABLE_FALLBACK") == "1"
                    and
                    os.environ.get("ATEC_PCA_OBJ3_DYNAMIC_FALLBACK", "1") != "0"
                    and not self.fallback_done
                    and target.label in ("obj3_mid", "obj3_release", "obj3_basket_hold")
                    and c_now[1] > BASKET_CENTER_Y + 0.16
                    and c_now[2] < TABLE_TOP_Z + 0.045
                    and self.step_in_target > 80
                ):
                    self.fallback_done = True
                    print(
                        f"[PCA_FALLBACK_TRIGGER] object_3 stalled c=({c_now[0]:.3f},{c_now[1]:.3f},{c_now[2]:.3f}) "
                        f"target={target.label} step={self.step_in_target}",
                        flush=True,
                    )
                    if self._build_object3_drag_fallback(obs):
                        target = self.plan[self.plan_idx]
                        pos_w = target.pos_w.copy()
                        raw_pos_w = pos_w.copy()
                        dynamic_finger_xy = None
                if os.environ.get("ATEC_PCA_DEBUG_TARGET") and self.step_in_target % 25 == 0:
                    print(
                        f"[PCA_OBJ_SERVO] {target.label} c=({c_now[0]:.3f},{c_now[1]:.3f}) "
                        f"target=({object_target_xy[0]:.3f},{object_target_xy[1]:.3f}) "
                        f"corr=({correction[0]:+.3f},{correction[1]:+.3f})",
                        flush=True,
                    )
        if target.finger_xy is not None:
            finger = self.ik.finger_center_world(qpos)
            gb_b, _ = self.ik.fk_base(qpos[:6])
            gb_w = BASE_POS_W + R_W_B @ gb_b
            finger_from_gb = finger - gb_w
            desired_finger_xy = target.finger_xy if dynamic_finger_xy is None else dynamic_finger_xy
            finger_target_z = target.finger_z if target.finger_z is not None else finger[2]
            finger_target_w = np.array([desired_finger_xy[0], desired_finger_xy[1], finger_target_z], dtype=np.float64)
            xy_error = finger[:2] - desired_finger_xy
            correction = -xy_error
            corr_norm = float(np.linalg.norm(correction))
            max_xy = 0.12
            if target.label.startswith("obj3_") and (
                ("_mid" in target.label)
                or ("_release" in target.label)
                or ("_basket_hold" in target.label)
                or ("_settle" in target.label)
                or ("_drag" in target.label)
            ):
                max_xy = OBJ3_FINGER_SERVO_MAX_XY
            elif ("_mid" in target.label) or ("_release" in target.label) or ("_settle" in target.label):
                max_xy = 0.32
            if corr_norm > max_xy:
                correction = correction / max(corr_norm, 1e-6) * max_xy
            pos_w[:2] = raw_pos_w[:2] + correction
            if target.finger_z is not None:
                pos_w[2] = float(target.finger_z - finger_from_gb[2])
            elif target.servo_obj_z is not None and target.servo_target_rel_z is not None:
                rel_z = float(finger[2] - target.servo_obj_z)
                z_error = float(target.servo_target_rel_z - rel_z)
                obj_for_label = 3 if target.label.startswith("obj3_") else 1
                max_z = OBJ_FINGER_SERVO_MAX_Z.get(obj_for_label, 0.050)
                if obj_for_label == 3:
                    z_correction = float(np.clip(z_error, -max_z, max_z))
                else:
                    z_correction = min(0.0, max(-max_z, z_error))
                pos_w[2] = float(raw_pos_w[2] + z_correction)
            if os.environ.get("ATEC_PCA_DEBUG_TARGET") and self.step_in_target % 25 == 0:
                print(
                    f"[PCA_TARGET] plan={self.plan_idx} step={self.step_in_target} "
                    f"raw=({raw_pos_w[0]:.3f},{raw_pos_w[1]:.3f},{raw_pos_w[2]:.3f}) "
                    f"gb=({gb_w[0]:.3f},{gb_w[1]:.3f},{gb_w[2]:.3f}) "
                    f"finger=({finger[0]:.3f},{finger[1]:.3f},{finger[2]:.3f}) "
                    f"desired=({desired_finger_xy[0]:.3f},{desired_finger_xy[1]:.3f}) "
                    f"pos=({pos_w[0]:.3f},{pos_w[1]:.3f},{pos_w[2]:.3f})",
                    flush=True,
                )
        # Use a submit-side equivalent of the runner's CartesianController:
        # one DLS update from the current qpos per simulator step.  Close/reach
        # phases prioritize position because centimetres of z error are enough
        # to miss the object, while a small wrist error is tolerable.
        position_only = (
            ("_reach" in target.label)
            or ("_side_pre" in target.label)
            or ("_side_low" in target.label)
            or ("_insert" in target.label)
            or ("_close" in target.label)
            or ("_low_hold" in target.label)
            or (target.label.startswith("obj3_") and any(key in target.label for key in ("drag", "mid", "release", "basket_hold", "settle")))
        )
        if target.freeze_arm:
            q6 = qpos[:6].copy()
        elif (
            finger_target_w is not None
            and (
                (
                    target.label.startswith("fallback_")
                    and os.environ.get("ATEC_PCA_FALLBACK_FINGER_IK", "0") != "0"
                )
                or (
                    target.label.startswith("obj3_")
                    and os.environ.get("ATEC_PCA_OBJ3_USE_FINGER_IK", "0") == "1"
                    and any(key in target.label for key in ("mid", "release", "basket_hold", "settle"))
                )
            )
        ):
            q6 = self.ik.solve_finger(qpos, finger_target_w, target.rot_w)
        elif os.environ.get("ATEC_PCA_USE_FULL_IK") == "1":
            q6 = self.ik.solve(qpos, pos_w, target.rot_w)
        else:
            q6 = self.ik.step_dls(qpos, pos_w, target.rot_w, position_only=position_only)
        q_target = np.concatenate([q6, target.grip])
        if target.label.startswith("obj1_"):
            gap = self.ik.finger_gap(qpos)
            if (
                self._obj1_hold_grip is None
                and
                target.label in ("obj1_close", "obj1_lift", "obj1_mid")
                and gap <= OBJ1_HOLD_GAP
                and self.step_in_target > 10
            ):
                self._obj1_hold_grip = qpos[6:8].copy()
            if self._obj1_hold_grip is not None and any(
                key in target.label for key in ("close", "squeeze", "lift", "mid", "release", "settle")
            ):
                q_target[6:8] = self._obj1_hold_grip
        if target.label.startswith("obj3_"):
            gap = self.ik.finger_gap(qpos)
            if (
                self._obj3_hold_grip is None
                and target.label == "obj3_lift"
                and gap <= OBJ3_HOLD_GAP
                and self.step_in_target >= int(os.environ.get("ATEC_PCA_OBJ3_LIFT_LATCH_STEP", "20"))
            ):
                self._obj3_hold_grip = qpos[6:8].copy()
            if self._obj3_hold_grip is not None and any(
                key in target.label for key in ("close", "low_hold", "lift", "mid", "release", "basket_hold", "settle", "drag")
            ):
                q_target[6:8] = self._obj3_hold_grip
        # Match IsaacLab CartesianController's per-step clamp; gripper fingers
        # still close gradually so they do not shove the object sideways.
        gripper_max_delta = 0.010
        if target.label.startswith("obj3_") and self._obj3_hold_grip is None and any(
            key in target.label for key in ("close", "low_hold")
        ):
            gripper_max_delta = OBJ3_GRIPPER_MAX_DELTA
        max_delta = np.array(
            [0.18, 0.18, 0.18, 0.18, 0.18, 0.18, gripper_max_delta, gripper_max_delta],
            dtype=np.float64,
        )
        q_target = qpos + np.clip(q_target - qpos, -max_delta, max_delta)
        action = np.clip((q_target - DEFAULT_Q) / ACTION_SCALE, -5.0, 5.0)
        self.step_in_target += 1
        advance = self.step_in_target >= target.steps
        if target.label == "obj1_close" and self._obj1_hold_grip is not None:
            advance = True
        if (
            target.label == "obj3_close"
            and self._obj3_hold_grip is not None
            and self.step_in_target >= OBJ3_CLOSE_MIN_STEPS
        ):
            advance = True
        if "_squeeze" in target.label:
            gap = self.ik.finger_gap(qpos)
            if self._obj1_hold_grip is not None and target.label.startswith("obj1_"):
                advance = self.step_in_target >= 20
            elif gap > OBJ1_HOLD_GAP and self.step_in_target < 420:
                advance = False
            if os.environ.get("ATEC_PCA_DEBUG_TARGET") and self.step_in_target % 25 == 0:
                print(f"[PCA_SQUEEZE] step={self.step_in_target} gap={gap:.4f} advance={advance}", flush=True)
        if advance:
            if os.environ.get("ATEC_PCA_DEBUG_TARGET") and target.label.startswith("obj3_"):
                c_dbg = self._estimate_object3_current_center(obs)
                f_dbg = self.ik.finger_center_world(qpos)
                gap_dbg = self.ik.finger_gap(qpos)
                c_msg = "none"
                if c_dbg is not None:
                    c_msg = f"({c_dbg[0]:.3f},{c_dbg[1]:.3f},{c_dbg[2]:.3f})"
                print(
                    f"[PCA_STAGE_END] {target.label} c={c_msg} "
                    f"finger=({f_dbg[0]:.3f},{f_dbg[1]:.3f},{f_dbg[2]:.3f}) "
                    f"gap={gap_dbg:.4f} hold="
                    f"{None if self._obj3_hold_grip is None else [float(v) for v in self._obj3_hold_grip]}",
                    flush=True,
                )
            self.step_in_target = 0
            self.plan_idx += 1
        return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}


RETRACT_X = TABLE_CENTER_X + TABLE_HALF_X - 0.05
RETRACT_Y = TABLE_CENTER_Y