Add files using upload-large-folder tool

atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT.usd.last_generated

@@ -0,0 +1 @@
+2025-01-15 22:28:57

atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual.usd.last_generated

@@ -0,0 +1 @@
+2025-01-15 22:29:04

atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual_collision.usd.last_generated

@@ -0,0 +1 @@
+2025-01-15 22:29:09

atec_robot_model/objects/task_e/shop_table/.collect.mapping.json

@@ -0,0 +1,77 @@
+{
+    "version": "1.0",
+    "file_records": [
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/aluminum_feet_basecolor.png",
+            "source_hash": "f57c28888268a580c183fdeb41f7bb9e9eb0b134",
+            "target_url": "./textures/aluminum_feet_basecolor.png",
+            "target_hash": "8ceaebf96f29d4ca23d43b0b35a4a9d7d591b9a2"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/aluminum_feet_normal.png",
+            "source_hash": "90799c1ef386f466fd2fc4ec065edd8c0d6c4a7e",
+            "target_url": "./textures/aluminum_feet_normal.png",
+            "target_hash": "782bdfd98942e2e209de7ad9685ed07fe221d45c"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/aluminum_feet_roughness.png",
+            "source_hash": "2b7a4d8487620024cc43a6e796b52a3a92b566e5",
+            "target_url": "./textures/aluminum_feet_roughness.png",
+            "target_hash": "ff5571089243d1d75b7509293beabe4f24f973ea"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_basecolor.png",
+            "source_hash": "e70234bdc6a607996b395667c8a1dee815703a4a",
+            "target_url": "./textures/metal_tabletop_basecolor.png",
+            "target_hash": "f07f6619e46cc26545f5061bec0cbdb94e37c922"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_metallic.png",
+            "source_hash": "d21eeeb9e675f4203387875b1d690151cb574c74",
+            "target_url": "./textures/metal_tabletop_metallic.png",
+            "target_hash": "2c6266f3ab51d0537ad38b54df02007eb9111803"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_normal.png",
+            "source_hash": "330003f7b33e37a63ff1547d603c9f54ecac6f1c",
+            "target_url": "./textures/metal_tabletop_normal.png",
+            "target_hash": "ce62d74aa3f6a05b8662b1a8f938a6421a9819aa"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_roughness.png",
+            "source_hash": "679380766abf4ca418c1d1681dec38a96f74d24e",
+            "target_url": "./textures/metal_tabletop_roughness.png",
+            "target_hash": "e4e2dc752544d7a9d0919520a33f084adff9cf50"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_basecolor.png",
+            "source_hash": "19de24af03b4a0a2a9fb1213e72b8dbb9fe43446",
+            "target_url": "./textures/steel_orange_basecolor.png",
+            "target_hash": "ada63e416ff77d9579ddb44bf24069b4d7393e84"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_metallic.png",
+            "source_hash": "a3b4c3c79ac1f820465b66078faf40131e83deb1",
+            "target_url": "./textures/steel_orange_metallic.png",
+            "target_hash": "6ef5e8a42ce00c27e79275c54258d9f99fe09ca7"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_normal.png",
+            "source_hash": "2024c4b6f6a2bed8812d854df83e115f15b132df",
+            "target_url": "./textures/steel_orange_normal.png",
+            "target_hash": "6c49a1bdb10f7b66c8e4028988fa6bafd416ab5b"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_roughness.png",
+            "source_hash": "529db0802c83a483c28e235ff6c706b99159d778",
+            "target_url": "./textures/steel_orange_roughness.png",
+            "target_hash": "fd92178c5427e9a2728bb4f866827724cb0025a5"
+        },
+        {
+            "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/vibrationtable_base_basecolor.png",
+            "source_hash": "c526c43071d2aa9dd4399e7682390774d84a9ee5",
+            "target_url": "./textures/vibrationtable_base_basecolor.png",
+            "target_hash": "933a0ca8cf7d13fbae9a8980a58798842625483a"
+        }
+    ]
+}

demo/act/detr/backbone.py

@@ -0,0 +1,126 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Backbone modules.
+"""
+from collections import OrderedDict
+
+import torch
+import torch.nn.functional as F
+import torchvision
+from torch import nn
+from torchvision.models._utils import IntermediateLayerGetter
+from typing import Dict, List
+
+from .utils  import NestedTensor
+from .position_encoding import build_position_encoding
+
+class FrozenBatchNorm2d(torch.nn.Module):
+    """
+    BatchNorm2d where the batch statistics and the affine parameters are fixed.
+
+    Copy-paste from torchvision.misc.ops with added eps before rqsrt,
+    without which any other policy_models than torchvision.policy_models.resnet[18,34,50,101]
+    produce nans.
+    """
+
+    def __init__(self, n):
+        super(FrozenBatchNorm2d, self).__init__()
+        self.register_buffer("weight", torch.ones(n))
+        self.register_buffer("bias", torch.zeros(n))
+        self.register_buffer("running_mean", torch.zeros(n))
+        self.register_buffer("running_var", torch.ones(n))
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
+                              missing_keys, unexpected_keys, error_msgs):
+        num_batches_tracked_key = prefix + 'num_batches_tracked'
+        if num_batches_tracked_key in state_dict:
+            del state_dict[num_batches_tracked_key]
+
+        super(FrozenBatchNorm2d, self)._load_from_state_dict(
+            state_dict, prefix, local_metadata, strict,
+            missing_keys, unexpected_keys, error_msgs)
+
+    def forward(self, x):
+        # move reshapes to the beginning
+        # to make it fuser-friendly
+        w = self.weight.reshape(1, -1, 1, 1)
+        b = self.bias.reshape(1, -1, 1, 1)
+        rv = self.running_var.reshape(1, -1, 1, 1)
+        rm = self.running_mean.reshape(1, -1, 1, 1)
+        eps = 1e-5
+        scale = w * (rv + eps).rsqrt()
+        bias = b - rm * scale
+        return x * scale + bias
+
+
+class BackboneBase(nn.Module):
+
+    def __init__(self, backbone: nn.Module, train_backbone: bool, num_channels: int, return_interm_layers: bool):
+        super().__init__()
+        # for name, parameter in backbone.named_parameters(): # only train later layers # TODO do we want this?
+        #     if not train_backbone or 'layer2' not in name and 'layer3' not in name and 'layer4' not in name:
+        #         parameter.requires_grad_(False)
+        if return_interm_layers:
+            return_layers = {"layer1": "0", "layer2": "1", "layer3": "2", "layer4": "3"}
+        else:
+            return_layers = {'layer4': "0"}
+        self.body = IntermediateLayerGetter(backbone, return_layers=return_layers)
+        self.num_channels = num_channels
+
+    def forward(self, tensor):
+        xs = self.body(tensor)
+        return xs
+        # out: Dict[str, NestedTensor] = {}
+        # for name, x in xs.items():
+        #     m = tensor_list.mask
+        #     assert m is not None
+        #     mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0]
+        #     out[name] = NestedTensor(x, mask)
+        # return out
+
+
+class Backbone(BackboneBase):
+    """ResNet backbone with frozen BatchNorm."""
+    def __init__(self, name: str,
+                 train_backbone: bool,
+                 return_interm_layers: bool,
+                 dilation: bool,
+                 include_depth: bool):
+        backbone = getattr(torchvision.models, name)(
+            replace_stride_with_dilation=[False, False, dilation],
+            pretrained=False, norm_layer=FrozenBatchNorm2d) # pretrained # TODO do we want frozen batch_norm??
+
+        # for rgbd data 
+        if include_depth:
+            w = backbone.conv1.weight
+            w = torch.cat([w, torch.full((64, 1, 7, 7), 0)], dim=1)
+            backbone.conv1.weight = nn.Parameter(w)
+            
+        num_channels = 512 if name in ('resnet18', 'resnet34') else 2048
+        super().__init__(backbone, train_backbone, num_channels, return_interm_layers)
+
+
+class Joiner(nn.Sequential):
+    def __init__(self, backbone, position_embedding):
+        super().__init__(backbone, position_embedding)
+
+    def forward(self, tensor_list: NestedTensor):
+        xs = self[0](tensor_list)
+        out: List[NestedTensor] = []
+        pos = []
+        for name, x in xs.items():
+            out.append(x)
+            # position encoding
+            pos.append(self[1](x).to(x.dtype))
+
+        return out, pos
+
+
+def build_backbone(args):
+    position_embedding = build_position_encoding(args)
+    train_backbone = args.lr_backbone > 0
+    return_interm_layers = args.masks
+    backbone = Backbone(args.backbone, train_backbone, return_interm_layers, args.dilation, args.include_depth)
+    model = Joiner(backbone, position_embedding)
+    model.num_channels = backbone.num_channels
+    return model

demo/act/detr/detr_vae.py

@@ -0,0 +1,137 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+DETR model and criterion classes.
+"""
+import torch
+from torch import nn
+from torch.autograd import Variable
+from .transformer import build_transformer, TransformerEncoder, TransformerEncoderLayer
+
+import numpy as np
+
+def reparametrize(mu, logvar):
+    std = logvar.div(2).exp()
+    eps = Variable(std.data.new(std.size()).normal_())
+    return mu + std * eps
+
+
+def get_sinusoid_encoding_table(n_position, d_hid):
+    def get_position_angle_vec(position):
+        return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]
+
+    sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)])
+    sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])  # dim 2i
+    sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])  # dim 2i+1
+
+    return torch.FloatTensor(sinusoid_table).unsqueeze(0)
+
+
+class DETRVAE(nn.Module):
+    """ This is the DETR module that performs object detection """
+    def __init__(self, backbones, transformer, encoder, state_dim, action_dim, num_queries):
+        super().__init__()
+        self.num_queries = num_queries
+        self.transformer = transformer
+        self.encoder = encoder
+        hidden_dim = transformer.d_model
+        self.action_head = nn.Linear(hidden_dim, action_dim)
+        self.query_embed = nn.Embedding(num_queries, hidden_dim)
+        if backbones is not None:
+            self.input_proj = nn.Conv2d(backbones[0].num_channels, hidden_dim, kernel_size=1)
+            self.backbones = nn.ModuleList(backbones)
+            self.input_proj_robot_state = nn.Linear(state_dim, hidden_dim)
+        else:
+            self.input_proj_robot_state = nn.Linear(state_dim, hidden_dim)
+            self.backbones = None
+
+        # encoder extra parameters
+        self.latent_dim = 32 # size of latent z
+        self.cls_embed = nn.Embedding(1, hidden_dim) # extra cls token embedding
+        self.encoder_state_proj = nn.Linear(state_dim, hidden_dim)  # project state to embedding
+        self.encoder_action_proj = nn.Linear(action_dim, hidden_dim) # project action to embedding
+        self.latent_proj = nn.Linear(hidden_dim, self.latent_dim*2) # project hidden state to latent std, var
+        self.register_buffer('pos_table', get_sinusoid_encoding_table(1+1+num_queries, hidden_dim)) # [CLS], state, actions
+
+        # decoder extra parameters
+        self.latent_out_proj = nn.Linear(self.latent_dim, hidden_dim) # project latent sample to embedding
+        self.additional_pos_embed = nn.Embedding(2, hidden_dim) # learned position embedding for state and proprio
+
+    def forward(self, obs, actions=None):
+        is_training = actions is not None
+        state = obs['state'] if self.backbones is not None else obs
+        bs = state.shape[0]
+
+        if is_training:
+            # project CLS token, state sequence, and action sequence to embedding dim
+            cls_embed = self.cls_embed.weight  # (1, hidden_dim)
+            cls_embed = torch.unsqueeze(cls_embed, axis=0).repeat(bs, 1, 1)  # (bs, 1, hidden_dim)
+            state_embed = self.encoder_state_proj(state) # (bs, hidden_dim)
+            state_embed = torch.unsqueeze(state_embed, axis=1)  # (bs, 1, hidden_dim)
+            action_embed = self.encoder_action_proj(actions)  # (bs, seq, hidden_dim)
+            # concat them together to form an input to the CVAE encoder
+            encoder_input = torch.cat([cls_embed, state_embed, action_embed], axis=1) # (bs, seq+2, hidden_dim)
+            encoder_input = encoder_input.permute(1, 0, 2) # (seq+2, bs, hidden_dim)
+            # no masking is applied to all parts of the CVAE encoder input
+            is_pad = torch.full((bs, encoder_input.shape[0]), False).to(state.device) # False: not a padding
+            # obtain position embedding
+            pos_embed = self.pos_table.clone().detach()
+            pos_embed = pos_embed.permute(1, 0, 2)  # (seq+2, 1, hidden_dim)
+            # query CVAE encoder
+            encoder_output = self.encoder(encoder_input, pos=pos_embed, src_key_padding_mask=is_pad)
+            encoder_output = encoder_output[0] # take cls output only
+            latent_info = self.latent_proj(encoder_output)
+            mu = latent_info[:, :self.latent_dim]
+            logvar = latent_info[:, self.latent_dim:]
+            latent_sample = reparametrize(mu, logvar)
+            latent_input = self.latent_out_proj(latent_sample)
+        else:
+            mu = logvar = None
+            latent_sample = torch.zeros([bs, self.latent_dim], dtype=torch.float32).to(state.device)
+            latent_input = self.latent_out_proj(latent_sample)
+
+        # CVAE decoder
+        if self.backbones is not None:
+            vis_data = obs['rgb']
+            if "depth" in obs:
+                vis_data = torch.cat([vis_data, obs['depth']], dim=2)
+            num_cams = vis_data.shape[1]
+
+            # Image observation features and position embeddings
+            all_cam_features = []
+            all_cam_pos = []
+            for cam_id in range(num_cams):
+                features, pos = self.backbones[0](vis_data[:, cam_id]) # HARDCODED
+                features = features[0] # take the last layer feature # (batch, hidden_dim, H, W)
+                pos = pos[0] # (1, hidden_dim, H, W)
+                all_cam_features.append(self.input_proj(features))
+                all_cam_pos.append(pos)
+
+            # proprioception features (state)
+            proprio_input = self.input_proj_robot_state(state)
+            # fold camera dimension into width dimension
+            src = torch.cat(all_cam_features, axis=3) # (batch, hidden_dim, 4, 8)
+            pos = torch.cat(all_cam_pos, axis=3) # (batch, hidden_dim, 4, 8)
+            hs = self.transformer(src, None, self.query_embed.weight, pos, latent_input, proprio_input, self.additional_pos_embed.weight)[0] # (batch, num_queries, hidden_dim)
+        else:
+            state = self.input_proj_robot_state(state)
+            hs = self.transformer(None, None, self.query_embed.weight, None, latent_input, state, self.additional_pos_embed.weight)[0]
+
+        a_hat = self.action_head(hs)
+        return a_hat, [mu, logvar]
+
+
+def build_encoder(args):
+    d_model = args.hidden_dim # 256
+    dropout = args.dropout # 0.1
+    nhead = args.nheads # 8
+    dim_feedforward = args.dim_feedforward # 2048
+    num_encoder_layers = args.enc_layers # 4 # TODO shared with VAE decoder
+    normalize_before = args.pre_norm # False
+    activation = "relu"
+
+    encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
+                                            dropout, activation, normalize_before)
+    encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+    encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+    return encoder

demo/act/detr/position_encoding.py

@@ -0,0 +1,90 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Various positional encodings for the transformer.
+"""
+import math
+import torch
+from torch import nn
+
+from .utils import NestedTensor
+
+class PositionEmbeddingSine(nn.Module):
+    """
+    This is a more standard version of the position embedding, very similar to the one
+    used by the Attention is all you need paper, generalized to work on images.
+    """
+    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
+        super().__init__()
+        self.num_pos_feats = num_pos_feats
+        self.temperature = temperature
+        self.normalize = normalize
+        if scale is not None and normalize is False:
+            raise ValueError("normalize should be True if scale is passed")
+        if scale is None:
+            scale = 2 * math.pi
+        self.scale = scale
+
+    def forward(self, tensor):
+        x = tensor
+        # mask = tensor_list.mask
+        # assert mask is not None
+        # not_mask = ~mask
+
+        not_mask = torch.ones_like(x[0, [0]])
+        y_embed = not_mask.cumsum(1, dtype=torch.float32)
+        x_embed = not_mask.cumsum(2, dtype=torch.float32)
+        if self.normalize:
+            eps = 1e-6
+            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
+            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
+        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
+
+        pos_x = x_embed[:, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, None] / dim_t
+        pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
+        pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
+        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+        return pos
+
+
+class PositionEmbeddingLearned(nn.Module):
+    """
+    Absolute pos embedding, learned.
+    """
+    def __init__(self, num_pos_feats=256):
+        super().__init__()
+        self.row_embed = nn.Embedding(50, num_pos_feats)
+        self.col_embed = nn.Embedding(50, num_pos_feats)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.uniform_(self.row_embed.weight)
+        nn.init.uniform_(self.col_embed.weight)
+
+    def forward(self, tensor_list: NestedTensor):
+        x = tensor_list.tensors
+        h, w = x.shape[-2:]
+        i = torch.arange(w, device=x.device)
+        j = torch.arange(h, device=x.device)
+        x_emb = self.col_embed(i)
+        y_emb = self.row_embed(j)
+        pos = torch.cat([
+            x_emb.unsqueeze(0).repeat(h, 1, 1),
+            y_emb.unsqueeze(1).repeat(1, w, 1),
+        ], dim=-1).permute(2, 0, 1).unsqueeze(0).repeat(x.shape[0], 1, 1, 1)
+        return pos
+
+
+def build_position_encoding(args):
+    N_steps = args.hidden_dim // 2
+    if args.position_embedding in ('v2', 'sine'):
+        # TODO find a better way of exposing other arguments
+        position_embedding = PositionEmbeddingSine(N_steps, normalize=True)
+    elif args.position_embedding in ('v3', 'learned'):
+        position_embedding = PositionEmbeddingLearned(N_steps)
+    else:
+        raise ValueError(f"not supported {args.position_embedding}")
+
+    return position_embedding

demo/act/detr/transformer.py

@@ -0,0 +1,455 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+DETR Transformer class.
+
+Copy-paste from torch.nn.Transformer with modifications:
+    * positional encodings are passed in MHattention
+    * extra LN at the end of encoder is removed
+    * decoder returns a stack of activations from all decoding layers
+"""
+import copy
+from typing import Optional, List
+
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+
+class Transformer(nn.Module):
+
+    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
+                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False,
+                 return_intermediate_dec=False, use_xsa=False):
+        super().__init__()
+
+        encoder_cls = XSATransformerEncoderLayer if use_xsa else TransformerEncoderLayer
+        decoder_cls = XSATransformerDecoderLayer if use_xsa else TransformerDecoderLayer
+
+        encoder_layer = encoder_cls(d_model, nhead, dim_feedforward,
+                                    dropout, activation, normalize_before)
+        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+        decoder_layer = decoder_cls(d_model, nhead, dim_feedforward,
+                                    dropout, activation, normalize_before)
+        decoder_norm = nn.LayerNorm(d_model)
+        self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
+                                          return_intermediate=return_intermediate_dec)
+
+        self._reset_parameters()
+
+        self.d_model = d_model
+        self.nhead = nhead
+
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def forward(self, src, mask, query_embed, pos_embed, latent_input=None, proprio_input=None, additional_pos_embed=None):
+        if src is None:
+            bs = proprio_input.shape[0]
+            query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+            pos_embed = additional_pos_embed.unsqueeze(1).repeat(1, bs, 1) # seq, bs, dim
+            src = torch.stack([latent_input, proprio_input], axis=0)
+        # TODO flatten only when input has H and W
+        elif len(src.shape) == 4: # has H and W
+            # flatten NxCxHxW to HWxNxC
+            bs, c, h, w = src.shape
+            src = src.flatten(2).permute(2, 0, 1)
+            pos_embed = pos_embed.flatten(2).permute(2, 0, 1).repeat(1, bs, 1)
+            query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+            # mask = mask.flatten(1)
+
+            additional_pos_embed = additional_pos_embed.unsqueeze(1).repeat(1, bs, 1) # seq, bs, dim
+            pos_embed = torch.cat([additional_pos_embed, pos_embed], axis=0)
+
+            addition_input = torch.stack([latent_input, proprio_input], axis=0)
+            src = torch.cat([addition_input, src], axis=0)
+
+        tgt = torch.zeros_like(query_embed)
+        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
+        hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
+                          pos=pos_embed, query_pos=query_embed)
+        hs = hs.transpose(1, 2)
+        return hs
+
+
+class TransformerEncoder(nn.Module):
+
+    def __init__(self, encoder_layer, num_layers, norm=None):
+        super().__init__()
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(self, src,
+                mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        output = src
+
+        for layer in self.layers:
+            output = layer(output, src_mask=mask,
+                           src_key_padding_mask=src_key_padding_mask, pos=pos)
+
+        if self.norm is not None:
+            output = self.norm(output)
+
+        return output
+
+
+class TransformerDecoder(nn.Module):
+
+    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
+        super().__init__()
+        self.layers = _get_clones(decoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+        self.return_intermediate = return_intermediate
+
+    def forward(self, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        output = tgt
+
+        intermediate = []
+
+        for layer in self.layers:
+            output = layer(output, memory, tgt_mask=tgt_mask,
+                           memory_mask=memory_mask,
+                           tgt_key_padding_mask=tgt_key_padding_mask,
+                           memory_key_padding_mask=memory_key_padding_mask,
+                           pos=pos, query_pos=query_pos)
+            if self.return_intermediate:
+                intermediate.append(self.norm(output))
+
+        if self.norm is not None:
+            output = self.norm(output)
+            if self.return_intermediate:
+                intermediate.pop()
+                intermediate.append(output)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate)
+
+        return output.unsqueeze(0)
+
+
+class TransformerEncoderLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self,
+                     src,
+                     src_mask: Optional[Tensor] = None,
+                     src_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(src, pos)
+        src2 = self.self_attn(q, k, value=src, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src = self.norm1(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
+        src = src + self.dropout2(src2)
+        src = self.norm2(src)
+        return src
+
+    def forward_pre(self, src,
+                    src_mask: Optional[Tensor] = None,
+                    src_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None):
+        src2 = self.norm1(src)
+        q = k = self.with_pos_embed(src2, pos)
+        src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src2 = self.norm2(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
+        src = src + self.dropout2(src2)
+        return src
+
+    def forward(self, src,
+                src_mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
+        return self.forward_post(src, src_mask, src_key_padding_mask, pos)
+
+
+class TransformerDecoderLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self, tgt, memory,
+                     tgt_mask: Optional[Tensor] = None,
+                     memory_mask: Optional[Tensor] = None,
+                     tgt_key_padding_mask: Optional[Tensor] = None,
+                     memory_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None,
+                     query_pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(tgt, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt = self.norm1(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout3(tgt2)
+        tgt = self.norm3(tgt)
+        return tgt
+
+    def forward_pre(self, tgt, memory,
+                    tgt_mask: Optional[Tensor] = None,
+                    memory_mask: Optional[Tensor] = None,
+                    tgt_key_padding_mask: Optional[Tensor] = None,
+                    memory_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None,
+                    query_pos: Optional[Tensor] = None):
+        tgt2 = self.norm1(tgt)
+        q = k = self.with_pos_embed(tgt2, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt2 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt
+
+    def forward(self, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(tgt, memory, tgt_mask, memory_mask,
+                                    tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
+        return self.forward_post(tgt, memory, tgt_mask, memory_mask,
+                                 tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos)
+
+
+class _XSAAttention(nn.Module):
+    """XSA self-attention block adapted from the local LeRobot act_xsa plugin."""
+
+    def __init__(self, d_model, nhead, dropout=0.1):
+        super().__init__()
+        if d_model % nhead != 0:
+            raise ValueError(f"d_model={d_model} must be divisible by nhead={nhead}")
+        self.nhead = nhead
+        self.head_dim = d_model // nhead
+        self.scale = self.head_dim ** -0.5
+
+        self.q_proj = nn.Linear(d_model, d_model)
+        self.k_proj = nn.Linear(d_model, d_model)
+        self.v_proj = nn.Linear(d_model, d_model)
+        self.out_proj = nn.Linear(d_model, d_model)
+        self.gate_proj = nn.Linear(d_model, nhead)
+        self.q_norm = nn.RMSNorm(self.head_dim)
+        self.k_norm = nn.RMSNorm(self.head_dim)
+        self.dropout = nn.Dropout(dropout)
+
+    @staticmethod
+    def with_pos_embed(tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward(self, x, pos: Optional[Tensor] = None,
+                attn_mask: Optional[Tensor] = None,
+                key_padding_mask: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(x, pos)
+        q = self.q_proj(q)
+        k = self.k_proj(k)
+        v = self.v_proj(x)
+
+        seq_len, batch_size, _ = q.shape
+        q = q.view(seq_len, batch_size, self.nhead, self.head_dim).permute(1, 2, 0, 3)
+        k = k.view(seq_len, batch_size, self.nhead, self.head_dim).permute(1, 2, 0, 3)
+        v = v.view(seq_len, batch_size, self.nhead, self.head_dim).permute(1, 2, 0, 3)
+
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+        attn_weights = torch.matmul(q, k.transpose(-2, -1)) * self.scale
+        if attn_mask is not None:
+            attn_weights = attn_weights + attn_mask
+        if key_padding_mask is not None:
+            attn_weights = attn_weights.masked_fill(
+                key_padding_mask.unsqueeze(1).unsqueeze(2), float("-inf")
+            )
+        attn_weights = F.softmax(attn_weights, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+
+        y = torch.matmul(attn_weights, v)
+        v_norm = F.normalize(v, dim=-1)
+        projection = (y * v_norm).sum(dim=-1, keepdim=True)
+        y = y - projection * v_norm
+
+        gate = self.gate_proj(x).sigmoid().permute(1, 2, 0).unsqueeze(-1)
+        y = y * gate
+        y = y.permute(2, 0, 1, 3).contiguous().view(seq_len, batch_size, -1)
+        return self.out_proj(y)
+
+
+class XSATransformerEncoderLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = _XSAAttention(d_model, nhead, dropout=dropout)
+        self.linear1 = nn.Linear(d_model, dim_feedforward * 2)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+        self.norm1 = nn.RMSNorm(d_model)
+        self.norm2 = nn.RMSNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+    def forward(self, src,
+                src_mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        skip = src
+        src2 = self.norm1(src)
+        src = skip + self.dropout1(
+            self.self_attn(src2, pos=pos, attn_mask=src_mask,
+                           key_padding_mask=src_key_padding_mask)
+        )
+        skip = src
+        src2 = self.norm2(src)
+        gate, value = self.linear1(src2).chunk(2, dim=-1)
+        src2 = self.linear2(self.dropout(F.silu(gate) * value))
+        src = skip + self.dropout2(src2)
+        return src
+
+
+class XSATransformerDecoderLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = _XSAAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.linear1 = nn.Linear(d_model, dim_feedforward * 2)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+        self.norm1 = nn.RMSNorm(d_model)
+        self.norm2 = nn.RMSNorm(d_model)
+        self.norm3 = nn.RMSNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+    @staticmethod
+    def with_pos_embed(tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward(self, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        skip = tgt
+        tgt2 = self.norm1(tgt)
+        tgt = skip + self.dropout1(
+            self.self_attn(tgt2, pos=query_pos, attn_mask=tgt_mask,
+                           key_padding_mask=tgt_key_padding_mask)
+        )
+
+        skip = tgt
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = skip + self.dropout2(tgt2)
+
+        skip = tgt
+        tgt2 = self.norm3(tgt)
+        gate, value = self.linear1(tgt2).chunk(2, dim=-1)
+        tgt2 = self.linear2(self.dropout(F.silu(gate) * value))
+        tgt = skip + self.dropout3(tgt2)
+        return tgt
+
+
+def _get_clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+def build_transformer(args):
+    return Transformer(
+        d_model=args.hidden_dim,
+        dropout=args.dropout,
+        nhead=args.nheads,
+        dim_feedforward=args.dim_feedforward,
+        num_encoder_layers=args.enc_layers,
+        num_decoder_layers=args.dec_layers,
+        normalize_before=args.pre_norm,
+        return_intermediate_dec=True,
+        use_xsa=getattr(args, "use_xsa", False),
+    )
+
+
+def _get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(F"activation should be relu/gelu, not {activation}.")

demo/act/detr/utils.py

@@ -0,0 +1,161 @@
+from torch.utils.data.sampler import Sampler
+import numpy as np
+import torch
+import torch.distributed as dist
+from torch import Tensor
+from h5py import File, Group, Dataset
+from typing import Optional
+
+
+class NestedTensor(object):
+    def __init__(self, tensors, mask: Optional[Tensor]):
+        self.tensors = tensors
+        self.mask = mask
+
+    def to(self, device):
+        # type: (Device) -> NestedTensor # noqa
+        cast_tensor = self.tensors.to(device)
+        mask = self.mask
+        if mask is not None:
+            assert mask is not None
+            cast_mask = mask.to(device)
+        else:
+            cast_mask = None
+        return NestedTensor(cast_tensor, cast_mask)
+
+    def decompose(self):
+        return self.tensors, self.mask
+
+    def __repr__(self):
+        return str(self.tensors)
+    
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+def is_main_process():
+    return get_rank() == 0
+    
+
+class IterationBasedBatchSampler(Sampler):
+    """Wraps a BatchSampler.
+    Resampling from it until a specified number of iterations have been sampled
+    References:
+        https://github.com/facebookresearch/maskrcnn-benchmark/blob/master/maskrcnn_benchmark/data/samplers/iteration_based_batch_sampler.py
+    """
+
+    def __init__(self, batch_sampler, num_iterations, start_iter=0):
+        self.batch_sampler = batch_sampler
+        self.num_iterations = num_iterations
+        self.start_iter = start_iter
+
+    def __iter__(self):
+        iteration = self.start_iter
+        while iteration < self.num_iterations:
+            # if the underlying sampler has a set_epoch method, like
+            # DistributedSampler, used for making each process see
+            # a different split of the dataset, then set it
+            if hasattr(self.batch_sampler.sampler, "set_epoch"):
+                self.batch_sampler.sampler.set_epoch(iteration)
+            for batch in self.batch_sampler:
+                yield batch
+                iteration += 1
+                if iteration >= self.num_iterations:
+                    break
+
+    def __len__(self):
+        return self.num_iterations - self.start_iter
+
+
+def worker_init_fn(worker_id, base_seed=None):
+    """The function is designed for pytorch multi-process dataloader.
+    Note that we use the pytorch random generator to generate a base_seed.
+    Please try to be consistent.
+    References:
+        https://pytorch.org/docs/stable/notes/faq.html#dataloader-workers-random-seed
+    """
+    if base_seed is None:
+        base_seed = torch.IntTensor(1).random_().item()
+    # print(worker_id, base_seed)
+    np.random.seed(base_seed + worker_id)
+
+TARGET_KEY_TO_SOURCE_KEY = {
+    'states': 'env_states',
+    'observations': 'obs',
+    'success': 'success',
+    'next_observations': 'obs',
+    # 'dones': 'dones',
+    # 'rewards': 'rewards',
+    'actions': 'actions',
+}
+def load_content_from_h5_file(file):
+    if isinstance(file, (File, Group)):
+        return {key: load_content_from_h5_file(file[key]) for key in list(file.keys())}
+    elif isinstance(file, Dataset):
+        return file[()]
+    else:
+        raise NotImplementedError(f"Unspported h5 file type: {type(file)}")
+
+def load_hdf5(path, ):
+    print('Loading HDF5 file', path)
+    file = File(path, 'r')
+    ret = load_content_from_h5_file(file)
+    file.close()
+    print('Loaded')
+    return ret
+
+def load_traj_hdf5(path, num_traj=None):
+    print('Loading HDF5 file', path)
+    file = File(path, 'r')
+    keys = list(file.keys())
+    if num_traj is not None:
+        assert num_traj <= len(keys), f"num_traj: {num_traj} > len(keys): {len(keys)}"
+        keys = sorted(keys, key=lambda x: int(x.split('_')[-1]))
+        keys = keys[:num_traj]
+    ret = {
+        key: load_content_from_h5_file(file[key]) for key in keys
+    }
+    file.close()
+    print('Loaded')
+    return ret
+def load_demo_dataset(path, keys=['observations', 'actions'], num_traj=None, concat=True):
+    # assert num_traj is None
+    raw_data = load_traj_hdf5(path, num_traj)
+    # raw_data has keys like: ['traj_0', 'traj_1', ...]
+    # raw_data['traj_0'] has keys like: ['actions', 'dones', 'env_states', 'infos', ...]
+    _traj = raw_data['traj_0']
+    for key in keys:
+        source_key = TARGET_KEY_TO_SOURCE_KEY[key]
+        assert source_key in _traj, f"key: {source_key} not in traj_0: {_traj.keys()}"
+    dataset = {}
+    for target_key in keys:
+        # if 'next' in target_key:
+        #     raise NotImplementedError('Please carefully deal with the length of trajectory')
+        source_key = TARGET_KEY_TO_SOURCE_KEY[target_key]
+        dataset[target_key] = [ raw_data[idx][source_key] for idx in raw_data ]
+        if isinstance(dataset[target_key][0], np.ndarray) and concat:
+            if target_key in ['observations', 'states'] and \
+                    len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']):
+                dataset[target_key] = np.concatenate([
+                    t[:-1] for t in dataset[target_key]
+                ], axis=0)
+            elif target_key in ['next_observations', 'next_states'] and \
+                    len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']):
+                dataset[target_key] = np.concatenate([
+                    t[1:] for t in dataset[target_key]
+                ], axis=0)
+            else:
+                dataset[target_key] = np.concatenate(dataset[target_key], axis=0)
+
+            print('Load', target_key, dataset[target_key].shape)
+        else:
+            print('Load', target_key, len(dataset[target_key]), type(dataset[target_key][0]))
+    return dataset

scripts/act/baseline.sh

@@ -0,0 +1,27 @@
+seed=1
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+demo_path="$SCRIPT_DIR/../../datasets/atec_task_e/trajectory_filtered.hdf5"
+
+echo "$demo_path"
+total_iters=100000
+batch_size=256
+log_freq=1000
+save_freq=10000
+wandb_entity=""
+
+
+# RGB based
+for demos in 100; do
+  python train_task_e.py \
+    --demo_path $demo_path \
+    --num_demos $demos \
+    --include_rgb \
+    --total_iters $total_iters \
+    --batch_size $batch_size \
+    --log_freq $log_freq \
+    --save_freq $save_freq \
+    --seed $seed \
+    --exp_name act-task-e-rgb-${demos}demos-seed${seed} \
+    --wandb_entity $wandb_entity \
+    --track
+done

scripts/act/cli_args.py

@@ -0,0 +1,48 @@
+"""CLI argument definitions for Task E demo collection.
+"""
+
+
+def add_collect_demo_args(parser) -> None:
+    parser.add_argument(
+        "--num_demos", type=int, default=50,
+        help="Number of successful demos to collect.",
+    )
+    parser.add_argument(
+        "--output_dir", type=str, default="./datasets/atec_task_e",
+        help="Directory to save trajectory.hdf5 and trajectory.json.",
+    )
+    parser.add_argument(
+        "--pick_objects", type=int, nargs="+", default=[3, 2, 1],
+        metavar="N",
+        help="Which objects to pick, in execution order. Default clears near-to-far: 3 2 1.",
+    )
+    parser.add_argument(
+        "--save_video", action="store_true", default=False,
+        help="Save an MP4 per demo for visualization "
+             "(requires: pip install imageio imageio-ffmpeg).",
+    )
+    parser.add_argument(
+        "--video_dir", type=str, default=None,
+        help="Output directory for MP4 files. Defaults to <output_dir>/videos/.",
+    )
+    parser.add_argument(
+        "--save_images", action="store_true", default=False,
+        help="Save raw RGB frames into HDF5 under traj_N/images/rgb (T,H,W,3) "
+             "for ACT RGBD training. Shares the camera with --save_video.",
+    )
+    parser.add_argument(
+        "--only_success", action="store_true", default=False,
+        help="Discard demos where not all picked objects ended up in the basket.",
+    )
+    parser.add_argument(
+        "--max_attempts", type=int, default=0,
+        help="Stop after this many attempts even if num_demos is not reached. 0 means unlimited.",
+    )
+    parser.add_argument(
+        "--trace", action="store_true", default=False,
+        help="Print compact grasp/basket diagnostics for failed scripted demos.",
+    )
+    parser.add_argument(
+        "--abort_failed_lift", action="store_true", default=False,
+        help="Abort an attempt as soon as the current object fails the post-LIFT height gate.",
+    )

scripts/act/collect_demos_task_e.py

@@ -0,0 +1,229 @@
+"""Scripted oracle data collection for Task E (pick-and-place).
+
+Usage
+-----
+# NOTE: only for object 3 now, if you want to pick objects 1 and 2, please modify the distance accordingly.
+python scripts/act/collect_demos_task_e.py --pick_objects 3 --num_demos 50 --headless
+
+"""
+
+import argparse
+import os
+import sys
+
+# sys.path.insert(0, os.path.dirname(__file__))
+
+from isaaclab.app import AppLauncher
+from cli_args import add_collect_demo_args
+
+parser = argparse.ArgumentParser(description="Collect Task E demonstrations for ACT.")
+add_collect_demo_args(parser)
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+
+if args_cli.save_video or args_cli.save_images:
+    args_cli.enable_cameras = True
+
+app_launcher   = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+import h5py
+import json
+import numpy as np
+
+from isaaclab.actuators import ImplicitActuatorCfg
+from isaaclab.envs import ManagerBasedRLEnv
+from isaaclab.sensors import CameraCfg
+import isaaclab.sim as sim_utils
+
+from atec_rl_lab.tasks.task_e.env_cfg import TaskEEnvPiperCfg
+from atec_rl_lab.utils import CartesianController
+
+from task_e.config import (
+    EE_BODY_NAME, ARM_JOINT_NAMES, GRIPPER_JOINT_NAMES,
+    ACT_STIFFNESS, ACT_DAMPING, ACT_EFFORT_LIMIT, ACT_VEL_LIMIT,
+    CAM_H, CAM_W, CAM_POS, CAM_ROT,
+)
+from task_e.collector import basket_status_lines, check_objects_in_basket, collect_one_demo
+
+
+def _trace_lines(data: dict | None, pick_objects: list[int]) -> list[str]:
+    if data is None or "trace" not in data:
+        return []
+    lines = []
+    for obj_idx in pick_objects:
+        tr = data["trace"].get(f"object_{obj_idx}", {})
+        if not tr:
+            continue
+        states = tr.get("states", {})
+        close = states.get("CLOSE", {})
+        lift = states.get("LIFT", {})
+        transport = states.get("TRANSPORT", {})
+        def _vec(value):
+            if value is None:
+                return "none"
+            return "(" + ",".join(f"{float(v):+.3f}" for v in value[:3]) + ")"
+        lines.append(
+            f"object_{obj_idx}: z_gain={float(tr.get('z_gain', 0.0)):.3f} "
+            f"lifted={tr.get('lifted')} reward_lifted={tr.get('reward_lifted')} "
+            f"gap_close={float(close.get('min_gripper_gap', 999.0)):.3f} "
+            f"finger_close={float(close.get('min_finger_center_dist', 999.0)):.3f} "
+            f"finger_vec_close={_vec(close.get('min_finger_center_vec'))} "
+            f"gap_lift={float(lift.get('min_gripper_gap', 999.0)):.3f} "
+            f"finger_gap={float(lift.get('min_finger_body_gap', 999.0)):.3f} "
+            f"finger_lift={float(lift.get('min_finger_center_dist', 999.0)):.3f} "
+            f"finger_vec_lift={_vec(lift.get('min_finger_center_vec'))} "
+            f"finger_transport={float(transport.get('min_finger_center_dist', 999.0)):.3f} "
+            f"ee_vec_lift={_vec(lift.get('min_ee_vec'))} "
+            f"basket_inside={tr.get('basket_inside')}"
+        )
+    return lines
+
+
+def build_env(pick_objects: list[int], need_camera: bool) -> ManagerBasedRLEnv:
+    import time
+    cfg = TaskEEnvPiperCfg()
+    cfg.seed              = int(time.time_ns() % (2**31))   # random seed each call
+    cfg.scene.num_envs    = 1
+    cfg.episode_length_s  = 80.0 * len(pick_objects) + 30.0
+    if not need_camera:
+        cfg.scene.video_cam = None
+        cfg.scene.ee_camera = None
+        cfg.scene.ee_dual_camera = None
+        cfg.scene.head_camera = None
+        cfg.observations.image = None
+    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,
+    )
+    # if need_camera:
+    #     cfg.scene.video_cam = CameraCfg(
+    #         prim_path="{ENV_REGEX_NS}/video_cam",
+    #         update_period=0.0,
+    #         height=CAM_H, width=CAM_W,
+    #         data_types=["rgb"],
+    #         spawn=sim_utils.PinholeCameraCfg(
+    #             focal_length=24.0, focus_distance=400.0,
+    #             horizontal_aperture=20.955, clipping_range=(0.1, 100.0),
+    #         ),
+    #         offset=CameraCfg.OffsetCfg(pos=CAM_POS, rot=CAM_ROT, convention="world"),
+    #     )
+    return ManagerBasedRLEnv(cfg)
+
+
+def init_output(output_dir: str) -> tuple[str, str]:
+    """Create output directory, wipe any existing trajectory.hdf5, write JSON metadata."""
+    os.makedirs(output_dir, exist_ok=True)
+    traj_path = os.path.join(output_dir, "trajectory.hdf5")
+    json_path = os.path.join(output_dir, "trajectory.json")
+    with h5py.File(traj_path, "w"):   # truncate / create fresh
+        pass
+    with open(json_path, "w") as fh:
+        json.dump({"env_info": {"env_kwargs": {"control_mode": "pd_joint_pos"}}}, fh)
+    return traj_path, json_path
+
+
+def save_traj(traj_path: str, traj_idx: int, data: dict,
+              save_images: bool) -> None:
+    """Append one trajectory group to the consolidated HDF5."""
+    with h5py.File(traj_path, "a") as f:
+        grp = f.create_group(f"traj_{traj_idx}")
+        grp.create_dataset("obs",     data=data["qpos"],    compression="gzip")
+        grp.create_dataset("actions", data=data["action"],  compression="gzip")
+        grp.create_dataset("qvel",    data=data["qvel"],    compression="gzip")
+        grp.create_dataset("ee_pos",  data=data["ee_pos"],  compression="gzip")
+        grp.create_dataset("ee_quat", data=data["ee_quat"], compression="gzip")
+        if save_images and "frames" in data:
+            grp.create_group("images").create_dataset(
+                "rgb", data=data["frames"], compression="gzip"
+            )
+
+
+def main() -> None:
+    pick_objects = list(dict.fromkeys(args_cli.pick_objects))
+    need_camera = args_cli.save_video or args_cli.save_images
+
+    env    = build_env(pick_objects, need_camera)
+    dev    = env.unwrapped.device
+    camera = env.unwrapped.scene["video_cam"] if need_camera else None
+
+    robot = env.unwrapped.scene.articulations["robot"]
+    arm_ids,     _ = robot.find_joints(ARM_JOINT_NAMES)
+    gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES)
+    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.2,
+    )
+    default_jpos = robot.data.default_joint_pos.clone()
+
+    video_dir = None
+    imageio   = None
+    if args_cli.save_video:
+        video_dir = args_cli.video_dir or os.path.join(args_cli.output_dir, "videos")
+        os.makedirs(video_dir, exist_ok=True)
+        import imageio as _io
+        imageio = _io
+
+    traj_path, _ = init_output(args_cli.output_dir)
+    rng = np.random.default_rng()   # unseeded → different positions every run
+
+    n_ok = 0
+    attempt = 0
+    while n_ok < args_cli.num_demos:
+        attempt += 1
+        if args_cli.max_attempts and attempt > args_cli.max_attempts:
+            print(f"\n[WARN] Reached --max_attempts={args_cli.max_attempts}; collected {n_ok} demos.")
+            break
+        print(f"\n[INFO] Demo {n_ok + 1}/{args_cli.num_demos}  (attempt {attempt})")
+
+        data = collect_one_demo(
+            env, robot, ik_ctrl,
+            arm_ids, gripper_ids,
+            pick_objects, dev,
+            default_jpos=default_jpos,
+            rng=rng,
+            camera=camera,
+            trace=args_cli.trace,
+            abort_failed_lift=args_cli.abort_failed_lift,
+        )
+        if data is None:
+            print("[WARN] Early termination — skipping.")
+            continue
+
+        if args_cli.only_success and not check_objects_in_basket(env, pick_objects):
+            print("[WARN] Objects not in basket — skipping (--only_success).")
+            for line in basket_status_lines(env, pick_objects):
+                print(f"[WARN] {line}")
+            for line in _trace_lines(data, pick_objects):
+                print(f"[TRACE] {line}")
+            continue
+
+        for line in _trace_lines(data, pick_objects):
+            print(f"[TRACE] {line}")
+        save_traj(traj_path, n_ok, data, args_cli.save_images)
+
+        T     = len(data["qpos"])
+        notes = [f"{T} steps"]
+        if args_cli.save_video and "frames" in data:
+            vp = os.path.join(video_dir, f"demo_{n_ok:04d}.mp4")
+            imageio.mimwrite(vp, data["frames"], fps=50, quality=7)
+            notes.append(f"video → {vp}")
+        if args_cli.save_images and "frames" in data:
+            notes.append("images saved")
+        print(f"[INFO] traj_{n_ok}: {', '.join(notes)}")
+        n_ok += 1
+
+    print(f"\n[INFO] Collected {n_ok} demos → {traj_path}")
+    env.close()
+
+
+if __name__ == "__main__":
+    main()
+    simulation_app.close()

scripts/act/eval_task_e_act.py

@@ -0,0 +1,191 @@
+"""Rollout evaluation for the Task-E ACT policy checkpoint."""
+
+import argparse
+import os
+import sys
+import time
+from datetime import datetime
+
+from isaaclab.app import AppLauncher
+
+
+parser = argparse.ArgumentParser(description="Evaluate ACT checkpoint on ATEC Task E.")
+parser.add_argument(
+    "--checkpoint",
+    type=str,
+    default="runs/act-task-e-rgb-100demos-seed1/checkpoints/best_loss.pt",
+    help="ACT checkpoint path.",
+)
+parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper")
+parser.add_argument("--episodes", type=int, default=3)
+parser.add_argument("--max_steps", type=int, default=1500)
+parser.add_argument("--video_path", type=str, default=None, help="Optional MP4 output path for episode 1.")
+parser.add_argument("--video_interval", type=int, default=2, help="Record every N env steps.")
+parser.add_argument("--video_fps", type=int, default=25)
+parser.add_argument("--seed", type=int, default=None)
+parser.add_argument("--disable_fabric", action="store_true", default=False)
+parser.add_argument("--debug", action="store_true", default=False)
+parser.add_argument(
+    "--solution_module",
+    type=str,
+    default="solution_act",
+    help="Module under demo/ that provides AlgSolution, e.g. solution_act or solution_pca.",
+)
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+args_cli.enable_cameras = True
+
+repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+checkpoint = os.path.abspath(args_cli.checkpoint)
+os.environ["ATEC_ACT_POLICY_PATH"] = checkpoint
+
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+import gymnasium as gym  # noqa: E402
+import torch  # noqa: E402
+
+from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
+from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402
+
+import atec_rl_lab.tasks  # noqa: F401, E402
+
+demo_dir = os.path.join(repo_root, "demo")
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+if demo_dir not in sys.path:
+    sys.path.insert(0, demo_dir)
+from scripts.act.task_e.collector import basket_status_lines  # noqa: E402
+import importlib  # noqa: E402
+
+AlgSolution = importlib.import_module(args_cli.solution_module).AlgSolution
+
+
+def _frame_from_obs(obs) -> object:
+    rgb = obs["image"]["video_rgb"]
+    if isinstance(rgb, torch.Tensor):
+        frame = rgb[0].detach().cpu()
+        if frame.ndim == 3 and frame.shape[0] in (3, 4):
+            frame = frame.permute(1, 2, 0)
+        if frame.shape[-1] == 4:
+            frame = frame[..., :3]
+        if frame.dtype != torch.uint8:
+            frame = (frame.float() * 255.0).clamp(0, 255).to(torch.uint8)
+        return frame.numpy()
+    return rgb[0]
+
+
+def _resolve_video_path() -> str | None:
+    if args_cli.video_path is None:
+        return None
+    if args_cli.video_path:
+        return os.path.abspath(args_cli.video_path)
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return os.path.join(repo_root, "logs", "videos", "task_e_act_eval", f"eval_{stamp}.mp4")
+
+
+def evaluate() -> list[dict[str, float]]:
+    if not os.path.exists(checkpoint):
+        raise FileNotFoundError(f"Checkpoint not found: {checkpoint}")
+
+    env_cfg = parse_env_cfg(
+        args_cli.task,
+        device=args_cli.device,
+        num_envs=1,
+        use_fabric=not args_cli.disable_fabric,
+    )
+    if args_cli.seed is not None:
+        env_cfg.seed = args_cli.seed
+    env = gym.make(args_cli.task, cfg=env_cfg)
+    if isinstance(env.unwrapped, DirectMARLEnv):
+        env = multi_agent_to_single_agent(env)
+
+    policy = AlgSolution()
+    video_path = _resolve_video_path()
+    writer = None
+    if video_path is not None:
+        import imageio.v2 as imageio
+
+        os.makedirs(os.path.dirname(video_path), exist_ok=True)
+        writer = imageio.get_writer(video_path, fps=args_cli.video_fps, quality=7)
+        print(f"[INFO] Recording episode 1 video to: {video_path}")
+
+    results = []
+    try:
+        for episode in range(args_cli.episodes):
+            reset_kwargs = {"seed": args_cli.seed + episode} if args_cli.seed is not None else {}
+            obs, _ = env.reset(**reset_kwargs)
+            policy.reset_episode()
+            total_reward = 0.0
+            elapsed_time = 0.0
+            steps = 0
+            done = False
+            start_wall = time.time()
+            if writer is not None and episode == 0:
+                writer.append_data(_frame_from_obs(obs))
+
+            while simulation_app.is_running() and steps < args_cli.max_steps:
+                with torch.inference_mode():
+                    resp = policy.predicts(obs, total_reward)
+                    if resp["giveup"]:
+                        break
+                    action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1)
+                    obs, reward, terminated, truncated, info = env.step(action)
+
+                sim_dt = info["Step_dt"]
+                total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt
+                if isinstance(info, dict) and "Elapsed_Time" in info:
+                    elapsed = info["Elapsed_Time"]
+                    elapsed_time = elapsed.item() if hasattr(elapsed, "item") else float(elapsed)
+                else:
+                    elapsed_time += env.unwrapped.step_dt
+
+                done = bool(terminated.item() or truncated.item())
+                steps += 1
+                if writer is not None and episode == 0 and steps % max(1, args_cli.video_interval) == 0:
+                    writer.append_data(_frame_from_obs(obs))
+                if args_cli.debug and steps % 100 == 0:
+                    print(f"[DEBUG] episode={episode + 1} step={steps} score={total_reward:.2f}")
+                if done:
+                    break
+
+            result = {
+                "episode": episode + 1,
+                "score": float(total_reward),
+                "elapsed_time": float(elapsed_time),
+                "steps": float(steps),
+                "done": float(done),
+                "wall_time": time.time() - start_wall,
+            }
+            results.append(result)
+            try:
+                for line in basket_status_lines(env, [1, 2, 3]):
+                    print(f"[BASKET] episode={episode + 1} {line}")
+            except Exception as exc:
+                if args_cli.debug:
+                    print(f"[DEBUG] basket status unavailable: {exc}")
+            print(
+                "[RESULT] "
+                f"episode={result['episode']:.0f} "
+                f"score={result['score']:.2f} "
+                f"elapsed_time={result['elapsed_time']:.2f} "
+                f"steps={result['steps']:.0f} "
+                f"done={bool(result['done'])} "
+                f"wall_time={result['wall_time']:.1f}s"
+            )
+    finally:
+        if writer is not None:
+            writer.close()
+        env.close()
+
+    return results
+
+
+if __name__ == "__main__":
+    try:
+        results = evaluate()
+        if results:
+            scores = torch.tensor([r["score"] for r in results], dtype=torch.float32)
+            print(f"[SUMMARY] episodes={len(results)} mean_score={scores.mean().item():.2f} best_score={scores.max().item():.2f}")
+    finally:
+        simulation_app.close()

scripts/act/filter_demos.py

@@ -0,0 +1,99 @@
+"""Filter HDF5 trajectory data: remove timesteps where the robot is not moving.
+
+Uses consecutive action differences: steps where max|action[t] - action[t-1]| < threshold
+are considered stationary and removed.
+
+Usage:
+    python scripts/act/filter_demos.py \
+        --input datasets/atec_task_e/trajectory.hdf5 \
+        --output datasets/atec_task_e/trajectory_filtered.hdf5 \
+        --threshold 0.001
+"""
+
+import argparse
+import h5py
+import numpy as np
+
+
+def compute_moving_mask(actions, threshold):
+    """Return a boolean mask (length T) marking steps where the robot is moving.
+
+    A step is 'moving' if max|action[t] - action[t-1]| >= threshold.
+    """
+    delta = np.zeros_like(actions)
+    delta[1:] = np.abs(actions[1:] - actions[:-1])
+    return delta.max(axis=1) >= threshold
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Filter stationary steps from demo HDF5.")
+    parser.add_argument("--input", type=str, required=True, help="Input HDF5 path")
+    parser.add_argument("--output", type=str, required=True, help="Output HDF5 path")
+    parser.add_argument("--threshold", type=float, default=0.001,
+                        help="Steps with max|action_delta| < threshold are removed (default: 0.001)")
+    parser.add_argument("--dry_run", action="store_true",
+                        help="Only print statistics, don't write output")
+    args = parser.parse_args()
+
+    total_before = 0
+    total_after  = 0
+
+    with h5py.File(args.input, "r") as fin:
+        traj_keys = sorted(fin.keys(), key=lambda k: int(k.split("_")[1]))
+
+        if args.dry_run:
+            print(f"{'traj':>10s}  {'before':>7s}  {'after':>7s}  {'removed':>7s}  {'removed%':>8s}")
+            for key in traj_keys:
+                actions = fin[key]["actions"][:]
+                mask = compute_moving_mask(actions, args.threshold)
+                n_before = len(actions)
+                n_after  = mask.sum()
+                total_before += n_before
+                total_after  += n_after
+                print(f"{key:>10s}  {n_before:7d}  {n_after:7d}  "
+                      f"{n_before - n_after:7d}  {(1 - n_after/n_before)*100:7.1f}%")
+            print(f"\nTotal: {total_before} → {total_after} "
+                  f"(removed {total_before - total_after}, "
+                  f"{(1 - total_after/total_before)*100:.1f}%)")
+            return
+
+        with h5py.File(args.output, "w") as fout:
+            for key in traj_keys:
+                grp_in = fin[key]
+                actions = grp_in["actions"][:]
+                mask = compute_moving_mask(actions, args.threshold)
+
+                n_before = len(actions)
+                n_after  = mask.sum()
+                total_before += n_before
+                total_after  += n_after
+
+                grp_out = fout.create_group(key)
+
+                # Filter all (T, ...) datasets with the same mask
+                for ds_name in grp_in.keys():
+                    if ds_name == "images":
+                        # Handle nested image group
+                        img_grp = grp_out.create_group("images")
+                        for img_key in grp_in["images"].keys():
+                            data = grp_in[f"images/{img_key}"][:]
+                            img_grp.create_dataset(img_key, data=data[mask], compression="gzip")
+                    elif isinstance(grp_in[ds_name], h5py.Dataset):
+                        data = grp_in[ds_name][:]
+                        if data.shape[0] == n_before:
+                            grp_out.create_dataset(ds_name, data=data[mask], compression="gzip")
+                        else:
+                            # Non-temporal dataset, copy as-is
+                            grp_out.create_dataset(ds_name, data=data, compression="gzip")
+
+                print(f"  {key}: {n_before} → {n_after} steps "
+                      f"(removed {n_before - n_after})")
+
+    print(f"\nTotal: {total_before} → {total_after} "
+          f"(removed {total_before - total_after}, "
+          f"{(1 - total_after/total_before)*100:.1f}%)")
+    print(f"Saved to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

scripts/act/run_task_e_pipeline.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+PYTHON="${PYTHON:-/home/ubuntu/envs/genmanip-isaac5-py311/bin/python}"
+ISAACLAB_SITE="/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source"
+
+export OMNI_KIT_ACCEPT_EULA=YES
+export PYTHONUNBUFFERED=1
+export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0}"
+export PYTHONPATH="${ISAACLAB_SITE}/isaaclab:${ISAACLAB_SITE}/isaaclab_tasks:${ISAACLAB_SITE}/isaaclab_assets:${ISAACLAB_SITE}/isaaclab_rl:${ISAACLAB_SITE}/isaaclab_mimic:${ROOT_DIR}/source/atec_rl_lab:${ROOT_DIR}/scripts/act:${PYTHONPATH:-}"
+
+cd "$ROOT_DIR"
+
+DATA_DIR="${DATA_DIR:-datasets/atec_task_e}"
+NUM_DEMOS="${NUM_DEMOS:-100}"
+PICK_OBJECTS="${PICK_OBJECTS:-3 2 1}"
+read -r -a PICK_OBJECTS_ARGS <<< "$PICK_OBJECTS"
+MAX_ATTEMPTS="${MAX_ATTEMPTS:-0}"
+TOTAL_ITERS="${TOTAL_ITERS:-100000}"
+BATCH_SIZE="${BATCH_SIZE:-512}"
+SEED="${SEED:-1}"
+LOG_FREQ="${LOG_FREQ:-100}"
+SAVE_FREQ="${SAVE_FREQ:-5000}"
+RUN_NAME="${RUN_NAME:-act-task-e-rgb-${NUM_DEMOS}demos-seed${SEED}}"
+RESUME_CHECKPOINT="${RESUME_CHECKPOINT:-}"
+RESUME_ITER="${RESUME_ITER:-}"
+
+RAW_DATA="${DATA_DIR}/trajectory.hdf5"
+FILTERED_DATA="${DATA_DIR}/trajectory_filtered.hdf5"
+
+mkdir -p "$DATA_DIR" logs
+
+echo "[ATEC Task E] root: $ROOT_DIR"
+echo "[ATEC Task E] python: $PYTHON"
+echo "[ATEC Task E] data: $DATA_DIR"
+echo "[ATEC Task E] demos: $NUM_DEMOS, pick_objects: ${PICK_OBJECTS_ARGS[*]}, batch: $BATCH_SIZE, iters: $TOTAL_ITERS"
+
+if [[ ! -f "$RAW_DATA" ]]; then
+    "$PYTHON" -u scripts/act/collect_demos_task_e.py \
+    --pick_objects "${PICK_OBJECTS_ARGS[@]}" \
+    --num_demos "$NUM_DEMOS" \
+    --headless \
+    --enable_cameras \
+    --save_images \
+    --only_success \
+    --trace \
+    --abort_failed_lift \
+    --max_attempts "$MAX_ATTEMPTS" \
+    --output_dir "$DATA_DIR"
+else
+  echo "[ATEC Task E] Found $RAW_DATA, skip collection."
+fi
+
+if [[ ! -f "$FILTERED_DATA" ]]; then
+  "$PYTHON" -u scripts/act/filter_demos.py \
+    --input "$RAW_DATA" \
+    --output "$FILTERED_DATA" \
+    --threshold 0.001
+else
+  echo "[ATEC Task E] Found $FILTERED_DATA, skip filtering."
+fi
+
+TRAIN_ARGS=(
+  --demo_path "$FILTERED_DATA"
+  --num_demos "$NUM_DEMOS"
+  --include_rgb
+  --total_iters "$TOTAL_ITERS"
+  --batch_size "$BATCH_SIZE"
+  --log_freq "$LOG_FREQ"
+  --save_freq "$SAVE_FREQ"
+  --seed "$SEED"
+  --exp_name "$RUN_NAME"
+)
+
+if [[ -n "$RESUME_CHECKPOINT" ]]; then
+  TRAIN_ARGS+=(--resume_checkpoint "$RESUME_CHECKPOINT")
+fi
+if [[ -n "$RESUME_ITER" ]]; then
+  TRAIN_ARGS+=(--resume_iter "$RESUME_ITER")
+fi
+
+"$PYTHON" -u scripts/act/train_task_e.py "${TRAIN_ARGS[@]}"

scripts/act/search_task_e_grasps.py

@@ -0,0 +1,761 @@
+"""Search per-object scripted grasp parameters for Task E.
+
+This is a fast physics-only diagnostic: it disables cameras, runs candidate
+grasp offsets/heights/yaw corrections in one Isaac process, and reports the
+first successful candidates.
+"""
+
+import argparse
+import math
+import os
+
+from isaaclab.app import AppLauncher
+
+
+parser = argparse.ArgumentParser(description="Search Task-E grasp candidates.")
+parser.add_argument("--objects", type=int, nargs="+", default=[1, 2])
+parser.add_argument("--trials", type=int, default=1)
+parser.add_argument("--max_candidates", type=int, default=40)
+parser.add_argument("--start_candidate", type=int, default=1,
+                    help="1-based candidate index to start from; useful for resuming long searches.")
+parser.add_argument("--max_joint_delta", type=float, default=0.2,
+                    help="Per-step IK joint target limit. Lower values make contact pushes gentler.")
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+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 TaskEEnvPiperCfg
+from atec_rl_lab.utils import CartesianController
+
+from task_e import config as grasp_cfg
+from task_e.collector import (
+    basket_status_lines,
+    check_objects_in_basket,
+    collect_one_demo,
+)
+from task_e.config import (
+    ACT_DAMPING,
+    ACT_EFFORT_LIMIT,
+    ACT_STIFFNESS,
+    ACT_VEL_LIMIT,
+    ARM_JOINT_NAMES,
+    EE_BODY_NAME,
+    GRIPPER_JOINT_NAMES,
+    STEPS,
+)
+
+BASE_STATE_STEP_OVERRIDES = {
+    obj_idx: steps.copy()
+    for obj_idx, steps in grasp_cfg.OBJ_STATE_STEP_OVERRIDES.items()
+}
+
+
+def _candidate_dict(
+    dx: float,
+    dy: float,
+    z: float,
+    carry_z: float,
+    target_x: float,
+    target_y: float,
+    transport_gripper: str,
+    yaw: float,
+    push_y: float | None = None,
+    *,
+    push_x: float = 0.0,
+    push_z: float = 0.0,
+    transport_steps: int | None = None,
+    place_steps: int | None = None,
+    open_steps: int | None = None,
+    close_steps: int | None = None,
+    lift_steps: int | None = None,
+    close_z: float | None = None,
+    finger_target_z: float | None = None,
+    finger_max_z: float | None = None,
+    mode: str = "pick",
+    push_x_gain: float | None = None,
+    push_max_x: float | None = None,
+    push_min_behind: float | None = None,
+) -> dict[str, float]:
+    return {
+        "mode": mode,
+        "dx": dx,
+        "dy": dy,
+        "z": z,
+        "carry_z": carry_z,
+        "place_z": min(carry_z, grasp_cfg.TABLE_TOP_Z + 0.15),
+        "target_x": target_x,
+        "target_y": target_y,
+        "transport_gripper": transport_gripper,
+        "yaw": yaw,
+        "push_x": push_x,
+        "push_y": push_y,
+        "push_z": push_z,
+        "transport_steps": transport_steps,
+        "place_steps": place_steps,
+        "open_steps": open_steps,
+        "close_steps": close_steps,
+        "lift_steps": lift_steps,
+        "close_z": close_z,
+        "finger_target_z": finger_target_z,
+        "finger_max_z": finger_max_z,
+        "push_x_gain": push_x_gain,
+        "push_max_x": push_max_x,
+        "push_min_behind": push_min_behind,
+    }
+
+
+def _normalize_candidate(item: tuple | dict) -> dict[str, float]:
+    if isinstance(item, dict):
+        cand = item.copy()
+        cand.setdefault("mode", "pick")
+        cand.setdefault("place_z", min(cand["carry_z"], grasp_cfg.TABLE_TOP_Z + 0.15))
+        cand.setdefault("push_x", 0.0)
+        cand.setdefault("push_y", None)
+        cand.setdefault("push_z", 0.0)
+        cand.setdefault("transport_steps", None)
+        cand.setdefault("place_steps", None)
+        cand.setdefault("open_steps", None)
+        cand.setdefault("close_steps", None)
+        cand.setdefault("lift_steps", None)
+        cand.setdefault("close_z", None)
+        cand.setdefault("finger_target_z", None)
+        cand.setdefault("finger_max_z", None)
+        cand.setdefault("push_x_gain", None)
+        cand.setdefault("push_max_x", None)
+        cand.setdefault("push_min_behind", None)
+        return cand
+    if len(item) == 8:
+        dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw = item
+        return _candidate_dict(dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw)
+    dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw, push_y = item
+    return _candidate_dict(dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw, push_y)
+
+
+def build_env() -> ManagerBasedRLEnv:
+    cfg = TaskEEnvPiperCfg()
+    cfg.seed = 123
+    cfg.scene.num_envs = 1
+    cfg.scene.video_cam = None
+    cfg.scene.ee_camera = None
+    cfg.scene.ee_dual_camera = None
+    cfg.scene.head_camera = None
+    cfg.observations.image = None
+    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 candidates_for(obj_idx: int) -> list[dict[str, float]]:
+    priority = []
+    if obj_idx == 1:
+        # Sugar box has an off-centre USD root.  Try real top-down pinch
+        # grasps around the measured visible bbox centre first; keep push-like
+        # sweeps only as a fallback diagnostic.
+        priority = [
+            _candidate_dict(0.025, 0.000, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.025, 0.000, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.015, finger_target_z=-0.030, finger_max_z=0.060,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.025, 0.000, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.025, finger_target_z=-0.020, finger_max_z=0.045,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.015, 0.000, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.035, 0.000, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.025, 0.010, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.025, -0.010, 0.072, grasp_cfg.CARRY_Z,
+                            0.00, 0.000, "close", 0.0,
+                            close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050,
+                            transport_steps=2200, place_steps=300, open_steps=80),
+            _candidate_dict(0.040, 0.180, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1450, place_steps=320, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.12,
+                            push_min_behind=0.035),
+            _candidate_dict(0.000, 0.180, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1450, place_steps=320, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.12,
+                            push_min_behind=0.035),
+            _candidate_dict(-0.040, 0.180, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1450, place_steps=320, open_steps=80,
+                            mode="push", push_x_gain=0.60, push_max_x=0.14,
+                            push_min_behind=0.035),
+            _candidate_dict(0.040, 0.220, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1550, place_steps=360, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.12,
+                            push_min_behind=0.040),
+            _candidate_dict(0.000, 0.220, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1550, place_steps=360, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.12,
+                            push_min_behind=0.040),
+            # Push-slide primitive: approach from +Y and drive the object
+            # centre into the basket.  This tests the contact-rich route
+            # before more top-down pinch candidates.
+            _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=850, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.000, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=850, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(-0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=850, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.70, push_max_x=0.12),
+            _candidate_dict(0.040, 0.190, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=950, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.000, 0.190, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=950, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050,
+                            0.00, 0.000, "open", 0.0,
+                            transport_steps=950, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.070,
+                            0.00, 0.000, "close", math.pi / 2,
+                            transport_steps=850, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.070,
+                            0.00, 0.000, "close", -math.pi / 2,
+                            transport_steps=850, place_steps=140, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            # Focused timing sweep after candidates 025-034 proved real
+            # contact/lift but missed the basket.  Keep the end effector low,
+            # hold contact longer, then release near the basket plane.
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.160,
+                            transport_steps=1000, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.180,
+                            transport_steps=900, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.140,
+                            transport_steps=1200, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.200,
+                            transport_steps=750, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.015,
+                            -0.17, 0.000, "close", 0.0, -0.180,
+                            transport_steps=900, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "open", 0.0, -0.180,
+                            transport_steps=1000, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "open", 0.0, -0.250,
+                            transport_steps=850, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.180,
+                            push_x=-0.040, transport_steps=900, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.180,
+                            push_x=0.040, transport_steps=900, place_steps=30, open_steps=80),
+            _candidate_dict(0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025,
+                            -0.17, 0.000, "close", 0.0, -0.180,
+                            transport_steps=900, place_steps=30, open_steps=80),
+            (-0.205, 0.104, 0.025, grasp_cfg.TABLE_TOP_Z + 0.140, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.065, grasp_cfg.TABLE_TOP_Z + 0.180, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", math.pi / 2),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", -math.pi / 2),
+            (-0.180, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.230, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.084, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.124, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.180, 0.084, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.230, 0.124, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.085, grasp_cfg.TABLE_TOP_Z + 0.200, 0.00, -0.240, "close", 0.0),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.120),
+            (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100),
+            (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.240, "close", 0.0, -0.100),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.140),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.180),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.220),
+            (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160),
+            (0.020, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160),
+            (0.060, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160),
+            # Focused refinement around candidate 019: it made real contact
+            # and lifted object_1, but released high and too far +X/+Y.
+            # Lower the sweep height and bias release toward basket centre/left.
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.180),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.10, 0.000, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.10, 0.000, "close", 0.0, -0.180),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.160),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.180),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, -0.100, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, -0.100, "close", 0.0, -0.180),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, 0.000, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, 0.000, "close", 0.0, -0.180),
+            (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.240, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.300, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.08, -0.240, "close", 0.0, -0.160),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.060),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.060),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100),
+            (0.020, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080),
+            (0.060, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080),
+            (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080),
+            (0.040, 0.180, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080),
+            (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.240, "close", 0.0, -0.080),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.300, "close", 0.0, -0.080),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.08, -0.750, "close", 0.0),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.600, "close", 0.0),
+            (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0),
+            (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0),
+            (0.060, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0),
+            (0.020, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0),
+            (0.040, 0.160, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.750, "close", 0.0),
+            (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.750, "close", 0.0),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "open", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", math.pi / 2),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", -math.pi / 2),
+            (-0.205, 0.084, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0),
+            (-0.180, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0),
+            (-0.230, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.124, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.065, grasp_cfg.TABLE_TOP_Z + 0.140, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.025, grasp_cfg.TABLE_TOP_Z + 0.100, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.180, 0.00, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, -0.10, -0.240, "close", 0.0),
+            (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.300, "close", 0.0),
+            (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.10, -0.60, "close", 0.0),
+            (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (0.080, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (-0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (-0.096, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (0.040, 0.240, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (0.040, 0.200, 0.000, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0),
+            (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.050, -0.17, -0.60, "close", 0.0),
+            (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.45, "close", 0.0),
+            (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.75, "close", 0.0),
+            (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "open", 0.0),
+        ]
+        base_offsets = [
+            (0.040, 0.140),
+            (0.040, 0.180),
+            (0.040, 0.220),
+            (0.080, 0.180),
+            (0.080, 0.220),
+            (-0.096, 0.140),
+            (-0.096, 0.180),
+            (-0.096, 0.220),
+            (-0.040, 0.140),
+            (-0.040, 0.180),
+            (-0.040, 0.220),
+            (0.000, 0.140),
+            (0.000, 0.180),
+            (0.000, 0.220),
+            (-0.160, 0.140),
+            (-0.200, 0.140),
+            (-0.117, -0.025),
+            (-0.096, 0.084),
+            (-0.096, 0.000),
+            (-0.060, 0.060),
+            (-0.040, 0.020),
+            (0.000, 0.040),
+            (-0.140, 0.040),
+            (-0.100, 0.000),
+            (-0.020, 0.080),
+        ]
+        z_values = [-0.020, -0.010, 0.000, 0.015, 0.025, 0.040, 0.060, 0.080, 0.110]
+        carry_values = [
+            grasp_cfg.TABLE_TOP_Z + 0.025,
+            grasp_cfg.TABLE_TOP_Z + 0.035,
+            grasp_cfg.TABLE_TOP_Z + 0.050,
+            grasp_cfg.TABLE_TOP_Z + 0.075,
+            grasp_cfg.TABLE_TOP_Z + 0.10,
+            grasp_cfg.TABLE_TOP_Z + 0.12,
+            grasp_cfg.TABLE_TOP_Z + 0.16,
+            grasp_cfg.TABLE_TOP_Z + 0.22,
+            grasp_cfg.CARRY_Z,
+        ]
+        target_x_offsets = [-0.17, -0.10, 0.0, 0.08]
+        target_y_offsets = [-0.60, -0.45, -0.75, -0.36, -0.30, -0.24, -0.18, 0.0]
+        transport_gripper_cmds = ["close", "open"]
+        yaws = [0.0, math.pi / 2, -math.pi / 2]
+    elif obj_idx == 2:
+        priority = [
+            _candidate_dict(0.000, 0.045, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, -0.140, "close", 0.0,
+                            transport_steps=1500, place_steps=420, open_steps=80,
+                            mode="push", push_x_gain=0.50, push_max_x=0.10,
+                            push_min_behind=-0.015),
+            _candidate_dict(0.020, 0.045, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, -0.140, "close", 0.0,
+                            transport_steps=1500, place_steps=420, open_steps=80,
+                            mode="push", push_x_gain=0.50, push_max_x=0.10,
+                            push_min_behind=-0.015),
+            _candidate_dict(-0.020, 0.045, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, -0.140, "close", 0.0,
+                            transport_steps=1500, place_steps=420, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.12,
+                            push_min_behind=-0.015),
+            _candidate_dict(0.000, 0.060, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040,
+                            0.00, -0.180, "close", 0.0,
+                            transport_steps=1600, place_steps=460, open_steps=80,
+                            mode="push", push_x_gain=0.50, push_max_x=0.10,
+                            push_min_behind=-0.020),
+            _candidate_dict(0.020, 0.060, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040,
+                            0.00, -0.180, "close", 0.0,
+                            transport_steps=1600, place_steps=460, open_steps=80,
+                            mode="push", push_x_gain=0.50, push_max_x=0.10,
+                            push_min_behind=-0.020),
+            _candidate_dict(-0.020, 0.060, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040,
+                            0.00, -0.180, "close", 0.0,
+                            transport_steps=1600, place_steps=460, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.12,
+                            push_min_behind=-0.020),
+            _candidate_dict(0.000, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1250, place_steps=260, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.10,
+                            push_min_behind=0.025),
+            _candidate_dict(0.020, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1250, place_steps=260, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.10,
+                            push_min_behind=0.025),
+            _candidate_dict(-0.020, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1250, place_steps=260, open_steps=80,
+                            mode="push", push_x_gain=0.60, push_max_x=0.12,
+                            push_min_behind=0.025),
+            _candidate_dict(0.000, 0.125, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1350, place_steps=300, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.10,
+                            push_min_behind=0.030),
+            _candidate_dict(0.020, 0.125, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1350, place_steps=300, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.10,
+                            push_min_behind=0.030),
+            _candidate_dict(0.000, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=1350, place_steps=300, open_steps=80,
+                            mode="push", push_x_gain=0.55, push_max_x=0.10,
+                            push_min_behind=0.020),
+            _candidate_dict(-0.040, 0.070, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, -0.140, "close", 0.0,
+                            transport_steps=1000, place_steps=160, open_steps=80,
+                            mode="push", push_x_gain=0.75, push_max_x=0.14),
+            _candidate_dict(0.000, 0.070, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, -0.140, "close", 0.0,
+                            transport_steps=1000, place_steps=160, open_steps=80,
+                            mode="push", push_x_gain=0.70, push_max_x=0.12),
+            _candidate_dict(0.040, 0.070, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045,
+                            0.00, -0.140, "close", 0.0,
+                            transport_steps=1000, place_steps=160, open_steps=80,
+                            mode="push", push_x_gain=0.70, push_max_x=0.12),
+            _candidate_dict(-0.040, 0.050, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040,
+                            0.00, -0.180, "close", 0.0,
+                            transport_steps=1100, place_steps=180, open_steps=80,
+                            mode="push", push_x_gain=0.75, push_max_x=0.14),
+            _candidate_dict(0.000, 0.050, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040,
+                            0.00, -0.180, "close", 0.0,
+                            transport_steps=1100, place_steps=180, open_steps=80,
+                            mode="push", push_x_gain=0.70, push_max_x=0.12),
+            _candidate_dict(-0.040, 0.090, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050,
+                            0.00, -0.220, "open", 0.0,
+                            transport_steps=1100, place_steps=180, open_steps=80,
+                            mode="push", push_x_gain=0.75, push_max_x=0.14),
+            _candidate_dict(0.000, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=700, place_steps=120, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.040, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=700, place_steps=120, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(-0.040, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=700, place_steps=120, open_steps=80,
+                            mode="push", push_x_gain=0.70, push_max_x=0.12),
+            _candidate_dict(0.000, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065,
+                            0.00, 0.000, "close", 0.0,
+                            transport_steps=850, place_steps=120, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065,
+                            0.00, 0.000, "close", -math.pi / 2,
+                            transport_steps=850, place_steps=120, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            _candidate_dict(0.000, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055,
+                            0.00, 0.000, "open", 0.0,
+                            transport_steps=850, place_steps=120, open_steps=80,
+                            mode="push", push_x_gain=0.65, push_max_x=0.10),
+            (0.006, 0.046, 0.045, grasp_cfg.TABLE_TOP_Z + 0.075, 0.00, -0.240, "close", -math.pi / 2),
+        ]
+        base_offsets = [
+            (0.006, 0.046),
+            (0.030, 0.026),
+            (0.060, 0.000),
+            (0.100, 0.020),
+            (0.115, 0.026),
+            (-0.020, 0.050),
+            (0.040, 0.070),
+            (0.000, 0.000),
+        ]
+        z_values = [0.045, 0.065, 0.085, 0.110, 0.135, 0.160]
+        carry_values = [
+            grasp_cfg.TABLE_TOP_Z + 0.075,
+            grasp_cfg.TABLE_TOP_Z + 0.10,
+            grasp_cfg.TABLE_TOP_Z + 0.12,
+            grasp_cfg.TABLE_TOP_Z + 0.14,
+            grasp_cfg.TABLE_TOP_Z + 0.18,
+            grasp_cfg.TABLE_TOP_Z + 0.24,
+            grasp_cfg.CARRY_Z,
+        ]
+        target_x_offsets = [0.0]
+        target_y_offsets = [-0.24, -0.18, -0.30, -0.12, 0.0]
+        transport_gripper_cmds = ["close"]
+        yaws = [0.0, math.pi / 2, -math.pi / 2]
+    else:
+        base_offsets = [(0.0, 0.0)]
+        z_values = [grasp_cfg.GRASP_Z_OFFSET]
+        carry_values = [grasp_cfg.CARRY_Z]
+        target_x_offsets = [0.0]
+        target_y_offsets = [0.0]
+        transport_gripper_cmds = ["close"]
+        yaws = [0.0]
+
+    out = []
+    for item in priority:
+        out.append(_normalize_candidate(item))
+    for z in z_values:
+        for carry_z in carry_values:
+            for target_x in target_x_offsets:
+                for target_y in target_y_offsets:
+                    for transport_gripper in transport_gripper_cmds:
+                        for yaw in yaws:
+                            for dx, dy in base_offsets:
+                                out.append({
+                                    "dx": dx,
+                                    "dy": dy,
+                                    "z": z,
+                                    "carry_z": carry_z,
+                                    "place_z": min(carry_z, grasp_cfg.TABLE_TOP_Z + 0.15),
+                                    "target_x": target_x,
+                                    "target_y": target_y,
+                                    "transport_gripper": transport_gripper,
+                                    "yaw": yaw,
+                                    "push_y": None,
+                                })
+    start = max(args_cli.start_candidate, 1) - 1
+    return out[start : start + args_cli.max_candidates]
+
+
+def apply_candidate(obj_idx: int, cand: dict[str, float]) -> None:
+    grasp_cfg.OBJ_MANIPULATION_MODES[obj_idx] = cand.get("mode", "pick")
+    grasp_cfg.OBJ_GRASP_CENTER_OFFSETS[obj_idx] = (cand["dx"], cand["dy"], 0.0)
+    grasp_cfg.OBJ_GRASP_Z_OFFSETS[obj_idx] = cand["z"]
+    if cand.get("close_z") is not None:
+        grasp_cfg.OBJ_CLOSE_Z_OFFSETS[obj_idx] = float(cand["close_z"])
+    grasp_cfg.OBJ_GRASP_YAW_OFFSETS[obj_idx] = cand["yaw"]
+    grasp_cfg.OBJ_CARRY_Z[obj_idx] = cand["carry_z"]
+    grasp_cfg.OBJ_PLACE_HEIGHTS[obj_idx] = cand["place_z"]
+    grasp_cfg.OBJ_PLACE_XY_OFFSETS[obj_idx] = (cand["target_x"], cand["target_y"])
+    grasp_cfg.OBJ_TRANSPORT_GRIPPER_CMDS[obj_idx] = cand["transport_gripper"]
+    grasp_cfg.OBJ_PUSH_GRIPPER_CMDS[obj_idx] = cand["transport_gripper"]
+    if cand.get("finger_target_z") is not None:
+        grasp_cfg.OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx] = float(cand["finger_target_z"])
+    if cand.get("finger_max_z") is not None:
+        grasp_cfg.OBJ_FINGER_CENTER_SERVO_MAX_Z[obj_idx] = float(cand["finger_max_z"])
+    if cand.get("push_x_gain") is not None:
+        grasp_cfg.OBJ_PUSH_X_GAINS[obj_idx] = float(cand["push_x_gain"])
+    if cand.get("push_max_x") is not None:
+        grasp_cfg.OBJ_PUSH_MAX_X_CORRECTIONS[obj_idx] = float(cand["push_max_x"])
+    if cand.get("push_min_behind") is not None:
+        grasp_cfg.OBJ_PUSH_MIN_BEHIND[obj_idx] = float(cand["push_min_behind"])
+    grasp_cfg.OBJ_TRANSPORT_PUSH_BIASES[obj_idx] = (
+        None if cand.get("push_y") is None
+        else (cand.get("push_x", 0.0), cand["push_y"], cand.get("push_z", 0.0))
+    )
+    step_overrides = BASE_STATE_STEP_OVERRIDES.get(obj_idx, {}).copy()
+    for cand_key, state_key in (
+        ("close_steps", "CLOSE"),
+        ("lift_steps", "LIFT"),
+        ("transport_steps", "TRANSPORT"),
+        ("place_steps", "PLACE"),
+        ("open_steps", "OPEN"),
+    ):
+        if cand.get(cand_key) is not None:
+            step_overrides[state_key] = int(cand[cand_key])
+    if step_overrides:
+        grasp_cfg.OBJ_STATE_STEP_OVERRIDES[obj_idx] = step_overrides
+    else:
+        grasp_cfg.OBJ_STATE_STEP_OVERRIDES.pop(obj_idx, None)
+
+
+def format_trace(data: dict | None, obj_idx: int) -> str:
+    if data is None or "trace" not in data:
+        return "trace=none"
+    tr = data["trace"].get(f"object_{obj_idx}", {})
+    states = tr.get("states", {})
+    close = states.get("CLOSE", {})
+    lift = states.get("LIFT", {})
+    transport = states.get("TRANSPORT", {})
+    def _fmt_vec(vec):
+        if vec is None:
+            return "none"
+        return "(" + ",".join(f"{float(v):+.3f}" for v in vec[:3]) + ")"
+    return (
+        f"lifted={tr.get('lifted')} "
+        f"reward_lifted={tr.get('reward_lifted')} "
+        f"z_gain={float(tr.get('z_gain', 0.0)):.3f} "
+        f"gap_close={float(close.get('min_gripper_gap', 999.0)):.3f} "
+        f"gap_lift={float(lift.get('min_gripper_gap', 999.0)):.3f} "
+        f"ee_lift={float(lift.get('min_ee_dist', 999.0)):.3f} "
+        f"ee_transport={float(transport.get('min_ee_dist', 999.0)):.3f} "
+        f"finger_lift={float(lift.get('min_finger_center_dist', 999.0)):.3f} "
+        f"finger_gap={float(lift.get('min_finger_body_gap', 999.0)):.3f} "
+        f"finger_vec_transport={_fmt_vec(transport.get('min_finger_center_vec'))} "
+        f"ee_vec_transport={_fmt_vec(transport.get('min_ee_vec'))}"
+    )
+
+
+def score_candidate(env: ManagerBasedRLEnv, data: dict | None, obj_idx: int, ok: bool) -> float:
+    pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
+    dx = abs(float(pos[0].item() - grasp_cfg.BASKET_CENTER_X))
+    dy = abs(float(pos[1].item() - grasp_cfg.BASKET_CENTER_Y))
+    xy_err = max(dx - grasp_cfg.BASKET_IN_X, 0.0) + max(dy - grasp_cfg.BASKET_IN_Y, 0.0)
+    z_gain = 0.0
+    if data is not None and "trace" in data:
+        z_gain = float(data["trace"].get(f"object_{obj_idx}", {}).get("z_gain", 0.0))
+    return (100.0 if ok else 0.0) + 2.0 * z_gain - xy_err
+
+
+def main() -> None:
+    env = build_env()
+    dev = env.unwrapped.device
+    robot = env.unwrapped.scene.articulations["robot"]
+    arm_ids, _ = robot.find_joints(ARM_JOINT_NAMES)
+    gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES)
+    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=args_cli.max_joint_delta,
+    )
+    default_jpos = robot.data.default_joint_pos.clone()
+    original_close = STEPS["CLOSE"]
+    STEPS["CLOSE"] = max(original_close, 100)
+
+    try:
+        for obj_idx in args_cli.objects:
+            print(f"\n[SEARCH] object_{obj_idx}")
+            successes: list[dict[str, float]] = []
+            best: tuple[float, int, dict[str, float], str] | None = None
+            for cand_idx, cand in enumerate(candidates_for(obj_idx), start=max(args_cli.start_candidate, 1)):
+                apply_candidate(obj_idx, cand)
+                ok_count = 0
+                last_status = ""
+                last_score = -1e9
+                for trial in range(args_cli.trials):
+                    # Keep trial seeds independent of candidate index so every
+                    # candidate is evaluated on the same object placements.
+                    rng = np.random.default_rng(1000 + obj_idx * 100 + trial)
+                    data = collect_one_demo(
+                        env,
+                        robot,
+                        ik_ctrl,
+                        arm_ids,
+                        gripper_ids,
+                        [obj_idx],
+                        dev,
+                        default_jpos=default_jpos,
+                        rng=rng,
+                        camera=None,
+                        trace=True,
+                    )
+                    ok = data is not None and check_objects_in_basket(env, [obj_idx])
+                    ok_count += int(ok)
+                    last_score = score_candidate(env, data, obj_idx, ok)
+                    last_status = (
+                        "; ".join(basket_status_lines(env, [obj_idx]))
+                        + " | "
+                        + format_trace(data, obj_idx)
+                    )
+                    if not ok:
+                        break
+                if best is None or last_score > best[0]:
+                    best = (last_score, cand_idx, cand.copy(), last_status)
+                result = f"{ok_count}/{args_cli.trials}"
+                print(
+                    f"[CAND {cand_idx:03d}] mode={cand.get('mode', 'pick')} result={result} "
+                    f"dx={cand['dx']:+.3f} dy={cand['dy']:+.3f} "
+                    f"z={cand['z']:.3f} close_z={cand.get('close_z')} "
+                    f"finger_z={cand.get('finger_target_z')} carry={cand['carry_z']:.3f} "
+                    f"target_x={cand['target_x']:+.3f} "
+                    f"target_y={cand['target_y']:+.3f} "
+                    f"push=({cand.get('push_x', 0.0):+.3f},{cand.get('push_y')},{cand.get('push_z', 0.0):+.3f}) "
+                    f"behind={cand.get('push_min_behind')} "
+                    f"steps=({cand.get('transport_steps')},{cand.get('place_steps')},{cand.get('open_steps')}) "
+                    f"transport_gripper={cand['transport_gripper']} "
+                    f"yaw={cand['yaw']:+.3f} | {last_status}",
+                    flush=True,
+                )
+                if ok_count == args_cli.trials:
+                    successes.append(cand.copy())
+                    print(f"[SUCCESS] object_{obj_idx}: {cand}", flush=True)
+                    break
+            if not successes:
+                print(f"[FAIL] object_{obj_idx}: no successful candidate in first {args_cli.max_candidates}")
+            if best is not None:
+                best_score, best_idx, best_cand, best_status = best
+                print(
+                    f"[BEST] object_{obj_idx}: cand={best_idx:03d} score={best_score:.3f} "
+                    f"{best_cand} | {best_status}",
+                    flush=True,
+                )
+    finally:
+        STEPS["CLOSE"] = original_close
+        env.close()
+
+
+if __name__ == "__main__":
+    main()
+    simulation_app.close()

scripts/act/task_e/collector.py

@@ -0,0 +1,399 @@
+"""Single-episode demo collection and success checking for Task E."""
+
+import numpy as np
+import torch
+from isaaclab.envs import ManagerBasedRLEnv
+from atec_rl_lab.utils import CartesianController
+from atec_rl_lab.tasks.task_e.env_cfg import (
+    TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z,
+    BASKET_CENTER_X, BASKET_CENTER_Y,
+)
+
+from .config import (
+    ACTION_SCALE,
+    EE_BODY_NAME,
+    GRIPPER_OPEN_POS, GRIPPER_CLOSE_POS,
+    OBJ_GRIPPER_CLOSE_POS,
+    RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z,
+    DEFAULT_PLACE_QUAT_W,
+    BASKET_IN_X, BASKET_IN_Y,
+    OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Z, OBJ_SPAWN_Y_BANDS,
+    OBJ_HALF_EXTENTS, OBJ_BBOX_MARGIN, OBJ_GRASP_CENTER_OFFSETS,
+    OBJ_FINGER_CENTER_SERVO_STATES, OBJ_FINGER_CENTER_SERVO_GAIN,
+    OBJ_FINGER_CENTER_SERVO_MAX_XY, OBJ_FINGER_CENTER_SERVO_TARGET_Z,
+    OBJ_FINGER_CENTER_SERVO_MAX_Z,
+    WARMUP_STEPS, SETTLE_STEPS,
+)
+from .state_machine import PickPlaceStateMachine
+
+
+def _rerandomize_objects(env: ManagerBasedRLEnv, rng: np.random.Generator) -> None:
+    """Place each object randomly with AABB-based overlap rejection."""
+    placed: dict[int, tuple[float, float]] = {}  # obj_idx -> (x, y)
+
+    for obj_idx in [1, 2, 3]:
+        obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"]
+        y_min, y_max = OBJ_SPAWN_Y_BANDS[obj_idx]
+        hx, hy = OBJ_HALF_EXTENTS[obj_idx]
+
+        x = y = None
+        for _ in range(200):
+            cx = float(rng.uniform(OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX))
+            cy = float(rng.uniform(y_min, y_max))
+            # AABB overlap check against all already-placed objects
+            ok = all(
+                abs(cx - px) >= hx + OBJ_HALF_EXTENTS[pi][0] + OBJ_BBOX_MARGIN or
+                abs(cy - py) >= hy + OBJ_HALF_EXTENTS[pi][1] + OBJ_BBOX_MARGIN
+                for pi, (px, py) in placed.items()
+            )
+            if ok:
+                x, y = cx, cy
+                break
+
+        if x is None:  # fallback: band centre
+            x = (OBJ_SPAWN_X_MIN + OBJ_SPAWN_X_MAX) / 2.0
+            y = (y_min + y_max) / 2.0
+
+        placed[obj_idx] = (x, y)
+        state = obj.data.default_root_state[0:1].clone()
+        state[0, 0] = x
+        state[0, 1] = y
+        state[0, 2] = OBJ_SPAWN_Z
+        state[0, 7:] = 0.0   # zero velocities
+        obj.write_root_state_to_sim(state)
+
+    env.unwrapped.scene.write_data_to_sim()
+    env.unwrapped.sim.forward()
+
+
+_BASKET_MAX_Z = TABLE_TOP_Z + 0.15  # keep aligned with Task-E reward/termination bounds
+
+def check_objects_in_basket(env: ManagerBasedRLEnv, pick_objects: list[int]) -> bool:
+    """Return True only if every picked object is inside the basket region and settled."""
+    for obj_idx in pick_objects:
+        pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
+        if (abs(pos[0].item() - BASKET_CENTER_X) > BASKET_IN_X or
+                abs(pos[1].item() - BASKET_CENTER_Y) > BASKET_IN_Y or
+                pos[2].item() > _BASKET_MAX_Z):
+            return False
+    return True
+
+
+def basket_status_lines(env: ManagerBasedRLEnv, pick_objects: list[int]) -> list[str]:
+    """Return compact debug lines for picked objects against basket bounds."""
+    lines = []
+    for obj_idx in pick_objects:
+        pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
+        dx = pos[0].item() - BASKET_CENTER_X
+        dy = pos[1].item() - BASKET_CENTER_Y
+        z = pos[2].item()
+        inside = abs(dx) <= BASKET_IN_X and abs(dy) <= BASKET_IN_Y and TABLE_TOP_Z <= z <= _BASKET_MAX_Z
+        lines.append(
+            f"object_{obj_idx}: pos=({pos[0].item():.3f},{pos[1].item():.3f},{z:.3f}) "
+            f"d=({dx:+.3f},{dy:+.3f}) inside={inside}"
+        )
+    return lines
+
+
+def collect_one_demo(
+    env:         ManagerBasedRLEnv,
+    robot,
+    ik_ctrl:     CartesianController,
+    arm_ids:     list[int],
+    gripper_ids: list[int],
+    pick_objects: list[int],
+    device:      str,
+    default_jpos: torch.Tensor,
+    rng:         np.random.Generator,
+    camera=None,
+    trace: bool = False,
+    abort_failed_lift: bool = False,
+) -> dict | None:
+    """Run one full episode and return recorded data, or None on early termination.
+
+    Returns a dict with keys:
+      qpos    (T, 8)        absolute joint positions
+      qvel    (T, 8)        joint velocities
+      ee_pos  (T, 3)        end-effector position (world frame)
+      ee_quat (T, 4)        end-effector quaternion (w,x,y,z)
+      action  (T, 8)        env action = (joint_target - default_jpos) / ACTION_SCALE
+      frames  (T, H, W, 3)  RGB uint8 — only present when camera is given
+    """
+    env.reset()
+    robot.write_joint_state_to_sim(
+        robot.data.default_joint_pos,
+        torch.zeros_like(robot.data.default_joint_vel),
+    )
+
+    _rerandomize_objects(env, rng)      # write new object positions to sim + sim.forward()
+    default_jpos = robot.data.default_joint_pos.clone()
+
+    ee_home = torch.tensor([[RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z]],
+                            dtype=torch.float32, device=device)
+    eq_home = torch.tensor([DEFAULT_PLACE_QUAT_W], dtype=torch.float32, device=device)
+    g_open  = torch.tensor([GRIPPER_OPEN_POS], dtype=torch.float32, device=device)
+
+    robot.update(dt=env.unwrapped.physics_dt)
+    ik_ctrl.reset()
+
+    # Warm-up: drive arm to HOME position (not recorded)
+    for _ in range(WARMUP_STEPS):
+        _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
+                 ee_home, eq_home, g_open, default_jpos)
+
+    # Pre-compute grasp quaternions from actual object orientations after reset
+    sm = PickPlaceStateMachine(pick_objects, device)
+    for obj_idx in pick_objects:
+        obj_quat = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] \
+                       .data.root_state_w[0, 3:7]
+        sm.set_grasp_quat(obj_idx, obj_quat)
+
+    # Settle
+    for _ in range(SETTLE_STEPS):
+        _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
+                 ee_home, eq_home, g_open, default_jpos)
+
+    ik_ctrl.reset()
+
+    # ---- Recording loop ---- #
+    qpos_buf, qvel_buf, ee_pos_buf, ee_quat_buf, action_buf = [], [], [], [], []
+    frames_buf = [] if camera is not None else None
+    trace_stats: dict[str, dict] | None = {} if trace else None
+    ee_body_idx = None
+    finger_body_indices: tuple[int, int] | None = None
+    ee_body_ids, _ = robot.find_bodies(EE_BODY_NAME)
+    if len(ee_body_ids) > 0:
+        ee_body_idx = int(ee_body_ids[0])
+    link7_ids, _ = robot.find_bodies("link7")
+    link8_ids, _ = robot.find_bodies("link8")
+    if len(link7_ids) > 0 and len(link8_ids) > 0:
+        finger_body_indices = (int(link7_ids[0]), int(link8_ids[0]))
+
+    def _finger_center() -> torch.Tensor | None:
+        if finger_body_indices is None:
+            return 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()
+        return 0.5 * (f0 + f1)
+
+    def _servo_target_to_fingers(
+        state_name: str,
+        obj_key: str,
+        obj_pos: torch.Tensor,
+        ee_pos_des: torch.Tensor,
+    ) -> torch.Tensor:
+        obj_idx = int(obj_key.rsplit("_", 1)[1])
+        if state_name not in OBJ_FINGER_CENTER_SERVO_STATES.get(obj_idx, ()):
+            return ee_pos_des
+        finger_center = _finger_center()
+        if finger_center is None:
+            return ee_pos_des
+        grasp_offset = torch.tensor(
+            OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)),
+            dtype=torch.float32,
+            device=device,
+        )
+        grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos
+        xy_error = finger_center[:2] - grasp_center[:2]
+        err_norm = torch.linalg.norm(xy_error)
+        if err_norm.item() > 0.18:
+            return ee_pos_des
+        gain = OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85)
+        correction = -xy_error * gain
+        max_xy = 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
+        ee_pos_des = ee_pos_des.clone()
+        ee_pos_des[:2] = ee_pos_des[:2] + correction
+        if state_name in ("REACH", "CLOSE") 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))
+            ee_pos_des[2] = ee_pos_des[2] + z_correction
+        return ee_pos_des
+
+    def _update_trace(state_name: str, obj_key: str, obj_pos: torch.Tensor) -> None:
+        if trace_stats is None:
+            return
+        obj_idx = int(obj_key.rsplit("_", 1)[1])
+        grasp_offset = torch.tensor(
+            OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)),
+            dtype=torch.float32,
+            device=device,
+        )
+        grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos
+        if ee_body_idx is not None:
+            ee_pos = robot.data.body_pos_w[0, ee_body_idx, :3].detach()
+        else:
+            ee_pos = ik_ctrl.ee_pos_w[0].detach()
+        finger_center_dist = None
+        finger_body_gap = None
+        if finger_body_indices 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)
+            finger_center_dist = float(torch.linalg.norm(grasp_center - finger_center).item())
+            finger_body_gap = float(torch.linalg.norm(f0 - f1).item())
+            finger_center_vec = [float(v) for v in (finger_center - grasp_center).detach().cpu().tolist()]
+        else:
+            finger_center_vec = None
+        gripper_jpos = robot.data.joint_pos[0, gripper_ids].detach()
+        gripper_gap = abs(float(gripper_jpos[0].item() - gripper_jpos[1].item()))
+        ee_dist = float(torch.linalg.norm(obj_pos - ee_pos).item())
+        ee_vec = [float(v) for v in (ee_pos - obj_pos).detach().cpu().tolist()]
+        obj_pos_cpu = [float(v) for v in obj_pos.detach().cpu().tolist()]
+        obj_stats = trace_stats.setdefault(
+            obj_key,
+            {
+                "initial_pos": obj_pos_cpu,
+                "final_pos": obj_pos_cpu,
+                "max_z": obj_pos_cpu[2],
+                "min_ee_dist": ee_dist,
+                "min_ee_vec": ee_vec,
+                "min_gripper_gap": gripper_gap,
+                "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0,
+                "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None,
+                "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0,
+                "states": {},
+            },
+        )
+        obj_stats["final_pos"] = obj_pos_cpu
+        obj_stats["max_z"] = max(float(obj_stats["max_z"]), obj_pos_cpu[2])
+        if ee_dist < float(obj_stats["min_ee_dist"]):
+            obj_stats["min_ee_dist"] = ee_dist
+            obj_stats["min_ee_vec"] = ee_vec
+        obj_stats["min_gripper_gap"] = min(float(obj_stats["min_gripper_gap"]), gripper_gap)
+        if finger_center_dist is not None:
+            if finger_center_dist < float(obj_stats["min_finger_center_dist"]):
+                obj_stats["min_finger_center_dist"] = finger_center_dist
+                obj_stats["min_finger_center_vec"] = finger_center_vec
+        if finger_body_gap is not None:
+            obj_stats["min_finger_body_gap"] = min(float(obj_stats["min_finger_body_gap"]), finger_body_gap)
+        st = obj_stats["states"].setdefault(
+            state_name,
+            {
+                "steps": 0,
+                "start_pos": obj_pos_cpu,
+                "end_pos": obj_pos_cpu,
+                "max_z": obj_pos_cpu[2],
+                "min_ee_dist": ee_dist,
+                "min_ee_vec": ee_vec,
+                "min_gripper_gap": gripper_gap,
+                "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0,
+                "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None,
+                "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0,
+            },
+        )
+        st["steps"] += 1
+        st["end_pos"] = obj_pos_cpu
+        st["max_z"] = max(float(st["max_z"]), obj_pos_cpu[2])
+        if ee_dist < float(st["min_ee_dist"]):
+            st["min_ee_dist"] = ee_dist
+            st["min_ee_vec"] = ee_vec
+        st["min_gripper_gap"] = min(float(st["min_gripper_gap"]), gripper_gap)
+        if finger_center_dist is not None:
+            if finger_center_dist < float(st["min_finger_center_dist"]):
+                st["min_finger_center_dist"] = finger_center_dist
+                st["min_finger_center_vec"] = finger_center_vec
+        if finger_body_gap is not None:
+            st["min_finger_body_gap"] = min(float(st["min_finger_body_gap"]), finger_body_gap)
+
+    def _gripper_target_values(obj_key: str, gripper_cmd: str) -> list[float]:
+        if gripper_cmd == "open":
+            return GRIPPER_OPEN_POS
+        obj_idx = int(obj_key.rsplit("_", 1)[1])
+        return OBJ_GRIPPER_CLOSE_POS.get(obj_idx, GRIPPER_CLOSE_POS)
+
+    while not sm.done:
+        state_name = sm.state
+        obj_key = sm.current_object_key
+        obj_pos_w = env.unwrapped.scene.rigid_objects[sm.current_object_key] \
+                        .data.root_pos_w[0].clone()
+        ee_pos_des, ee_quat_des, gripper_cmd = sm.tick(obj_pos_w)
+        ee_pos_des = _servo_target_to_fingers(state_name, obj_key, obj_pos_w, ee_pos_des)
+
+        arm_jpos_des   = ik_ctrl.compute(ee_pos_des.unsqueeze(0), ee_quat_des.unsqueeze(0))
+        gripper_vals   = _gripper_target_values(obj_key, gripper_cmd)
+        gripper_target = torch.tensor([gripper_vals], dtype=torch.float32, device=device)
+
+        full_target = robot.data.joint_pos.clone()
+        full_target[:, arm_ids]     = arm_jpos_des
+        full_target[:, gripper_ids] = gripper_target
+        env_action = (full_target - default_jpos) / ACTION_SCALE
+
+        # Record BEFORE stepping (obs at time t, action at time t)
+        qpos_buf.append(robot.data.joint_pos[0].cpu().numpy())
+        qvel_buf.append(robot.data.joint_vel[0].cpu().numpy())
+        ee_pos_buf.append(ik_ctrl.ee_pos_w[0].cpu().numpy())
+        ee_quat_buf.append(ik_ctrl.ee_quat_w[0].cpu().numpy())
+        action_buf.append(env_action[0].cpu().numpy())
+        if frames_buf is not None:
+            rgba = camera.data.output["rgb"][0].cpu().numpy()
+            frames_buf.append(rgba[:, :, :3])
+
+        _update_trace(state_name, obj_key, obj_pos_w)
+        _, _, terminated, truncated, _ = env.step(env_action)
+
+        if abort_failed_lift and state_name == "LIFT" and sm.state != "LIFT":
+            final_obj_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0]
+            lift_gain = float((final_obj_pos[2] - obj_pos_w[2]).item())
+            trace_gain = None
+            if trace_stats is not None and obj_key in trace_stats:
+                obj_stats = trace_stats[obj_key]
+                trace_gain = float(obj_stats["max_z"] - obj_stats["initial_pos"][2])
+            effective_gain = max(lift_gain, trace_gain if trace_gain is not None else lift_gain)
+            if effective_gain < 0.035:
+                print(
+                    f"[WARN] {obj_key} failed lift gate "
+                    f"(z_gain={effective_gain:.3f}) - aborting attempt."
+                )
+                return None
+
+        if terminated.any() or truncated.any():
+            if check_objects_in_basket(env, pick_objects):
+                print("[INFO] Episode ended after basket success; keeping demo.")
+                break
+            print("[WARN] Episode ended early — skipping demo.")
+            return None
+
+    result = {
+        "qpos":    np.stack(qpos_buf),
+        "qvel":    np.stack(qvel_buf),
+        "ee_pos":  np.stack(ee_pos_buf),
+        "ee_quat": np.stack(ee_quat_buf),
+        "action":  np.stack(action_buf),
+    }
+    if frames_buf is not None:
+        result["frames"] = np.stack(frames_buf)
+    if trace_stats is not None:
+        for obj_idx in pick_objects:
+            obj_key = f"object_{obj_idx}"
+            if obj_key not in trace_stats:
+                continue
+            final_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0]
+            final_pos_cpu = [float(v) for v in final_pos.detach().cpu().tolist()]
+            obj_stats = trace_stats[obj_key]
+            obj_stats["final_pos"] = final_pos_cpu
+            obj_stats["z_gain"] = float(obj_stats["max_z"] - obj_stats["initial_pos"][2])
+            obj_stats["lifted"] = bool(obj_stats["z_gain"] >= 0.035)
+            obj_stats["reward_lifted"] = bool(obj_stats["max_z"] >= TABLE_TOP_Z + 0.15)
+            obj_stats["basket_inside"] = check_objects_in_basket(env, [obj_idx])
+        result["trace"] = trace_stats
+    return result
+
+
+# ------------------------------------------------------------------ #
+# Internal helper
+# ------------------------------------------------------------------ #
+
+def _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
+             ee_pos, ee_quat, gripper_target, default_jpos):
+    """Single IK step toward a target pose (utility used during warm-up/settle)."""
+    arm_des = ik_ctrl.compute(ee_pos, ee_quat)
+    tgt = robot.data.joint_pos.clone()
+    tgt[:, arm_ids]     = arm_des
+    tgt[:, gripper_ids] = gripper_target
+    env.step((tgt - default_jpos) / ACTION_SCALE)
+    robot.update(dt=env.unwrapped.physics_dt)

scripts/act/task_e/config.py

@@ -0,0 +1,295 @@
+"""Task E demo-collection constants.
+"""
+
+from atec_rl_lab.tasks.task_e.env_cfg import (
+    BASKET_CENTER_X, BASKET_CENTER_Y,
+    TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z, TABLE_HALF_X,
+    BASKET_EXCL_HALF_X, BASKET_EXCL_HALF_Y,
+)
+
+__all__ = [
+    "BASKET_CENTER_X", "BASKET_CENTER_Y",
+    "TABLE_CENTER_X", "TABLE_CENTER_Y", "TABLE_TOP_Z", "TABLE_HALF_X",
+    "BASKET_EXCL_HALF_X", "BASKET_EXCL_HALF_Y",
+    # robot
+    "EE_BODY_NAME", "ARM_JOINT_NAMES", "GRIPPER_JOINT_NAMES",
+    "GRIPPER_OPEN_POS", "GRIPPER_CLOSE_POS", "OBJ_GRIPPER_CLOSE_POS",
+    "ACTION_SCALE",
+    # state machine
+    "STEPS", "STATE_ORDER", "OBJ_STATE_STEP_OVERRIDES",
+    # geometry
+    "PRE_GRASP_CLEARANCE", "GRASP_Z_OFFSET", "OBJ_GRASP_Z_OFFSETS",
+    "OBJ_CLOSE_Z_OFFSETS",
+    "OBJ_GRASP_YAW_OFFSETS", "OBJ_CARRY_Z", "OBJ_PLACE_HEIGHTS",
+    "OBJ_PLACE_XY_OFFSETS", "OBJ_TRANSPORT_GRIPPER_CMDS",
+    "OBJ_KEEP_GRASP_QUAT_STATES", "OBJ_TRANSPORT_PUSH_BIASES",
+    "OBJ_MANIPULATION_MODES", "OBJ_PUSH_GRIPPER_CMDS",
+    "OBJ_PUSH_APPROACH_CLEARANCE",
+    "OBJ_PUSH_X_GAINS", "OBJ_PUSH_MAX_X_CORRECTIONS",
+    "OBJ_PUSH_Y_GAINS", "OBJ_PUSH_MAX_Y_CORRECTIONS",
+    "OBJ_PUSH_MIN_BEHIND",
+    "OBJ_SERVO_TO_BASKET_STATES", "OBJ_SERVO_XY_GAINS", "OBJ_SERVO_MAX_XY",
+    "OBJ_SERVO_HOLD_STATES", "OBJ_SERVO_EXTRA_STEPS",
+    "OBJ_FINGER_CENTER_SERVO_STATES", "OBJ_FINGER_CENTER_SERVO_GAIN",
+    "OBJ_FINGER_CENTER_SERVO_MAX_XY", "OBJ_FINGER_CENTER_SERVO_TARGET_Z",
+    "OBJ_FINGER_CENTER_SERVO_MAX_Z",
+    "CARRY_Z", "PLACE_HEIGHT",
+    "RETRACT_POS_X", "RETRACT_POS_Y",
+    "DEFAULT_PLACE_QUAT_W",
+    # success check
+    "BASKET_IN_X", "BASKET_IN_Y",
+    # spawn regions
+    "OBJ_SPAWN_X_MIN", "OBJ_SPAWN_X_MAX", "OBJ_SPAWN_Z", "OBJ_SPAWN_Y_BANDS",
+    "OBJ_HALF_EXTENTS", "OBJ_BBOX_MARGIN", "OBJ_GRASP_CENTER_OFFSETS",
+    # camera
+    "CAM_POS", "CAM_ROT", "CAM_H", "CAM_W",
+    # actuator
+    "ACT_STIFFNESS", "ACT_DAMPING", "ACT_EFFORT_LIMIT", "ACT_VEL_LIMIT",
+    # warm-up
+    "WARMUP_STEPS", "SETTLE_STEPS",
+]
+
+# ------------------------------------------------------------------ #
+# Robot
+# ------------------------------------------------------------------ #
+EE_BODY_NAME        = "gripper_base"
+ARM_JOINT_NAMES     = ["joint1", "joint2", "joint3", "joint4", "joint5", "joint6"]
+GRIPPER_JOINT_NAMES = ["joint7", "joint8"]
+GRIPPER_OPEN_POS    = [0.035, -0.035]   # joint7, joint8
+GRIPPER_CLOSE_POS   = [0.0, 0.0]        # joint limits: joint7 >= 0, joint8 <= 0
+OBJ_GRIPPER_CLOSE_POS: dict[int, list[float]] = {}
+
+# Must match ActionsCfg: scale=0.5, use_default_offset=True
+#   env_action = (joint_target - default_joint_pos) / ACTION_SCALE
+ACTION_SCALE = 0.5
+
+# ------------------------------------------------------------------ #
+# State-machine
+# ------------------------------------------------------------------ #
+STEPS: dict[str, int] = {
+    "INIT":         100,
+    "PRE_GRASP":    220,
+    "REACH":        150,
+    "CLOSE":         80,
+    "LIFT":         170,
+    "TRANSPORT":    240,
+    "PLACE":         90,
+    "OPEN":          70,
+    "LIFT_RETRACT":  80,
+    "RETRACT":       80,
+}
+STATE_ORDER = ["INIT", "PRE_GRASP", "REACH", "CLOSE", "LIFT",
+               "TRANSPORT", "PLACE", "OPEN", "LIFT_RETRACT", "RETRACT"]
+OBJ_STATE_STEP_OVERRIDES: dict[int, dict[str, int]] = {
+    1: {
+        "TRANSPORT": 2200,
+        "PLACE": 300,
+    },
+    2: {
+        "TRANSPORT": 2200,
+        "PLACE": 300,
+    },
+}
+
+# ------------------------------------------------------------------ #
+# Geometry
+# ------------------------------------------------------------------ #
+PRE_GRASP_CLEARANCE = 0.12   # metres above object before descent
+GRASP_Z_OFFSET      = 0.09   # metres: gripper approach height above object centre
+
+CARRY_Z      = TABLE_TOP_Z + 0.40   # safe carry height
+PLACE_HEIGHT = TABLE_TOP_Z + 0.15   # height at which to release into basket
+
+RETRACT_POS_X = TABLE_CENTER_X + TABLE_HALF_X - 0.05
+RETRACT_POS_Y = TABLE_CENTER_Y
+DEFAULT_PLACE_QUAT_W = [0.0, 1.0, 0.0, 0.0]   # top-down orientation (w,x,y,z)
+
+# ------------------------------------------------------------------ #
+# Object spawn regions
+#
+#   object_1  Y ∈ [0.25, 0.29]   (top band)
+#   object_2  Y ∈ [0.14, 0.20]   (middle band)
+#   object_3  Y ∈ [0.03, 0.09]   (bottom band, closest to basket)
+# ------------------------------------------------------------------ #
+OBJ_SPAWN_X_MIN = TABLE_CENTER_X - 0.10
+OBJ_SPAWN_X_MAX = TABLE_CENTER_X + 0.10
+OBJ_SPAWN_Z     = TABLE_TOP_Z + 0.05
+
+# Per-object Y-bands: {object_idx: (y_min, y_max)}
+OBJ_SPAWN_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),
+}
+
+# Per-object 2-D bounding-box half-extents (metres, world XY plane, scale=1).
+# Used for AABB overlap rejection during randomisation.
+OBJ_HALF_EXTENTS: dict[int, tuple[float, float]] = {
+    1: (0.050, 0.044),   # Sugar box   (half_x, half_y)
+    2: (0.050, 0.030),   # Mustard bottle
+    3: (0.100, 0.040),   # Banana
+}
+OBJ_BBOX_MARGIN = 0.015  # extra clearance between object bounding boxes
+
+# The object USD roots are centered on the visible geometry.  Keep the XY target
+# on the root/contact point; compensate the Piper TCP primarily in Z through
+# OBJ_GRASP_Z_OFFSETS.
+OBJ_GRASP_CENTER_OFFSETS: dict[int, tuple[float, float, float]] = {
+    1: (0.025, 0.0, 0.0),  # Sugar box: compensate Piper fingertip centre offset
+    2: (0.060, 0.0, 0.0),  # Mustard bottle: grasp a narrower side section
+    3: (0.0, 0.0, 0.0),  # Banana already works from its root pose
+}
+OBJ_GRASP_Z_OFFSETS: dict[int, float] = {
+    1: 0.072,
+    2: 0.135,
+    3: GRASP_Z_OFFSET,
+}
+OBJ_CLOSE_Z_OFFSETS: dict[int, float] = {
+    1: 0.020,
+}
+OBJ_GRASP_YAW_OFFSETS: dict[int, float] = {
+    1: 0.0,
+    2: 0.0,
+    3: 0.0,
+}
+OBJ_CARRY_Z: dict[int, float] = {
+    1: CARRY_Z,
+    2: CARRY_Z,
+    3: CARRY_Z,
+}
+OBJ_PLACE_HEIGHTS: dict[int, float] = {
+    1: PLACE_HEIGHT,
+    2: PLACE_HEIGHT,
+    3: PLACE_HEIGHT,
+}
+OBJ_PLACE_XY_OFFSETS: dict[int, tuple[float, float]] = {
+    1: (0.0, 0.0),
+    2: (0.0, 0.0),
+    3: (0.040, 0.050),
+}
+OBJ_TRANSPORT_GRIPPER_CMDS: dict[int, str] = {
+    1: "close",
+    2: "close",
+    3: "close",
+}
+OBJ_KEEP_GRASP_QUAT_STATES: dict[int, tuple[str, ...]] = {
+    1: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"),
+    2: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"),
+    3: ("REACH", "CLOSE", "LIFT"),
+}
+OBJ_TRANSPORT_PUSH_BIASES: dict[int, tuple[float, float, float] | None] = {
+    1: None,
+    2: None,
+    3: None,
+}
+
+# Optional manipulation mode used by the candidate search.  "pick" keeps the
+# normal top-down grasp.  "push" turns the same state machine into a low,
+# table-contact pusher that drives the object centre to the basket.
+OBJ_MANIPULATION_MODES: dict[int, str] = {
+    1: "pick",
+    2: "pick",
+    3: "pick",
+}
+OBJ_PUSH_GRIPPER_CMDS: dict[int, str] = {
+    1: "close",
+    2: "close",
+}
+OBJ_PUSH_APPROACH_CLEARANCE: dict[int, float] = {
+    1: 0.14,
+    2: 0.14,
+}
+OBJ_PUSH_X_GAINS: dict[int, float] = {
+    1: 0.55,
+    2: 0.55,
+}
+OBJ_PUSH_MAX_X_CORRECTIONS: dict[int, float] = {
+    1: 0.08,
+    2: 0.08,
+}
+OBJ_PUSH_Y_GAINS: dict[int, float] = {
+    1: 0.85,
+    2: 0.85,
+}
+OBJ_PUSH_MAX_Y_CORRECTIONS: dict[int, float] = {
+    1: 0.22,
+    2: 0.22,
+}
+OBJ_PUSH_MIN_BEHIND: dict[int, float] = {
+    1: 0.035,
+    2: 0.030,
+}
+
+# For the hard objects, keep the arm target coupled to the measured object
+# position during carry/release.  This compensates for Piper gripper_base/TCP
+# offsets and small slips: the EE target is nudged in the direction that would
+# move the object centre into the basket.
+OBJ_SERVO_TO_BASKET_STATES: dict[int, tuple[str, ...]] = {
+    1: ("TRANSPORT", "PLACE", "OPEN"),
+    2: (),
+}
+OBJ_SERVO_XY_GAINS: dict[int, float] = {
+    1: 0.85,
+    2: 0.85,
+}
+OBJ_SERVO_MAX_XY: dict[int, float] = {
+    1: 0.28,
+    2: 0.24,
+}
+OBJ_SERVO_HOLD_STATES: dict[int, tuple[str, ...]] = {
+    1: ("PLACE",),
+    2: ("PLACE",),
+}
+OBJ_SERVO_EXTRA_STEPS: dict[int, int] = {
+    1: 500,
+    2: 500,
+}
+
+# Closed-loop correction used during scripted data generation.  The target pose
+# is nudged so the measured finger centre stays on the selected object centre,
+# which absorbs IK/tracking variation across random object positions.
+OBJ_FINGER_CENTER_SERVO_STATES: dict[int, tuple[str, ...]] = {
+    1: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE"),
+    2: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE"),
+}
+OBJ_FINGER_CENTER_SERVO_GAIN: dict[int, float] = {
+    1: 1.0,
+    2: 1.0,
+}
+OBJ_FINGER_CENTER_SERVO_MAX_XY: dict[int, float] = {
+    1: 0.12,
+    2: 0.12,
+}
+OBJ_FINGER_CENTER_SERVO_TARGET_Z: dict[int, float] = {
+    1: -0.025,
+}
+OBJ_FINGER_CENTER_SERVO_MAX_Z: dict[int, float] = {
+    1: 0.050,
+}
+
+# ------------------------------------------------------------------ #
+# Success / basket bounds
+# ------------------------------------------------------------------ #
+BASKET_IN_X = 0.20   # ± metres in X around BASKET_CENTER_X
+BASKET_IN_Y = 0.11   # ± metres in Y around BASKET_CENTER_Y
+
+# ------------------------------------------------------------------ #
+# Camera (for --save_video / --save_images)
+# ------------------------------------------------------------------ #
+CAM_H, CAM_W = 480, 640
+CAM_POS = (TABLE_CENTER_X - 1.2, TABLE_CENTER_Y, TABLE_TOP_Z + 0.8)
+CAM_ROT = (0.957, 0.0, 0.290, 0.0)   # ~34° around +Y → looks forward-down
+
+# ------------------------------------------------------------------ #
+# Actuator overrides for data collection (high stiffness for fast tracking)
+# ------------------------------------------------------------------ #
+ACT_STIFFNESS    = 800.0
+ACT_DAMPING      = 80.0
+ACT_EFFORT_LIMIT = 100.0
+ACT_VEL_LIMIT    = 100.0
+
+# ------------------------------------------------------------------ #
+# Warm-up / settle steps before recording starts
+# ------------------------------------------------------------------ #
+WARMUP_STEPS = 150
+SETTLE_STEPS = 30

scripts/act/task_e/state_machine.py

@@ -0,0 +1,439 @@
+"""Pick-place state machine and grasp-quaternion solver for Task E."""
+
+import torch
+from isaaclab.utils.math import matrix_from_quat, quat_from_matrix
+
+from .config import (
+    STEPS, STATE_ORDER, OBJ_STATE_STEP_OVERRIDES,
+    CARRY_Z, PLACE_HEIGHT,
+    RETRACT_POS_X, RETRACT_POS_Y,
+    GRASP_Z_OFFSET, OBJ_GRASP_Z_OFFSETS, OBJ_CLOSE_Z_OFFSETS,
+    OBJ_GRASP_YAW_OFFSETS,
+    BASKET_CENTER_X, BASKET_CENTER_Y,
+    DEFAULT_PLACE_QUAT_W,
+    OBJ_GRASP_CENTER_OFFSETS,
+    OBJ_CARRY_Z, OBJ_PLACE_HEIGHTS, OBJ_PLACE_XY_OFFSETS,
+    OBJ_TRANSPORT_GRIPPER_CMDS, OBJ_KEEP_GRASP_QUAT_STATES,
+    OBJ_TRANSPORT_PUSH_BIASES,
+    OBJ_MANIPULATION_MODES, OBJ_PUSH_GRIPPER_CMDS,
+    OBJ_PUSH_APPROACH_CLEARANCE,
+    OBJ_PUSH_X_GAINS, OBJ_PUSH_MAX_X_CORRECTIONS,
+    OBJ_PUSH_Y_GAINS, OBJ_PUSH_MAX_Y_CORRECTIONS,
+    OBJ_PUSH_MIN_BEHIND,
+    OBJ_SERVO_TO_BASKET_STATES, OBJ_SERVO_XY_GAINS, OBJ_SERVO_MAX_XY,
+    OBJ_SERVO_HOLD_STATES, OBJ_SERVO_EXTRA_STEPS,
+    BASKET_IN_X, BASKET_IN_Y,
+)
+
+
+def _build_grasp_matrix(long_axis: torch.Tensor, grip_z: torch.Tensor) -> torch.Tensor:
+    """Build a right-handed gripper rotation matrix given the object's long axis.
+
+    The Piper gripper jaw opens along its LOCAL Y axis, so local Y must be
+    perpendicular to the object's long axis.
+
+    Frame layout (columns of R_grip):
+      col 0 (local X) = align_dir  ∥ long_axis
+      col 1 (local Y) = jaw_dir    ⊥ long_axis  ← jaw opening direction
+      col 2 (local Z) = grip_z     pointing down
+
+    Right-hand check: col0 × col1 = align_dir × jaw_dir = grip_z ✓
+    """
+    jaw_dir   = torch.linalg.cross(long_axis, grip_z)   # ⊥ long_axis, in XY plane
+    jaw_dir   = jaw_dir / jaw_dir.norm().clamp(min=1e-6)
+    align_dir = torch.linalg.cross(jaw_dir, grip_z)     # ∥ long_axis
+    align_dir = align_dir / align_dir.norm().clamp(min=1e-6)
+    return torch.stack([align_dir, jaw_dir, grip_z], dim=1)   # (3, 3)
+
+
+def compute_grasp_quat(obj_quat_w: torch.Tensor, device: str) -> torch.Tensor:
+    """Compute a top-down grasp quaternion for the object.
+
+    Finds the object axis most aligned with the world XY-plane (the long axis),
+    builds a gripper frame where the jaw (local Y) is perpendicular to that axis,
+    then picks the candidate orientation closest to the default top-down pose.
+
+    Parameters
+    ----------
+    obj_quat_w : (4,) tensor, (w, x, y, z)
+    device     : torch device string
+
+    Returns
+    -------
+    grasp_quat : (4,) tensor, (w, x, y, z)
+    """
+    R_obj        = matrix_from_quat(obj_quat_w.unsqueeze(0)).squeeze(0)   # (3, 3)
+    grip_z       = torch.tensor([0.0, 0.0, -1.0], device=device)
+    default_quat = torch.tensor(DEFAULT_PLACE_QUAT_W, dtype=torch.float32, device=device)
+
+    # Project each object column-axis onto XY plane; keep the most horizontal one(s)
+    norms, axes_xy = [], []
+    for col in range(3):
+        ax = torch.tensor([R_obj[0, col].item(), R_obj[1, col].item(), 0.0], device=device)
+        norms.append(ax.norm().item())
+        axes_xy.append(ax)
+
+    best_norm  = max(norms)
+    candidates = [
+        axes_xy[c] / max(norms[c], 1e-6)
+        for c in range(3)
+        if norms[c] >= best_norm - 1e-3
+    ]
+
+    # Among candidates, pick the one whose grasp frame is closest to the default orientation
+    best_cos  = -2.0
+    long_axis = candidates[0]
+    for cand in candidates:
+        q_cand  = quat_from_matrix(_build_grasp_matrix(cand, grip_z).unsqueeze(0)).squeeze(0)
+        cos_sim = torch.abs((q_cand * default_quat).sum()).item()
+        if cos_sim > best_cos:
+            best_cos  = cos_sim
+            long_axis = cand
+
+    R_grip = _build_grasp_matrix(long_axis, grip_z)                  # (3, 3)
+    return quat_from_matrix(R_grip.unsqueeze(0)).squeeze(0)           # (4,) w,x,y,z
+
+
+def _quat_mul(q1: torch.Tensor, q2: torch.Tensor) -> torch.Tensor:
+    w1, x1, y1, z1 = q1.unbind()
+    w2, x2, y2, z2 = q2.unbind()
+    return torch.stack([
+        w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
+        w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
+        w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2,
+        w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2,
+    ])
+
+
+class PickPlaceStateMachine:
+    """Finite state machine that sequences pick-and-place for multiple objects.
+
+    States (in order): INIT → PRE_GRASP → REACH → CLOSE → LIFT →
+                       TRANSPORT → PLACE → OPEN → RETRACT → (next object or done)
+    """
+
+    def __init__(self, object_indices: list[int], device: str):
+        self._obj_indices = object_indices
+        self._device      = device
+        self._grasp_quat_cache: dict[int, torch.Tensor] = {}
+        self.reset()
+
+    def reset(self) -> None:
+        self._ptr             = 0
+        self._state_idx       = 0
+        self._count           = 0
+        self.done             = False
+        self._cached_obj_pos: torch.Tensor | None = None
+        self._servo_extra_counts: dict[tuple[int, str], int] = {}
+        self._grasp_quat_cache.clear()
+
+    def set_grasp_quat(self, obj_idx: int, obj_quat_w: torch.Tensor) -> None:
+        """Pre-compute and cache the grasp quaternion for one object."""
+        grasp_quat = compute_grasp_quat(obj_quat_w, self._device)
+        yaw = OBJ_GRASP_YAW_OFFSETS.get(obj_idx, 0.0)
+        if abs(yaw) > 1e-6:
+            half = torch.tensor(0.5 * yaw, dtype=torch.float32, device=self._device)
+            yaw_quat = torch.stack([
+                torch.cos(half),
+                torch.tensor(0.0, dtype=torch.float32, device=self._device),
+                torch.tensor(0.0, dtype=torch.float32, device=self._device),
+                torch.sin(half),
+            ])
+            grasp_quat = _quat_mul(yaw_quat, grasp_quat)
+            grasp_quat = grasp_quat / grasp_quat.norm().clamp(min=1e-6)
+        self._grasp_quat_cache[obj_idx] = grasp_quat
+
+    def tick(self, obj_pos: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, str]:
+        """Advance the state machine by one step.
+
+        Parameters
+        ----------
+        obj_pos : (3,) tensor — current object position in world frame
+
+        Returns
+        -------
+        ee_pos_des  : (3,) target EE position
+        ee_quat_des : (4,) target EE orientation (w,x,y,z)
+        gripper_cmd : "open" | "close"
+        """
+        s = self.state
+        d = self._device
+
+        # Freeze object position at start of PRE_GRASP to avoid drift during descent
+        if s == "PRE_GRASP" and self._count == 0:
+            self._cached_obj_pos = obj_pos.clone()
+        if s in ("REACH", "CLOSE", "LIFT") and self._cached_obj_pos is not None:
+            obj_pos = self._cached_obj_pos
+
+        ee_pos, gripper = self._get_target_pos_gripper(s, obj_pos, d)
+        ee_quat         = self._get_target_quat(s, d)
+
+        self._count += 1
+        if self._count >= self._get_state_steps(s):
+            if self._should_hold_servo_state(s, obj_pos):
+                self._count = self._get_state_steps(s) - 1
+                return ee_pos, ee_quat, gripper
+            self._count = 0
+            if s == "RETRACT":
+                self._ptr          += 1
+                self._cached_obj_pos = None
+                if self._ptr >= len(self._obj_indices):
+                    self.done = True
+                    return ee_pos, ee_quat, gripper
+                self._state_idx = STATE_ORDER.index("PRE_GRASP")
+            else:
+                self._state_idx += 1
+
+        return ee_pos, ee_quat, gripper
+
+    # ------------------------------------------------------------------ #
+    # Properties
+    # ------------------------------------------------------------------ #
+
+    @property
+    def state(self) -> str:
+        return STATE_ORDER[self._state_idx]
+
+    @property
+    def current_object_key(self) -> str:
+        return f"object_{self._obj_indices[self._ptr]}"
+
+    # ------------------------------------------------------------------ #
+    # Private helpers
+    # ------------------------------------------------------------------ #
+
+    def _get_target_pos_gripper(
+        self, s: str, obj_pos: torch.Tensor, d: str
+    ) -> tuple[torch.Tensor, str]:
+        if self._is_push_mode():
+            return self._get_push_target_pos_gripper(s, obj_pos, d)
+
+        grasp_pos = self._get_grasp_pos(obj_pos, d)
+        if s == "INIT":
+            return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open"
+        elif s == "PRE_GRASP":
+            p = grasp_pos.clone(); p[2] = CARRY_Z
+            return p, "open"
+        elif s == "REACH":
+            p = grasp_pos.clone(); p[2] += self._get_grasp_z_offset()
+            return p, "open"
+        elif s == "CLOSE":
+            p = grasp_pos.clone(); p[2] += self._get_close_z_offset()
+            return p, "close"
+        elif s == "LIFT":
+            p = grasp_pos.clone(); p[2] = self._get_carry_z()
+            return p, self._get_transport_gripper_cmd()
+        elif s == "TRANSPORT":
+            servo = self._get_object_servo_target(s, obj_pos, grasp_pos, self._get_carry_z(), d)
+            if servo is not None:
+                return servo, self._get_transport_gripper_cmd()
+            x, y = self._get_place_xy()
+            return torch.tensor([x, y, self._get_carry_z()], device=d), self._get_transport_gripper_cmd()
+        elif s == "PLACE":
+            servo = self._get_object_servo_target(s, obj_pos, grasp_pos, self._get_place_height(), d)
+            if servo is not None:
+                return servo, self._get_transport_gripper_cmd()
+            x, y = self._get_place_xy()
+            return torch.tensor([x, y, self._get_place_height()], device=d), self._get_transport_gripper_cmd()
+        elif s == "OPEN":
+            servo = self._get_object_servo_target(s, obj_pos, grasp_pos, self._get_place_height(), d)
+            if servo is not None:
+                return servo, "open"
+            x, y = self._get_place_xy()
+            return torch.tensor([x, y, self._get_place_height()], device=d), "open"
+        elif s == "LIFT_RETRACT":
+            return torch.tensor([BASKET_CENTER_X, BASKET_CENTER_Y, CARRY_Z], device=d), "open"
+        elif s == "RETRACT":
+            return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open"
+        else:
+            raise ValueError(f"Unknown state: {s}")
+
+    def _get_grasp_pos(self, obj_pos: torch.Tensor, d: str) -> torch.Tensor:
+        cur_idx = self._obj_indices[min(self._ptr, len(self._obj_indices) - 1)]
+        offset = OBJ_GRASP_CENTER_OFFSETS.get(cur_idx, (0.0, 0.0, 0.0))
+        return obj_pos + torch.tensor(offset, dtype=torch.float32, device=d)
+
+    def _get_current_obj_idx(self) -> int:
+        return self._obj_indices[min(self._ptr, len(self._obj_indices) - 1)]
+
+    def _is_push_mode(self) -> bool:
+        return OBJ_MANIPULATION_MODES.get(self._get_current_obj_idx(), "pick") == "push"
+
+    def _get_push_gripper_cmd(self) -> str:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_PUSH_GRIPPER_CMDS.get(cur_idx, self._get_transport_gripper_cmd())
+
+    def _get_push_target_pos_gripper(
+        self, s: str, obj_pos: torch.Tensor, d: str
+    ) -> tuple[torch.Tensor, str]:
+        """Low table-contact pushing primitive for objects that do not pinch reliably."""
+        cur_idx = self._get_current_obj_idx()
+        contact_obj_pos = self._cached_obj_pos if self._cached_obj_pos is not None else obj_pos
+        start = self._get_grasp_pos(contact_obj_pos, d)
+        z_low = self._get_place_height()
+
+        if s == "INIT":
+            return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open"
+        if s == "PRE_GRASP":
+            p = start.clone()
+            p[2] = z_low + OBJ_PUSH_APPROACH_CLEARANCE.get(cur_idx, 0.14)
+            return p, "open"
+        if s in ("REACH", "CLOSE", "LIFT"):
+            p = start.clone()
+            p[2] = z_low
+            return p, self._get_push_gripper_cmd()
+        if s in ("TRANSPORT", "PLACE"):
+            place_x, place_y = self._get_place_xy()
+            target_xy = torch.tensor([place_x, place_y], dtype=torch.float32, device=d)
+            start_xy = contact_obj_pos[:2]
+
+            x_err = place_x - obj_pos[0]
+            x_gain = OBJ_PUSH_X_GAINS.get(cur_idx, 0.55)
+            x_max = OBJ_PUSH_MAX_X_CORRECTIONS.get(cur_idx, 0.08)
+            x_corr = torch.clamp(x_err * x_gain, min=-x_max, max=x_max)
+
+            progress = 1.0
+            if s == "TRANSPORT":
+                progress = min((self._count + 1) / max(self._get_state_steps(s), 1), 1.0)
+                progress = min(progress * 1.35, 1.0)
+            ref_xy = start_xy + (target_xy - start_xy) * progress
+            p_live = torch.cat([
+                ref_xy,
+                torch.tensor([z_low], dtype=torch.float32, device=d),
+            ])
+            offset = torch.tensor(
+                OBJ_GRASP_CENTER_OFFSETS.get(cur_idx, (0.0, 0.0, 0.0)),
+                dtype=torch.float32,
+                device=d,
+            )
+            p_live = p_live + offset
+            p_live[0] = p_live[0] + x_corr
+
+            # Keep the pusher on the rear side of the object.  If the reference
+            # sweep gets ahead of a lagging object, contact is lost or the object
+            # is knocked sideways instead of being driven into the basket.
+            min_behind = OBJ_PUSH_MIN_BEHIND.get(cur_idx, 0.03)
+            p_live[1] = torch.maximum(
+                p_live[1],
+                obj_pos[1] + torch.tensor(min_behind, dtype=torch.float32, device=d),
+            )
+
+            # During the hold phase, apply a bounded inward preload without
+            # allowing the pusher centre to cross in front of the object.
+            y_err = place_y - obj_pos[1]
+            y_gain = OBJ_PUSH_Y_GAINS.get(cur_idx, 0.85)
+            y_max = OBJ_PUSH_MAX_Y_CORRECTIONS.get(cur_idx, 0.22)
+            inward = torch.clamp(y_err * y_gain, min=-y_max, max=0.0)
+            p_live[1] = torch.maximum(p_live[1] + inward, obj_pos[1] + min_behind)
+            p_live[2] = z_low
+
+            if s == "TRANSPORT":
+                p = start + (p_live - start) * min(progress * 3.0, 1.0)
+            else:
+                p = p_live
+            return p, self._get_push_gripper_cmd()
+        if s == "OPEN":
+            p = self._get_grasp_pos(obj_pos, d)
+            p[2] = z_low
+            return p, "open"
+        if s == "LIFT_RETRACT":
+            x, y = self._get_place_xy()
+            return torch.tensor([x, y, CARRY_Z], device=d), "open"
+        if s == "RETRACT":
+            return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open"
+        raise ValueError(f"Unknown state: {s}")
+
+    def _get_grasp_z_offset(self) -> float:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_GRASP_Z_OFFSETS.get(cur_idx, GRASP_Z_OFFSET)
+
+    def _get_close_z_offset(self) -> float:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_CLOSE_Z_OFFSETS.get(cur_idx, self._get_grasp_z_offset())
+
+    def _get_carry_z(self) -> float:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_CARRY_Z.get(cur_idx, CARRY_Z)
+
+    def _get_place_height(self) -> float:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_PLACE_HEIGHTS.get(cur_idx, PLACE_HEIGHT)
+
+    def _get_place_xy(self) -> tuple[float, float]:
+        cur_idx = self._get_current_obj_idx()
+        dx, dy = OBJ_PLACE_XY_OFFSETS.get(cur_idx, (0.0, 0.0))
+        return BASKET_CENTER_X + dx, BASKET_CENTER_Y + dy
+
+    def _get_transport_gripper_cmd(self) -> str:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_TRANSPORT_GRIPPER_CMDS.get(cur_idx, "close")
+
+    def _get_state_steps(self, s: str) -> int:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_STATE_STEP_OVERRIDES.get(cur_idx, {}).get(s, STEPS[s])
+
+    def _get_transport_push_bias(self) -> tuple[float, float, float] | None:
+        cur_idx = self._get_current_obj_idx()
+        return OBJ_TRANSPORT_PUSH_BIASES.get(cur_idx)
+
+    def _get_object_servo_target(
+        self,
+        s: str,
+        obj_pos: torch.Tensor,
+        grasp_pos: torch.Tensor,
+        z: float,
+        d: str,
+    ) -> torch.Tensor | None:
+        cur_idx = self._get_current_obj_idx()
+        if s not in OBJ_SERVO_TO_BASKET_STATES.get(cur_idx, ()):
+            push_bias = self._get_transport_push_bias()
+            if push_bias is None:
+                return None
+            p = grasp_pos + torch.tensor(push_bias, dtype=torch.float32, device=d)
+            p[2] = z
+            return p
+
+        x, y = self._get_place_xy()
+        target_xy = torch.tensor([x, y], dtype=torch.float32, device=d)
+        xy_error = target_xy - obj_pos[:2]
+        gain = OBJ_SERVO_XY_GAINS.get(cur_idx, 1.0)
+        max_xy = OBJ_SERVO_MAX_XY.get(cur_idx, 0.25)
+        correction = xy_error * gain
+        norm = torch.linalg.norm(correction).clamp(min=1e-6)
+        if norm.item() > max_xy:
+            correction = correction / norm * max_xy
+        if s == "TRANSPORT":
+            progress = min((self._count + 1) / max(self._get_state_steps(s), 1), 1.0)
+            correction = correction * max(0.15, progress)
+
+        p = grasp_pos.clone()
+        p[:2] = p[:2] + correction
+        push_bias = self._get_transport_push_bias()
+        if push_bias is not None:
+            p = p + torch.tensor(push_bias, dtype=torch.float32, device=d)
+        p[2] = z
+        return p
+
+    def _should_hold_servo_state(self, s: str, obj_pos: torch.Tensor) -> bool:
+        cur_idx = self._get_current_obj_idx()
+        if s not in OBJ_SERVO_HOLD_STATES.get(cur_idx, ()):
+            return False
+        dx = abs(float(obj_pos[0].item() - BASKET_CENTER_X))
+        dy = abs(float(obj_pos[1].item() - BASKET_CENTER_Y))
+        if dx <= BASKET_IN_X * 0.85 and dy <= BASKET_IN_Y * 0.85:
+            return False
+        key = (cur_idx, s)
+        count = self._servo_extra_counts.get(key, 0)
+        if count >= OBJ_SERVO_EXTRA_STEPS.get(cur_idx, 0):
+            return False
+        self._servo_extra_counts[key] = count + 1
+        return True
+
+    def _get_target_quat(self, s: str, d: str) -> torch.Tensor:
+        default_quat = torch.tensor(DEFAULT_PLACE_QUAT_W, dtype=torch.float32, device=d)
+        cur_idx = self._get_current_obj_idx()
+        if self._is_push_mode() and s in ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"):
+            return self._grasp_quat_cache.get(cur_idx, default_quat)
+        if s in OBJ_KEEP_GRASP_QUAT_STATES.get(cur_idx, ("REACH", "CLOSE", "LIFT")):
+            return self._grasp_quat_cache.get(cur_idx, default_quat)
+        return default_quat

scripts/act/trace_task_e_policy.py

@@ -0,0 +1,84 @@
+"""Trace Task-E policy rollout with object positions at fixed intervals."""
+
+import argparse
+import os
+import sys
+
+from isaaclab.app import AppLauncher
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--checkpoint", required=True)
+parser.add_argument("--solution_module", default="solution_act")
+parser.add_argument("--task", default="ATEC-TaskE-Piper")
+parser.add_argument("--seed", type=int, default=11)
+parser.add_argument("--max_steps", type=int, default=1800)
+parser.add_argument("--interval", type=int, default=100)
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+args_cli.enable_cameras = True
+
+repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+demo_dir = os.path.join(repo_root, "demo")
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+if demo_dir not in sys.path:
+    sys.path.insert(0, demo_dir)
+os.environ["ATEC_ACT_POLICY_PATH"] = os.path.abspath(args_cli.checkpoint)
+
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+import importlib  # noqa: E402
+
+import gymnasium as gym  # noqa: E402
+import torch  # noqa: E402
+from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
+from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402
+
+import atec_rl_lab.tasks  # noqa: F401,E402
+from scripts.act.task_e.collector import basket_status_lines  # noqa: E402
+
+
+def _object_summary(env) -> str:
+    return " | ".join(basket_status_lines(env, [1, 2, 3]))
+
+
+def main() -> None:
+    env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1)
+    env_cfg.seed = args_cli.seed
+    env = gym.make(args_cli.task, cfg=env_cfg)
+    if isinstance(env.unwrapped, DirectMARLEnv):
+        env = multi_agent_to_single_agent(env)
+
+    policy = importlib.import_module(args_cli.solution_module).AlgSolution()
+    obs, _ = env.reset(seed=args_cli.seed)
+    policy.reset_episode()
+    total_reward = 0.0
+
+    try:
+        print(f"[TRACE_STEP] step=0 score=0.00 {_object_summary(env)}", flush=True)
+        for step in range(1, args_cli.max_steps + 1):
+            with torch.inference_mode():
+                resp = policy.predicts(obs, total_reward)
+                action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1)
+                obs, reward, terminated, truncated, info = env.step(action)
+            sim_dt = info["Step_dt"]
+            total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt
+            if step % args_cli.interval == 0 or bool(terminated.item() or truncated.item()):
+                print(
+                    f"[TRACE_STEP] step={step} score={total_reward:.2f} {_object_summary(env)}",
+                    flush=True,
+                )
+            if bool(terminated.item() or truncated.item()):
+                break
+        print(f"[RESULT] score={total_reward:.2f} steps={step}", flush=True)
+    finally:
+        env.close()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    finally:
+        simulation_app.close()

scripts/act/train_task_e.py

@@ -0,0 +1,442 @@
+ALGO_NAME = 'BC_ACT'
+
+import os
+import random
+import time
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Optional
+
+import h5py
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import torchvision.transforms as T
+from torch.utils.data.dataset import Dataset
+from torch.utils.data.sampler import RandomSampler, BatchSampler
+from torch.utils.data.dataloader import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+from diffusers.training_utils import EMAModel
+
+from atec_rl_lab.train.act.act.detr.backbone import build_backbone
+from atec_rl_lab.train.act.act.detr.transformer import build_transformer
+from atec_rl_lab.train.act.act.detr.detr_vae import build_encoder, DETRVAE
+from atec_rl_lab.train.act.act.utils import IterationBasedBatchSampler, worker_init_fn
+import tyro
+
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ATEC2026"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+
+    demo_path: str = './datasets/atec_task_e/trajectory.hdf5'
+    """path to the HDF5 demo dataset produced by collect_demos_task_e.py"""
+    num_demos: Optional[int] = None
+    """number of trajectories to load (None = all)"""
+    total_iters: int = 1_000_000
+    """total training iterations"""
+    batch_size: int = 256
+    """batch size"""
+
+    # ACT specific
+    lr: float = 1e-4
+    """learning rate"""
+    kl_weight: float = 10
+    """weight for the KL loss term"""
+    temporal_agg: bool = True
+    """if toggled, temporal ensembling will be performed at inference"""
+
+    # Backbone
+    position_embedding: str = 'sine'
+    backbone: str = 'resnet18'
+    lr_backbone: float = 1e-5
+    masks: bool = False
+    dilation: bool = False
+    include_depth: bool = False
+    """always False — depth not collected; kept for backbone API compatibility"""
+    include_rgb: bool = True
+    """use RGB images as input (requires --save_images during collection)"""
+
+    # Transformer
+    enc_layers: int = 2
+    dec_layers: int = 4
+    dim_feedforward: int = 512
+    hidden_dim: int = 256
+    dropout: float = 0.1
+    nheads: int = 8
+    num_queries: int = 30
+    pre_norm: bool = False
+    use_xsa: bool = False
+    """replace transformer self-attention/FFN blocks with the local XSA variant"""
+
+    log_freq: int = 1000
+    """frequency of logging training metrics"""
+    save_freq: int = 5000
+    """frequency of saving model checkpoints"""
+    num_dataload_workers: int = 0
+    """number of DataLoader worker processes"""
+    resume_checkpoint: Optional[str] = None
+    """optional checkpoint to continue training from"""
+    resume_iter: Optional[int] = None
+    """absolute iteration for a legacy checkpoint that does not store train_iter"""
+
+
+class DemoDataset_ACT(Dataset):
+    """Load IsaacLab Task-E HDF5 demos into memory.
+
+    HDF5 structure (produced by collect_demos_task_e.py):
+        traj_N/obs          (T, 8)       joint positions (qpos)
+        traj_N/actions      (T, 8)       env actions
+        traj_N/images/rgb   (T, H, W, 3) uint8 RGB — optional
+    """
+
+    def __init__(self, data_path: str, num_queries: int,
+                 num_traj: Optional[int] = None, include_rgb: bool = True):
+        self.num_queries = num_queries
+        self.include_rgb = include_rgb
+        self.transforms = T.Resize((224, 224), antialias=True)
+
+        # load raw data
+        states_list: list[torch.Tensor] = []
+        actions_list: list[torch.Tensor] = []
+        rgb_list: list[torch.Tensor] = []   # only when include_rgb is True
+        has_images = None
+
+        with h5py.File(data_path, 'r') as f:
+            traj_keys = sorted(f.keys(), key=lambda k: int(k.split('_')[1]))
+            if num_traj is not None:
+                traj_keys = traj_keys[:num_traj]
+
+            for key in traj_keys:
+                grp = f[key]
+                states_list.append(torch.from_numpy(grp['obs'][:].astype(np.float32)))
+                actions_list.append(torch.from_numpy(grp['actions'][:].astype(np.float32)))
+
+                if include_rgb:
+                    if has_images is None:
+                        has_images = 'images' in grp
+                    if has_images and 'images' in grp:
+                        rgb_arr = grp['images/rgb'][:]          # (T, H, W, 3) uint8
+                        rgb_t = torch.from_numpy(rgb_arr)       # uint8
+                        # (T, 3, H, W) → resize → (T, 3, 224, 224)
+                        rgb_t = self.transforms(rgb_t.permute(0, 3, 1, 2))
+                        # add camera dim → (T, 1, 3, 224, 224)
+                        rgb_list.append(rgb_t.unsqueeze(1))
+
+        if has_images is None:
+            has_images = False
+        self.has_images = has_images and include_rgb and len(rgb_list) > 0
+
+        if include_rgb and not self.has_images:
+            print('[WARN] include_rgb=True but no images found in dataset. '
+                  'Re-collect with --save_images, or set include_rgb=False.')
+
+        self.num_traj = len(states_list)
+        self.states  = states_list   # list of (T, 8)
+        self.actions = actions_list  # list of (T, 8)
+        self.rgb     = rgb_list      # list of (T, 1, 3, 224, 224) or empty
+
+        # state/action dims
+        self.state_dim = self.states[0].shape[1]
+        self.act_dim   = self.actions[0].shape[1]
+
+        # index slices: (traj_idx, timestep)
+        self.slices = [
+            (i, t)
+            for i, acts in enumerate(self.actions)
+            for t in range(acts.shape[0])
+        ]
+        print(f'Loaded {self.num_traj} trajectories, {len(self.slices)} timesteps. '
+              f'state_dim={self.state_dim}, act_dim={self.act_dim}, '
+              f'has_images={self.has_images}')
+
+        # normalisation stats (pd_joint_pos = absolute actions → normalise)
+        self.norm_stats = self._compute_norm_stats()
+
+    # ------------------------------------------------------------------
+
+    def _pad_action(self, act_seq: torch.Tensor) -> torch.Tensor:
+        """Pad a short action chunk by repeating the last action."""
+        shortage = self.num_queries - act_seq.shape[0]
+        if shortage > 0:
+            act_seq = torch.cat([act_seq, act_seq[-1:].repeat(shortage, 1)], dim=0)
+        return act_seq
+
+    def _compute_norm_stats(self) -> dict:
+        # Vectorised: stack each full trajectory then slice — avoids 110k tiny ops
+        all_states  = torch.cat(self.states,  dim=0)   # (total_T, state_dim)
+        all_actions = torch.cat(self.actions, dim=0)   # (total_T, act_dim)
+
+        state_mean = all_states.mean(0,  keepdim=True)
+        state_std  = all_states.std(0,   keepdim=True).clamp(1e-2)
+        act_mean   = all_actions.mean(0, keepdim=True)
+        act_std    = all_actions.std(0,  keepdim=True).clamp(1e-2)
+
+        return dict(state_mean=state_mean, state_std=state_std,
+                    action_mean=act_mean,  action_std=act_std)
+
+    def __len__(self):
+        return len(self.slices)
+
+    def __getitem__(self, index):
+        traj_idx, ts = self.slices[index]
+
+        state   = self.states[traj_idx][ts]
+        act_seq = self._pad_action(self.actions[traj_idx][ts:ts + self.num_queries])
+
+        # normalise
+        state   = (state   - self.norm_stats['state_mean'][0])  / self.norm_stats['state_std'][0]
+        act_seq = (act_seq - self.norm_stats['action_mean'])     / self.norm_stats['action_std']
+
+        obs = dict(state=state)
+        if self.has_images:
+            obs['rgb'] = self.rgb[traj_idx][ts]   # (1, 3, 224, 224) uint8
+
+        return {'observations': obs, 'actions': act_seq}
+
+
+
+class Agent(nn.Module):
+    def __init__(self, state_dim: int, act_dim: int, args: Args):
+        super().__init__()
+        self.state_dim  = state_dim
+        self.act_dim    = act_dim
+        self.kl_weight  = args.kl_weight
+        self.normalize  = T.Normalize(mean=[0.485, 0.456, 0.406],
+                                      std=[0.229, 0.224, 0.225])
+        self.include_rgb = args.include_rgb
+
+        # CNN backbone — None for state-only mode (DETRVAE handles both paths)
+        backbones = [build_backbone(args)] if args.include_rgb else None
+
+        # CVAE decoder
+        transformer = build_transformer(args)
+
+        # CVAE encoder
+        encoder = build_encoder(args)
+
+        # ACT ( CVAE encoder + (CNN backbones + CVAE decoder) )
+        self.model = DETRVAE(
+            backbones,
+            transformer,
+            encoder,
+            state_dim=state_dim,
+            action_dim=act_dim,
+            num_queries=args.num_queries,
+        )
+
+    def _preprocess_rgb(self, obs: dict) -> None:
+        if self.include_rgb and 'rgb' in obs:
+            obs['rgb'] = obs['rgb'].float() / 255.0
+            # obs['rgb']: (B, num_cams, 3, 224, 224)
+            B, N, C, H, W = obs['rgb'].shape
+            obs['rgb'] = self.normalize(obs['rgb'].view(B * N, C, H, W)).view(B, N, C, H, W)
+
+    def _model_input(self, obs: dict):
+        # DETRVAE state-only path expects the state tensor directly, not a dict
+        return obs if self.include_rgb else obs['state']
+
+    def compute_loss(self, obs: dict, action_seq: torch.Tensor) -> dict:
+        self._preprocess_rgb(obs)
+        a_hat, (mu, logvar) = self.model(self._model_input(obs), action_seq)
+
+        total_kld, _, _ = kl_divergence(mu, logvar)
+        l1 = F.l1_loss(action_seq, a_hat)
+
+        return dict(l1=l1, kl=total_kld[0],
+                    loss=l1 + total_kld[0] * self.kl_weight)
+
+    def get_action(self, obs: dict) -> torch.Tensor:
+        self._preprocess_rgb(obs)
+        a_hat, _ = self.model(self._model_input(obs))
+        return a_hat
+
+
+def kl_divergence(mu, logvar):
+    if mu.data.ndimension() == 4:
+        mu     = mu.view(mu.size(0),     mu.size(1))
+        logvar = logvar.view(logvar.size(0), logvar.size(1))
+    klds       = -0.5 * (1 + logvar - mu.pow(2) - logvar.exp())
+    total_kld  = klds.sum(1).mean(0, True)
+    dim_kld    = klds.mean(0)
+    mean_kld   = klds.mean(1).mean(0, True)
+    return total_kld, dim_kld, mean_kld
+
+
+def save_ckpt(run_name: str, tag: str, train_iter: int) -> None:
+    os.makedirs(f'runs/{run_name}/checkpoints', exist_ok=True)
+    ema.copy_to(ema_agent.parameters())
+    ckpt = {
+        'norm_stats': dataset.norm_stats,
+        'model_args': vars(args),
+        'train_iter': train_iter,
+        'agent':      agent.state_dict(),
+        'ema_agent':  ema_agent.state_dict(),
+        'optimizer':  optimizer.state_dict(),
+        'lr_scheduler': lr_scheduler.state_dict(),
+    }
+    if hasattr(ema, 'state_dict'):
+        ckpt['ema'] = ema.state_dict()
+    torch.save(ckpt, f'runs/{run_name}/checkpoints/{tag}.pt')
+    print(f'[INFO] Saved checkpoint: runs/{run_name}/checkpoints/{tag}.pt')
+
+if __name__ == '__main__':
+    args = tyro.cli(Args)
+
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[:-len('.py')]
+        run_name = f"{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device('cuda' if torch.cuda.is_available() and args.cuda else 'cpu')
+
+    # dataset & dataloader
+    dataset = DemoDataset_ACT(
+        args.demo_path,
+        num_queries=args.num_queries,
+        num_traj=args.num_demos,
+        include_rgb=args.include_rgb,
+    )
+    if args.num_demos is None:
+        args.num_demos = dataset.num_traj
+
+    sampler       = RandomSampler(dataset, replacement=False)
+    batch_sampler = BatchSampler(sampler, batch_size=args.batch_size, drop_last=True)
+    start_iter = 0
+    batch_sampler = IterationBasedBatchSampler(batch_sampler, args.total_iters)
+    train_dataloader = DataLoader(
+        dataset,
+        batch_sampler=batch_sampler,
+        num_workers=args.num_dataload_workers,
+        worker_init_fn=lambda wid: worker_init_fn(wid, base_seed=args.seed),
+    )
+
+    # logging
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            save_code=True,
+            group='ACT',
+            tags=['act'],
+        )
+    writer = SummaryWriter(f'runs/{run_name}')
+    writer.add_text(
+        'hyperparameters',
+        '|param|value|\n|-|-|\n' +
+        '\n'.join(f'|{k}|{v}|' for k, v in vars(args).items()),
+    )
+
+    # agent
+    agent     = Agent(dataset.state_dim, dataset.act_dim, args).to(device)
+    ema_agent = Agent(dataset.state_dim, dataset.act_dim, args).to(device)
+
+    param_dicts = [
+        {'params': [p for n, p in agent.named_parameters()
+                    if 'backbone' not in n and p.requires_grad]},
+        {'params': [p for n, p in agent.named_parameters()
+                    if 'backbone'     in n and p.requires_grad],
+         'lr': args.lr_backbone},
+    ]
+    optimizer    = optim.AdamW(param_dicts, lr=args.lr, weight_decay=1e-4)
+    lr_drop      = max(int(2 / 3 * args.total_iters), 1)
+    lr_scheduler = optim.lr_scheduler.StepLR(optimizer, lr_drop)
+    ema          = EMAModel(parameters=agent.parameters(), power=0.75)
+
+    if args.resume_checkpoint:
+        ckpt = torch.load(args.resume_checkpoint, map_location=device, weights_only=False)
+        weight_key = 'agent'
+        if weight_key not in ckpt:
+            raise KeyError(f"Checkpoint {args.resume_checkpoint} has no '{weight_key}' weights")
+        agent.load_state_dict(ckpt[weight_key])
+        if 'ema_agent' in ckpt:
+            ema_agent.load_state_dict(ckpt['ema_agent'])
+        if 'optimizer' in ckpt:
+            optimizer.load_state_dict(ckpt['optimizer'])
+        if 'lr_scheduler' in ckpt:
+            lr_scheduler.load_state_dict(ckpt['lr_scheduler'])
+        if 'ema' in ckpt and hasattr(ema, 'load_state_dict'):
+            ema.load_state_dict(ckpt['ema'])
+        start_iter = int(ckpt.get('train_iter') or args.resume_iter or 0)
+        if start_iter >= args.total_iters:
+            raise ValueError(
+                f"resume start_iter={start_iter} is >= total_iters={args.total_iters}; "
+                "increase --total_iters or choose an earlier checkpoint"
+            )
+        print(f'[INFO] Resumed checkpoint {args.resume_checkpoint} at iter {start_iter}')
+
+    # training loop
+    agent.train()
+    best_loss = float('inf')
+    timings   = defaultdict(float)
+
+    for local_iter, data_batch in enumerate(train_dataloader):
+        cur_iter = start_iter + local_iter
+        if cur_iter >= args.total_iters:
+            break
+        last_tick = time.time()
+
+        obs_batch = {k: v.to(device, non_blocking=True)
+                     for k, v in data_batch['observations'].items()}
+        act_batch = data_batch['actions'].to(device, non_blocking=True)
+
+        loss_dict  = agent.compute_loss(obs=obs_batch, action_seq=act_batch)
+        total_loss = loss_dict['loss']
+
+        optimizer.zero_grad()
+        total_loss.backward()
+        optimizer.step()
+        lr_scheduler.step()
+        ema.step(agent.parameters())
+
+        timings['update'] += time.time() - last_tick
+
+        if cur_iter % args.log_freq == 0:
+            loss_val = total_loss.item()
+            print(f'Iter {cur_iter:7d}  loss={loss_val:.4f}  '
+                  f'l1={loss_dict["l1"].item():.4f}  '
+                  f'kl={loss_dict["kl"].item():.4f}')
+            writer.add_scalar('charts/lr',          optimizer.param_groups[0]['lr'], cur_iter)
+            writer.add_scalar('charts/lr_backbone', optimizer.param_groups[1]['lr'], cur_iter)
+            writer.add_scalar('losses/total',       loss_val,                        cur_iter)
+            writer.add_scalar('losses/l1',          loss_dict['l1'].item(),          cur_iter)
+            writer.add_scalar('losses/kl',          loss_dict['kl'].item(),          cur_iter)
+            for k, v in timings.items():
+                writer.add_scalar(f'time/{k}', v, cur_iter)
+
+            if loss_val < best_loss:
+                best_loss = loss_val
+                save_ckpt(run_name, 'best_loss', cur_iter)
+
+        if args.save_freq > 0 and cur_iter % args.save_freq == 0 and cur_iter > 0:
+            save_ckpt(run_name, str(cur_iter), cur_iter)
+
+    save_ckpt(run_name, 'final', min(args.total_iters, cur_iter + 1))
+    writer.close()
+    print(f'[INFO] Training done. Run: runs/{run_name}')

scripts/graspnet_task_e/__init__.py

@@ -0,0 +1,2 @@
+"""GraspNet adapters for ATEC Task E."""
+

scripts/graspnet_task_e/anygrasp_adapter.py

@@ -0,0 +1,228 @@
+"""AnyGrasp SDK bridge for ATEC Task E.
+
+AnyGrasp predicts grasp candidates from RGB-D point clouds in the camera frame.
+For Task E we keep the same execution contract as the TunTun/GraspNet adapter:
+use the model for contact centre, jaw yaw, score and width, then hand a
+top-down-friendly world-frame ``TaskEGrasp`` to the existing Piper primitive.
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+import ctypes
+import os
+import sys
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+from scripts.graspnet_task_e.tuntun_adapter import TaskEGrasp, camera_arrays
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+ANYGRASP_ROOT = REPO_ROOT / "third_party" / "anygrasp_sdk"
+DETECTION_ROOT = ANYGRASP_ROOT / "grasp_detection"
+CHECKPOINT_PATH = DETECTION_ROOT / "log" / "checkpoint_detection.tar"
+SSL11_DIR = Path(
+    "/home/ubuntu/projects/manipdojo2026/micromamba/envs/genmanip-sim/lib/python3.10/site-packages/"
+    "isaacsim/exts/omni.isaac.ros2_bridge/humble/lib"
+)
+TOOLS_DIR = REPO_ROOT / "tools" / "anygrasp"
+
+
+def _ensure_anygrasp_paths() -> None:
+    det = str(DETECTION_ROOT)
+    if det not in sys.path:
+        sys.path.insert(0, det)
+    tools = str(TOOLS_DIR)
+    old_path = os.environ.get("PATH", "")
+    if TOOLS_DIR.exists() and tools not in old_path.split(":"):
+        os.environ["PATH"] = f"{tools}:{old_path}" if old_path else tools
+    ssl = str(SSL11_DIR)
+    old_ld = os.environ.get("LD_LIBRARY_PATH", "")
+    if SSL11_DIR.exists() and ssl not in old_ld.split(":"):
+        os.environ["LD_LIBRARY_PATH"] = f"{ssl}:{old_ld}" if old_ld else ssl
+    # lib_cxx.so is linked against OpenSSL 1.1.  In long-running Isaac Python
+    # processes, changing LD_LIBRARY_PATH after startup is not enough, so load
+    # the exact libraries by absolute path before importing gsnet/lib_cxx.
+    for name in ("libcrypto.so.1.1", "libssl.so.1.1"):
+        path = SSL11_DIR / name
+        if path.exists():
+            ctypes.CDLL(str(path), mode=ctypes.RTLD_GLOBAL)
+
+
+def _check_anygrasp_files() -> None:
+    missing = []
+    for path in [
+        DETECTION_ROOT / "gsnet.so",
+        DETECTION_ROOT / "lib_cxx.so",
+        DETECTION_ROOT / "license" / "licenseCfg.json",
+        CHECKPOINT_PATH,
+    ]:
+        if not path.exists():
+            missing.append(str(path))
+    if missing:
+        raise FileNotFoundError("AnyGrasp SDK is not fully installed:\n" + "\n".join(missing))
+
+
+@lru_cache(maxsize=1)
+def _load_anygrasp_detector():
+    _ensure_anygrasp_paths()
+    _check_anygrasp_files()
+    from argparse import Namespace
+    from gsnet import AnyGrasp
+
+    cfg = Namespace(
+        checkpoint_path=str(CHECKPOINT_PATH),
+        max_gripper_width=0.085,
+        gripper_height=0.03,
+        top_down_grasp=True,
+        debug=False,
+    )
+    detector = AnyGrasp(cfg)
+    detector.load_net()
+    return detector
+
+
+def _points_from_rgbd(
+    rgb: np.ndarray,
+    depth: np.ndarray,
+    mask: np.ndarray,
+    K: np.ndarray,
+    *,
+    expand_px: int = 0,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    use_mask = mask > 0
+    if expand_px > 0 and np.any(use_mask):
+        ys0, xs0 = np.where(use_mask)
+        y1 = max(int(ys0.min()) - expand_px, 0)
+        y2 = min(int(ys0.max()) + expand_px + 1, mask.shape[0])
+        x1 = max(int(xs0.min()) - expand_px, 0)
+        x2 = min(int(xs0.max()) + expand_px + 1, mask.shape[1])
+        use_mask = np.zeros_like(use_mask, dtype=bool)
+        use_mask[y1:y2, x1:x2] = True
+    valid = use_mask & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
+    ys, xs = np.where(valid)
+    if len(xs) == 0:
+        raise RuntimeError("No valid masked depth points for AnyGrasp.")
+
+    z = depth[ys, xs].astype(np.float32)
+    x = (xs.astype(np.float32) - float(K[0, 2])) / float(K[0, 0]) * z
+    y = (ys.astype(np.float32) - float(K[1, 2])) / float(K[1, 1]) * z
+    points = np.stack([x, y, z], axis=1).astype(np.float32)
+    colors = (rgb[ys, xs, :3].astype(np.float32) / 255.0).astype(np.float32)
+    return points, colors, np.stack([ys, xs], axis=1)
+
+
+def _lims_for_points(points: np.ndarray, pad: float = 0.04) -> list[float]:
+    lo = points.min(axis=0)
+    hi = points.max(axis=0)
+    return [
+        float(lo[0] - pad),
+        float(hi[0] + pad),
+        float(lo[1] - pad),
+        float(hi[1] + pad),
+        float(max(0.0, lo[2] - pad)),
+        float(hi[2] + pad),
+    ]
+
+
+def _select_anygrasp_candidate(gg, points_cam: np.ndarray):
+    if gg is None or len(gg) == 0:
+        raise RuntimeError("AnyGrasp returned no grasps after filtering.")
+    gg = gg.nms().sort_by_score()
+    grasps = list(gg)
+    if not grasps:
+        raise RuntimeError("AnyGrasp returned no grasps after filtering.")
+
+    center = np.median(points_cam, axis=0)
+    spread = float(np.linalg.norm(np.percentile(points_cam, 90, axis=0) - np.percentile(points_cam, 10, axis=0)))
+    spread = max(spread, 1e-3)
+
+    def rank(g) -> float:
+        dist = float(np.linalg.norm(np.asarray(g.translation, dtype=np.float64) - center))
+        # Keep score dominant, but reject edge candidates that are far from the
+        # segmented object core. This mirrors the proven GraspNet selector.
+        return float(g.score) * 0.65 + max(0.0, 1.0 - dist / spread) * 0.35
+
+    return max(grasps[:128], key=rank)
+
+
+def infer_anygrasp_from_camera(camera, mask: np.ndarray) -> TaskEGrasp:
+    """Run AnyGrasp SDK and convert the selected grasp to Task-E world pose."""
+    rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
+    detector = _load_anygrasp_detector()
+    attempts = [
+        (0, 0.04, True, False, True),
+        (0, 0.08, False, False, False),
+        (24, 0.08, False, False, False),
+    ]
+    last_error: Exception | None = None
+    points_cam = colors = None
+    grasp = None
+    for expand_px, lim_pad, apply_object_mask, dense_grasp, collision_detection in attempts:
+        try:
+            points_cam, colors, _pixels = _points_from_rgbd(rgb, depth, mask, K, expand_px=expand_px)
+            if len(points_cam) < 64:
+                raise RuntimeError(f"Too few masked points for AnyGrasp: {len(points_cam)}")
+            lims = _lims_for_points(points_cam, pad=lim_pad)
+            print(
+                "[ANYGRASP] "
+                f"points={len(points_cam)} expand_px={expand_px} lim_pad={lim_pad:.3f} "
+                f"object_mask={apply_object_mask} dense={dense_grasp} collision={collision_detection}",
+                flush=True,
+            )
+            gg, _cloud = detector.get_grasp(
+                points_cam,
+                colors,
+                lims=lims,
+                apply_object_mask=apply_object_mask,
+                dense_grasp=dense_grasp,
+                collision_detection=collision_detection,
+            )
+            grasp = _select_anygrasp_candidate(gg, points_cam)
+            break
+        except Exception as exc:
+            last_error = exc
+            print(f"[ANYGRASP] attempt failed: {exc}", flush=True)
+    if grasp is None or points_cam is None:
+        raise RuntimeError(f"AnyGrasp failed for all attempts: {last_error}")
+
+    rot_w_cam = Rotation.from_quat(
+        [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
+    ).as_matrix()
+    t_cam = np.asarray(grasp.translation, dtype=np.float64)
+    t_w = rot_w_cam @ t_cam + pos_w
+
+    pts_w = (rot_w_cam @ points_cam.astype(np.float64).T).T + pos_w
+    z_gate = float(np.percentile(pts_w[:, 2], 70))
+    upper = pts_w[pts_w[:, 2] >= z_gate]
+    if len(upper) > 16:
+        t_w[:2] = np.median(upper[:, :2], axis=0)
+    else:
+        t_w[:2] = np.median(pts_w[:, :2], axis=0)
+    t_w[2] = float(np.percentile(pts_w[:, 2], 85))
+
+    R_cam_grasp = np.asarray(grasp.rotation_matrix, dtype=np.float64)
+    jaw_hint_w = rot_w_cam @ R_cam_grasp[:, 1]
+    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 = 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 = align_x / max(np.linalg.norm(align_x), 1e-6)
+    jaw_y = np.cross(grip_z, align_x)
+    jaw_y = jaw_y / max(np.linalg.norm(jaw_y), 1e-6)
+    R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1)
+    quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat()
+    quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64)
+
+    return TaskEGrasp(
+        translation_w=t_w.astype(np.float64),
+        quat_wxyz_w=quat_wxyz,
+        score=float(grasp.score),
+        width=float(grasp.width),
+        raw_translation_cam=t_cam,
+    )

scripts/graspnet_task_e/debug_solution_pca_execution.py

@@ -0,0 +1,178 @@
+"""Measure execution error for demo.solution_pca in Task E.
+
+Uses simulator internals only for debugging: object root, gripper_base, link7,
+and link8 positions.  The submission policy still only receives observations.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+
+from isaaclab.app import AppLauncher
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper")
+parser.add_argument("--seed", type=int, default=12)
+parser.add_argument("--object", type=int, default=3)
+parser.add_argument("--max_steps", type=int, default=2500)
+parser.add_argument("--solution_module", type=str, default="solution_pca")
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+args_cli.enable_cameras = True
+
+repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+demo_dir = os.path.join(repo_root, "demo")
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+if demo_dir not in sys.path:
+    sys.path.insert(0, demo_dir)
+
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+import gymnasium as gym  # noqa: E402
+import importlib  # noqa: E402
+import numpy as np  # noqa: E402
+import torch  # noqa: E402
+from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
+from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402
+
+import atec_rl_lab.tasks  # noqa: F401,E402
+
+
+def main() -> None:
+    env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1)
+    env_cfg.seed = args_cli.seed
+    env = gym.make(args_cli.task, cfg=env_cfg)
+    if isinstance(env.unwrapped, DirectMARLEnv):
+        env = multi_agent_to_single_agent(env)
+
+    module = importlib.import_module(args_cli.solution_module)
+    AlgSolution = module.AlgSolution
+    policy = AlgSolution()
+    try:
+        obs, _ = env.reset(seed=args_cli.seed)
+        policy.reset_episode()
+        robot = env.unwrapped.scene.articulations["robot"]
+        obj = env.unwrapped.scene.rigid_objects[f"object_{args_cli.object}"]
+        gb_id = int(robot.find_bodies("gripper_base")[0][0])
+        link7_id = int(robot.find_bodies("link7")[0][0])
+        link8_id = int(robot.find_bodies("link8")[0][0])
+        obj_initial = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
+
+        best = {
+            "finger_dist": (999.0, None, 0, None),
+            "gb_dist": (999.0, None, 0, None),
+            "max_z_gain": (-999.0, None, 0, None),
+            "pin_finger_err": (999.0, None, 0, None),
+            "pin_gb_err": (999.0, None, 0, None),
+        }
+        stage_best = {}
+        pin_err_sum = {"finger": 0.0, "gb": 0.0}
+        pin_err_n = 0
+        total_reward = 0.0
+        start = time.time()
+        for step in range(args_cli.max_steps):
+            with torch.inference_mode():
+                resp = policy.predicts(obs, total_reward)
+                action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1)
+                obs, reward, terminated, truncated, info = env.step(action)
+            sim_dt = info["Step_dt"]
+            total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt
+
+            obj_pos = obj.data.root_pos_w[0, :3].detach().cpu().numpy().astype(np.float64)
+            gb = robot.data.body_pos_w[0, gb_id, :3].detach().cpu().numpy().astype(np.float64)
+            f7 = robot.data.body_pos_w[0, link7_id, :3].detach().cpu().numpy().astype(np.float64)
+            f8 = robot.data.body_pos_w[0, link8_id, :3].detach().cpu().numpy().astype(np.float64)
+            finger = 0.5 * (f7 + f8)
+            qpos = policy._obs_qpos(obs)
+            pin_finger = policy.ik.finger_center_world(qpos)
+            pin_gb_b, _ = policy.ik.fk_base(qpos[:6])
+            pin_gb = module.BASE_POS_W + module.R_W_B @ pin_gb_b
+            gap = float(np.linalg.norm(f7 - f8))
+            fd = float(np.linalg.norm(finger - obj_pos))
+            gd = float(np.linalg.norm(gb - obj_pos))
+            pfe = float(np.linalg.norm(pin_finger - finger))
+            pge = float(np.linalg.norm(pin_gb - gb))
+            pin_err_sum["finger"] += pfe
+            pin_err_sum["gb"] += pge
+            pin_err_n += 1
+            zg = float(obj_pos[2] - obj_initial[2])
+            plan_idx = getattr(policy, "plan_idx", -1)
+            target_step = getattr(policy, "step_in_target", -1)
+            label = "none"
+            plan = getattr(policy, "plan", None)
+            if isinstance(plan, list) and 0 <= plan_idx < len(plan):
+                label = getattr(plan[plan_idx], "label", str(plan_idx))
+            stage = stage_best.setdefault(
+                label,
+                {
+                    "min_finger": (999.0, None, 0, None),
+                    "max_z_gain": (-999.0, None, 0, None),
+                    "min_gap": (999.0, 0),
+                    "last": None,
+                },
+            )
+            if fd < stage["min_finger"][0]:
+                stage["min_finger"] = (fd, finger - obj_pos, step, (plan_idx, target_step, gap, qpos[6], qpos[7]))
+            if zg > stage["max_z_gain"][0]:
+                stage["max_z_gain"] = (zg, obj_pos.copy(), step, (plan_idx, target_step, gap, qpos[6], qpos[7]))
+            if gap < stage["min_gap"][0]:
+                stage["min_gap"] = (gap, step)
+            stage["last"] = (finger - obj_pos, obj_pos.copy(), gap, qpos[6], qpos[7], step)
+            if fd < best["finger_dist"][0]:
+                best["finger_dist"] = (fd, finger - obj_pos, step, (plan_idx, target_step, gap))
+            if gd < best["gb_dist"][0]:
+                best["gb_dist"] = (gd, gb - obj_pos, step, (plan_idx, target_step, gap))
+            if zg > best["max_z_gain"][0]:
+                best["max_z_gain"] = (zg, obj_pos.copy(), step, (plan_idx, target_step, gap))
+            if pfe < best["pin_finger_err"][0]:
+                best["pin_finger_err"] = (pfe, pin_finger - finger, step, (plan_idx, target_step, gap))
+            if pge < best["pin_gb_err"][0]:
+                best["pin_gb_err"] = (pge, pin_gb - gb, step, (plan_idx, target_step, gap))
+            if bool(terminated.item() or truncated.item()):
+                break
+
+        final = obj.data.root_pos_w[0, :3].detach().cpu().numpy().astype(np.float64)
+        print(f"[EXEC_DEBUG] seed={args_cli.seed} obj={args_cli.object} score={total_reward:.2f} wall={time.time()-start:.1f}s")
+        print(f"[EXEC_DEBUG] initial=({obj_initial[0]:.4f},{obj_initial[1]:.4f},{obj_initial[2]:.4f}) final=({final[0]:.4f},{final[1]:.4f},{final[2]:.4f})")
+        if pin_err_n:
+            print(f"[EXEC_DEBUG] pin_mean_err finger={pin_err_sum['finger']/pin_err_n:.4f} gb={pin_err_sum['gb']/pin_err_n:.4f}")
+        for key, (value, vec, step, meta) in best.items():
+            if vec is None:
+                print(f"[EXEC_DEBUG] {key}=none")
+            elif key == "max_z_gain":
+                print(f"[EXEC_DEBUG] {key}={value:.4f} obj=({vec[0]:.4f},{vec[1]:.4f},{vec[2]:.4f}) step={step} meta={meta}")
+            else:
+                print(f"[EXEC_DEBUG] {key}={value:.4f} vec=({vec[0]:+.4f},{vec[1]:+.4f},{vec[2]:+.4f}) step={step} meta={meta}")
+        for label, stats in stage_best.items():
+            if not any(k in label for k in ("reach", "insert", "close", "lift", "mid", "release")):
+                continue
+            fd, fvec, fstep, fmeta = stats["min_finger"]
+            zg, zobj, zstep, zmeta = stats["max_z_gain"]
+            last = stats["last"]
+            if fvec is None or zobj is None or last is None:
+                continue
+            lvec, lobj, lgap, lq7, lq8, lstep = last
+            print(
+                f"[STAGE_DEBUG] label={label} min_fd={fd:.4f} "
+                f"min_vec=({fvec[0]:+.4f},{fvec[1]:+.4f},{fvec[2]:+.4f}) "
+                f"min_meta={fmeta} max_z_gain={zg:.4f} "
+                f"z_obj=({zobj[0]:.4f},{zobj[1]:.4f},{zobj[2]:.4f}) z_meta={zmeta} "
+                f"last_vec=({lvec[0]:+.4f},{lvec[1]:+.4f},{lvec[2]:+.4f}) "
+                f"last_obj=({lobj[0]:.4f},{lobj[1]:.4f},{lobj[2]:.4f}) "
+                f"last_gap={lgap:.4f} last_q=({lq7:.4f},{lq8:.4f}) last_step={lstep}"
+            )
+    finally:
+        env.close()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    finally:
+        simulation_app.close()

scripts/graspnet_task_e/debug_solution_pca_perception.py

@@ -0,0 +1,84 @@
+"""Compare submit-style RGB-D PCA estimates against Task-E simulator truth.
+
+This script uses simulator object roots only for debugging/calibration.  It is
+not part of the submission policy.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from isaaclab.app import AppLauncher
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper")
+parser.add_argument("--seed", type=int, default=12)
+parser.add_argument("--settle_steps", type=int, default=5)
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+args_cli.enable_cameras = True
+
+repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+demo_dir = os.path.join(repo_root, "demo")
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+if demo_dir not in sys.path:
+    sys.path.insert(0, demo_dir)
+
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+import gymnasium as gym  # noqa: E402
+import numpy as np  # noqa: E402
+import torch  # noqa: E402
+from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
+from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402
+
+import atec_rl_lab.tasks  # noqa: F401,E402
+import solution_pca  # noqa: E402
+
+
+def main() -> None:
+    env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1)
+    env_cfg.seed = args_cli.seed
+    env = gym.make(args_cli.task, cfg=env_cfg)
+    if isinstance(env.unwrapped, DirectMARLEnv):
+        env = multi_agent_to_single_agent(env)
+
+    policy = solution_pca.AlgSolution()
+    try:
+        obs, _ = env.reset(seed=args_cli.seed)
+        zero = torch.zeros((1, 8), dtype=torch.float32, device=args_cli.device)
+        for _ in range(max(0, args_cli.settle_steps)):
+            obs, *_ = env.step(zero)
+
+        rgb, depth = policy._video_rgb_depth(obs)
+        print(f"[PERCEPTION_DEBUG] seed={args_cli.seed} settle_steps={args_cli.settle_steps}")
+        for obj_idx in (1, 2, 3):
+            est, rot = policy._estimate_grasp(rgb, depth, obj_idx)
+            pick_xy = est[:2] + solution_pca.OBJ_GRASP_CENTER_OFFSETS[obj_idx]
+            obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"]
+            truth = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
+            delta = est - truth
+            pick_delta = np.r_[pick_xy - truth[:2], est[2] - truth[2]]
+            jaw_yaw = float(np.arctan2(rot[1, 1], rot[0, 1]))
+            print(
+                "[PERCEPTION_DEBUG] "
+                f"obj={obj_idx} truth=({truth[0]:.4f},{truth[1]:.4f},{truth[2]:.4f}) "
+                f"est=({est[0]:.4f},{est[1]:.4f},{est[2]:.4f}) "
+                f"delta=({delta[0]:+.4f},{delta[1]:+.4f},{delta[2]:+.4f}) "
+                f"pick_delta=({pick_delta[0]:+.4f},{pick_delta[1]:+.4f},{pick_delta[2]:+.4f}) "
+                f"jaw_yaw={jaw_yaw:+.3f}"
+            )
+    finally:
+        env.close()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    finally:
+        simulation_app.close()

scripts/graspnet_task_e/pca_aabb_adapter.py

@@ -0,0 +1,114 @@
+"""GraspGen-style PCA/AABB grasp prior for ATEC Task E.
+
+This mirrors the core idea used by the PiPER GraspGen demo: reconstruct the
+segmented RGB-D points, run PCA, build an oriented AABB, and use its center as a
+geometric grasp prior.  The Task-E runner may still override orientation with
+the calibrated Piper quaternion.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+from scripts.graspnet_task_e.tuntun_adapter import TaskEGrasp, camera_arrays
+
+
+def _masked_world_points(camera, mask: np.ndarray) -> np.ndarray:
+    _rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
+    valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
+    if not np.any(valid):
+        raise RuntimeError("No valid masked depth points for PCA/AABB grasp.")
+    ys, xs = np.where(valid)
+    z = depth[ys, xs].astype(np.float64)
+    x = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z
+    y = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z
+    pts_cam = np.stack([x, y, z], axis=1)
+    rot_w_cam = Rotation.from_quat(
+        [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
+    ).as_matrix()
+    return (rot_w_cam @ pts_cam.T).T + pos_w
+
+
+def _pca_aabb(points_w: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray, int]:
+    pts = np.asarray(points_w, dtype=np.float64)
+    if pts.shape[0] < 4:
+        raise RuntimeError("Too few points for PCA/AABB grasp.")
+
+    centroid = np.mean(pts, axis=0)
+    centered = pts - centroid
+    covariance = (centered.T @ centered) / max(centered.shape[0] - 1, 1)
+    eigen_values, eigen_vectors = np.linalg.eigh(covariance)
+
+    ev = eigen_vectors.copy()
+    ev[:, 2] = np.cross(ev[:, 0], ev[:, 1])
+    ev[:, 1] = np.cross(ev[:, 2], ev[:, 0])
+    ev[:, 0] = np.cross(ev[:, 1], ev[:, 2])
+    for i in range(3):
+        norm = np.linalg.norm(ev[:, i])
+        if norm > 1e-10:
+            ev[:, i] /= norm
+
+    order = np.argsort(eigen_values)[::-1]
+    R = ev[:, order].copy()
+    if np.linalg.det(R) < 0:
+        R[:, 2] = -R[:, 2]
+
+    local = (R.T @ (pts - centroid).T).T
+    min_pt = np.min(local, axis=0)
+    max_pt = np.max(local, axis=0)
+    extents = max_pt - min_pt
+    center_local = (min_pt + max_pt) * 0.5
+    center_w = R @ center_local + centroid
+    grasp_axis = int(np.argmin(extents))
+    return center_w.astype(np.float64), R.astype(np.float64), extents.astype(np.float64), grasp_axis
+
+
+def infer_pca_aabb_from_camera(camera, mask: np.ndarray, object_index: int | None = None) -> TaskEGrasp:
+    """Return a GraspGen-style geometric grasp prior from segmented RGB-D."""
+    pts_w = _masked_world_points(camera, mask)
+
+    # Use the visible object body.  Box/bottle masks are most stable with the
+    # upper visible surface median, while the banana's curved mask is less
+    # stable there and works better from the oriented AABB center.
+    center_w, R_pca, extents, grasp_axis = _pca_aabb(pts_w)
+    z_gate = float(np.percentile(pts_w[:, 2], 70))
+    upper = pts_w[pts_w[:, 2] >= z_gate]
+    exec_center = center_w.copy()
+    if object_index != 3 and len(upper) > 16:
+        exec_center[:2] = np.median(upper[:, :2], axis=0)
+        exec_center[2] = float(np.percentile(pts_w[:, 2], 85))
+
+    if grasp_axis == 0:
+        jaw_hint_w = R_pca[:, 1]
+    elif grasp_axis == 1:
+        jaw_hint_w = R_pca[:, 0]
+    else:
+        jaw_hint_w = R_pca[:, 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)
+    R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1)
+    quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat()
+    quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64)
+
+    width = float(extents[grasp_axis])
+    score = 1.0 / (1.0 + float(np.linalg.norm(extents)))
+    print(
+        f"[PCA_AABB] points={len(pts_w)} extents=({extents[0]:.3f},{extents[1]:.3f},{extents[2]:.3f}) "
+        f"axis={grasp_axis} width={width:.3f}"
+    )
+    return TaskEGrasp(
+        translation_w=exec_center.astype(np.float64),
+        quat_wxyz_w=quat_wxyz,
+        score=score,
+        width=width,
+        raw_translation_cam=np.zeros(3, dtype=np.float64),
+    )

scripts/graspnet_task_e/run_anygrasp_pick.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+PYTHON_BIN="${PYTHON_BIN:-/home/ubuntu/envs/genmanip-isaac5-py311/bin/python}"
+
+OBJ="${1:-3}"
+if (( $# > 0 )); then
+  shift
+fi
+SEED="${1:-11}"
+if (( $# > 0 )); then
+  shift
+fi
+MASK_PROVIDER="${MASK_PROVIDER:-oracle}"
+VIDEO_PATH="${VIDEO_PATH:-logs/videos/task_e_anygrasp/anygrasp_obj${OBJ}_seed${SEED}.mp4}"
+DEBUG_NPZ="${DEBUG_NPZ:-logs/anygrasp_task_e/obj${OBJ}_seed${SEED}_debug.npz}"
+
+cd "${REPO_ROOT}"
+
+exec env OMNI_KIT_ACCEPT_EULA=YES PYTHONUNBUFFERED=1 "${PYTHON_BIN}" \
+  scripts/graspnet_task_e/run_graspnet_pick.py \
+  --grasp_provider anygrasp \
+  --object "${OBJ}" \
+  --seed "${SEED}" \
+  --mask_provider "${MASK_PROVIDER}" \
+  --use_task_quat \
+  --tcp_z_offset 0.040 \
+  --close_z_offset -0.020 \
+  --close_steps 160 \
+  --move_steps 200 \
+  --transport_steps 1400 \
+  --place_steps 260 \
+  --video_path "${VIDEO_PATH}" \
+  --save_debug_npz "${DEBUG_NPZ}" \
+  --headless \
+  "$@"

scripts/graspnet_task_e/run_graspnet_pick.py

@@ -0,0 +1,844 @@
+"""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()

scripts/graspnet_task_e/sam3_segment_image.py

@@ -0,0 +1,109 @@
+"""Run local SAM3 on a saved RGB image and write a binary mask.
+
+This script is intentionally small and dependency-isolated: Task-E/Isaac can
+call it from the SAM3 virtualenv without installing SAM3 into the Isaac env.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+
+PROMPT_INPAINT = Path("/home/ubuntu/Documents/01Proj/sam3d_gs/submodule/Prompt-Inpaint")
+if not PROMPT_INPAINT.exists():
+    raise SystemExit(f"Prompt-Inpaint not found: {PROMPT_INPAINT}")
+sys.path.insert(0, str(PROMPT_INPAINT))
+
+from src.sam3_predictor import SAM3Predictor  # noqa: E402
+
+
+def _bbox_area(mask: np.ndarray) -> int:
+    ys, xs = np.nonzero(mask)
+    if len(xs) == 0:
+        return 0
+    return int((xs.max() - xs.min() + 1) * (ys.max() - ys.min() + 1))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Segment one image with local SAM3.")
+    parser.add_argument("--image", required=True, help="Input RGB image path.")
+    parser.add_argument("--out_mask", required=True, help="Output .npy binary mask path.")
+    parser.add_argument("--out_meta", default=None, help="Optional JSON metadata output.")
+    parser.add_argument("--out_candidates", default=None, help="Optional .npz with all candidate masks.")
+    parser.add_argument("--prompt", action="append", required=True, help="Text prompt. Can repeat.")
+    parser.add_argument("--threshold", type=float, default=0.35)
+    parser.add_argument("--mask_threshold", type=float, default=0.5)
+    parser.add_argument(
+        "--model",
+        default="/home/ubuntu/Documents/01Proj/sam3d_gs/submodule/Prompt-Inpaint/checkpoints/sam3.pt",
+    )
+    args = parser.parse_args()
+
+    image = np.asarray(Image.open(args.image).convert("RGB"))
+    predictor = SAM3Predictor(
+        model_id=args.model,
+        device="cuda",
+        threshold=args.threshold,
+        mask_threshold=args.mask_threshold,
+    )
+    predictor.set_image(image)
+
+    detections = []
+    for prompt in args.prompt:
+        detections.extend(predictor.detect(prompt))
+
+    candidates = []
+    image_area = image.shape[0] * image.shape[1]
+    for det in detections:
+        if det.mask is None:
+            continue
+        mask = det.mask.astype(bool)
+        area = int(mask.sum())
+        if area < 40 or area > int(image_area * 0.35):
+            continue
+        candidates.append(
+            {
+                "prompt": det.label,
+                "score": float(det.score),
+                "bbox": [int(v) for v in det.bbox],
+                "area": area,
+                "bbox_area": _bbox_area(mask),
+                "mask": mask,
+            }
+        )
+
+    if not candidates:
+        raise SystemExit("SAM3 produced no usable mask")
+
+    # Prefer confident, compact object masks. This avoids selecting the table or
+    # a merged scene-sized region when prompts are broad.
+    best = max(candidates, key=lambda c: (c["score"], -c["bbox_area"]))
+    out_mask = Path(args.out_mask)
+    out_mask.parent.mkdir(parents=True, exist_ok=True)
+    np.save(out_mask, best["mask"].astype(np.bool_))
+
+    if args.out_meta:
+        meta = {k: v for k, v in best.items() if k != "mask"}
+        meta["num_candidates"] = len(candidates)
+        Path(args.out_meta).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.out_meta).write_text(json.dumps(meta, indent=2), encoding="utf-8")
+
+    if args.out_candidates:
+        cand_path = Path(args.out_candidates)
+        cand_path.parent.mkdir(parents=True, exist_ok=True)
+        masks = np.stack([c["mask"].astype(np.bool_) for c in candidates], axis=0)
+        metas = [
+            {k: v for k, v in c.items() if k != "mask"}
+            for c in candidates
+        ]
+        np.savez_compressed(cand_path, masks=masks, metas=json.dumps(metas))
+
+
+if __name__ == "__main__":
+    main()

scripts/graspnet_task_e/tuntun_adapter.py

@@ -0,0 +1,388 @@
+"""Small Task-E bridge around the TunTunClaw GraspNet API.
+
+The GraspNet model predicts grasps in the camera/ROS frame.  Task E executes a
+top-down Piper grasp in world frame, so this adapter intentionally uses
+GraspNet for the contact centre and jaw yaw, then forces a stable top-down
+orientation for the Piper gripper.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+import os
+import sys
+
+import numpy as np
+import torch
+from scipy.spatial.transform import Rotation
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+TUNTUN_ROOT = REPO_ROOT / "third_party" / "tuntunclaw"
+GRASPNET_ROOT = TUNTUN_ROOT / "graspnet-baseline"
+CHECKPOINT_PATH = TUNTUN_ROOT / "temp" / "logs" / "log_rs" / "checkpoint-rs.tar"
+
+
+def _ensure_tuntun_paths() -> None:
+    paths = [
+        GRASPNET_ROOT / "models",
+        GRASPNET_ROOT / "dataset",
+        GRASPNET_ROOT / "utils",
+        GRASPNET_ROOT / "graspnetAPI",
+        TUNTUN_ROOT / "manipulator_grasp",
+    ]
+    for path in paths:
+        p = str(path)
+        if p not in sys.path:
+            sys.path.insert(0, p)
+
+
+@dataclass(frozen=True)
+class TaskEGrasp:
+    translation_w: np.ndarray
+    quat_wxyz_w: np.ndarray
+    score: float
+    width: float
+    raw_translation_cam: np.ndarray
+
+
+def camera_arrays(camera) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Return RGB, depth, K, camera position and ROS-frame quaternion."""
+    rgb = camera.data.output["rgb"][0].detach().cpu().numpy()[..., :3]
+    depth = camera.data.output["depth"][0].detach().cpu().numpy()
+    if depth.ndim == 3:
+        depth = depth[..., 0]
+    K = camera.data.intrinsic_matrices[0].detach().cpu().numpy()
+    pos_w = camera.data.pos_w[0].detach().cpu().numpy()
+    quat_wxyz_ros = camera.data.quat_w_ros[0].detach().cpu().numpy()
+    return rgb, depth.astype(np.float32), K.astype(np.float32), pos_w.astype(np.float64), quat_wxyz_ros.astype(np.float64)
+
+
+def project_world_points_to_image(points_w: np.ndarray, K: np.ndarray, pos_w: np.ndarray, quat_wxyz_ros: np.ndarray) -> np.ndarray:
+    """Project world points into a ROS camera image."""
+    rot_w_cam = Rotation.from_quat(
+        [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
+    ).as_matrix()
+    pts_cam = (rot_w_cam.T @ (points_w - pos_w).T).T
+    z = np.clip(pts_cam[:, 2], 1e-6, None)
+    u = K[0, 0] * pts_cam[:, 0] / z + K[0, 2]
+    v = K[1, 1] * pts_cam[:, 1] / z + K[1, 2]
+    return np.stack([u, v, pts_cam[:, 2]], axis=1)
+
+
+def oracle_object_mask(env, camera, obj_idx: int, pad_px: int = 24) -> np.ndarray:
+    """Create a temporary ROI mask by projecting the known simulated object bbox.
+
+    This is for fast grasp primitive debugging.  Once the primitive is stable,
+    replace this mask provider with RGB-D segmentation/VLM masks for submission.
+    """
+    from atec_rl_lab.tasks.task_e.env_cfg import OBJ_HALF_EXTENTS, TABLE_TOP_Z
+
+    rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
+    h, w = depth.shape[:2]
+    obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"]
+    center = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64)
+    hx, hy = OBJ_HALF_EXTENTS[f"object_{obj_idx}"]
+    z_lo = TABLE_TOP_Z + 0.005
+    z_hi = max(center[2] + 0.16, TABLE_TOP_Z + 0.08)
+    corners = np.array(
+        [
+            [center[0] + sx * hx, center[1] + sy * hy, z]
+            for sx in (-1.0, 1.0)
+            for sy in (-1.0, 1.0)
+            for z in (z_lo, z_hi)
+        ],
+        dtype=np.float64,
+    )
+    uvz = project_world_points_to_image(corners, K, pos_w, quat_wxyz_ros)
+    valid = uvz[:, 2] > 0.02
+    mask = np.zeros((h, w), dtype=np.uint8)
+    if not np.any(valid):
+        return mask
+    u = uvz[valid, 0]
+    v = uvz[valid, 1]
+    x1 = int(np.clip(np.floor(u.min()) - pad_px, 0, w - 1))
+    y1 = int(np.clip(np.floor(v.min()) - pad_px, 0, h - 1))
+    x2 = int(np.clip(np.ceil(u.max()) + pad_px, 0, w - 1))
+    y2 = int(np.clip(np.ceil(v.max()) + pad_px, 0, h - 1))
+    if x2 > x1 and y2 > y1:
+        mask[y1 : y2 + 1, x1 : x2 + 1] = 255
+        # Remove obvious background/table pixels while keeping the object surface.
+        obj_depth = depth[mask > 0]
+        obj_depth = obj_depth[np.isfinite(obj_depth) & (obj_depth > 0.0)]
+        if obj_depth.size:
+            d_min = float(np.percentile(obj_depth, 3))
+            d_max = float(np.percentile(obj_depth, 70))
+            mask[(depth < d_min - 0.03) | (depth > d_max + 0.06)] = 0
+        # Debug oracle refinement: keep only RGB-D points whose reconstructed
+        # world coordinates lie inside the selected object's AABB.  The first
+        # rectangular ROI can include neighboring objects for banana/long
+        # shapes, which shifts GraspNet's execution centre by tens of cm.
+        ys, xs = np.where((mask > 0) & np.isfinite(depth) & (depth > 0.0))
+        if len(xs) > 0:
+            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)
+            rot_w_cam = Rotation.from_quat(
+                [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
+            ).as_matrix()
+            pts_w = (rot_w_cam @ pts_cam.T).T + pos_w
+            keep = (
+                (pts_w[:, 0] >= center[0] - hx - 0.025)
+                & (pts_w[:, 0] <= center[0] + hx + 0.025)
+                & (pts_w[:, 1] >= center[1] - hy - 0.025)
+                & (pts_w[:, 1] <= center[1] + hy + 0.025)
+                & (pts_w[:, 2] >= TABLE_TOP_Z - 0.010)
+                & (pts_w[:, 2] <= center[2] + 0.180)
+            )
+            refined = np.zeros_like(mask)
+            refined[ys[keep], xs[keep]] = 255
+            if np.count_nonzero(refined) > 128:
+                mask = refined
+    return mask
+
+
+_BAND_Z_LIMITS = {
+    1: (0.035, 0.130),  # sugar box: reject table pixels and high gripper links
+    2: (0.020, 0.190),  # mustard bottle
+    3: (0.012, 0.095),  # banana
+}
+
+
+def rgbd_band_object_mask(camera, obj_idx: int, margin_y: float = 0.045) -> np.ndarray:
+    """Segment a Task-E object from RGB-D using legal scene priors.
+
+    The official randomizer keeps each object type in a distinct world-Y band.
+    Reconstructing the video camera depth into world coordinates lets us isolate
+    the object without reading simulator object state.  This is the intended
+    replacement for ``oracle_object_mask`` in submission-style tests.
+    """
+    from scripts.act.task_e.config import OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Y_BANDS
+    from atec_rl_lab.tasks.task_e.env_cfg import TABLE_TOP_Z
+
+    rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera)
+    valid = np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
+    ys, xs = np.where(valid)
+    mask = np.zeros(depth.shape[:2], dtype=np.uint8)
+    if len(xs) == 0:
+        return mask
+
+    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)
+    rot_w_cam = Rotation.from_quat(
+        [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
+    ).as_matrix()
+    pts_w = (rot_w_cam @ pts_cam.T).T + pos_w
+
+    y0, y1 = OBJ_SPAWN_Y_BANDS[obj_idx]
+    z_min_rel, z_max_rel = _BAND_Z_LIMITS.get(obj_idx, (0.006, 0.24))
+    rgb_pts = rgb[ys, xs].astype(np.float32)
+    maxc = rgb_pts.max(axis=1)
+    minc = rgb_pts.min(axis=1)
+    sat = maxc - minc
+    non_gray = (sat > 18.0) | (maxc > 170.0)
+    world_keep = (
+        (pts_w[:, 0] >= OBJ_SPAWN_X_MIN - 0.08)
+        & (pts_w[:, 0] <= OBJ_SPAWN_X_MAX + 0.08)
+        & (pts_w[:, 1] >= y0 - margin_y)
+        & (pts_w[:, 1] <= y1 + margin_y)
+        & (pts_w[:, 2] >= TABLE_TOP_Z + z_min_rel)
+        & (pts_w[:, 2] <= TABLE_TOP_Z + z_max_rel)
+        & non_gray
+    )
+    mask[ys[world_keep], xs[world_keep]] = 255
+
+    # Fill the component's rectangular holes lightly; GraspNet expects enough
+    # depth samples and the box has large white low-saturation areas.
+    if np.count_nonzero(mask) > 0:
+        yy, xx = np.where(mask > 0)
+        x1, x2 = int(xx.min()), int(xx.max())
+        y1p, y2p = int(yy.min()), int(yy.max())
+        roi = np.zeros_like(mask)
+        roi[y1p : y2p + 1, x1 : x2 + 1] = 255
+        fill_keep = roi[ys, xs] > 0
+        fill_keep &= (
+            (pts_w[:, 1] >= y0 - margin_y)
+            & (pts_w[:, 1] <= y1 + margin_y)
+            & (pts_w[:, 2] >= TABLE_TOP_Z + z_min_rel)
+            & (pts_w[:, 2] <= TABLE_TOP_Z + z_max_rel)
+        )
+        mask[ys[fill_keep], xs[fill_keep]] = 255
+    return mask
+
+
+@lru_cache(maxsize=1)
+def _load_graspnet_model():
+    _ensure_tuntun_paths()
+    if not CHECKPOINT_PATH.exists():
+        raise FileNotFoundError(
+            f"GraspNet checkpoint missing: {CHECKPOINT_PATH}. "
+            "Download official checkpoint-rs.tar there first."
+        )
+    from graspnet import GraspNet
+
+    net = GraspNet(
+        input_feature_dim=0,
+        num_view=300,
+        num_angle=12,
+        num_depth=4,
+        cylinder_radius=0.05,
+        hmin=-0.02,
+        hmax_list=[0.01, 0.02, 0.03, 0.04],
+        is_training=False,
+    )
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    net.to(device)
+    checkpoint = torch.load(CHECKPOINT_PATH, map_location=device)
+    net.load_state_dict(checkpoint["model_state_dict"])
+    net.eval()
+    return net
+
+
+def _run_graspnet(rgb: np.ndarray, depth: np.ndarray, mask: np.ndarray, K: np.ndarray):
+    _ensure_tuntun_paths()
+    import open3d as o3d
+    from collision_detector import ModelFreeCollisionDetector
+    from data_utils import CameraInfo, create_point_cloud_from_depth_image
+    from graspnet import pred_decode
+    from graspnetAPI import GraspGroup
+
+    color = rgb.astype(np.float32) / 255.0
+    height, width = depth.shape[:2]
+    camera_info = CameraInfo(width, height, float(K[0, 0]), float(K[1, 1]), float(K[0, 2]), float(K[1, 2]), 1.0)
+    cloud = create_point_cloud_from_depth_image(depth, camera_info, organized=True)
+
+    valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
+    cloud_masked = cloud[valid]
+    color_masked = color[valid]
+    if len(cloud_masked) == 0:
+        raise RuntimeError("No valid masked depth points for GraspNet.")
+
+    num_point = 5000
+    if len(cloud_masked) >= num_point:
+        idxs = np.random.choice(len(cloud_masked), num_point, replace=False)
+    else:
+        idxs = np.concatenate(
+            [np.arange(len(cloud_masked)), np.random.choice(len(cloud_masked), num_point - len(cloud_masked), replace=True)]
+        )
+    cloud_sampled = torch.from_numpy(cloud_masked[idxs][None].astype(np.float32)).to(
+        torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    )
+    end_points = {"point_clouds": cloud_sampled, "cloud_colors": color_masked[idxs]}
+
+    net = _load_graspnet_model()
+    with torch.no_grad():
+        end_points = net(end_points)
+        grasp_preds = pred_decode(end_points)
+
+    gg = GraspGroup(grasp_preds[0].detach().cpu().numpy()).nms().sort_by_score()
+    if len(gg) > 128:
+        gg = gg[:128]
+
+    cloud_o3d = o3d.geometry.PointCloud()
+    cloud_o3d.points = o3d.utility.Vector3dVector(cloud_masked.astype(np.float32))
+    cloud_o3d.colors = o3d.utility.Vector3dVector(color_masked.astype(np.float32))
+    try:
+        detector = ModelFreeCollisionDetector(np.asarray(cloud_o3d.points, dtype=np.float32), voxel_size=0.01)
+        collision_mask = detector.detect(gg, approach_dist=0.05, collision_thresh=0.01)
+        gg = gg[~collision_mask]
+    except Exception as exc:
+        print(f"[graspnet] collision check skipped: {exc}")
+
+    gg = gg.sort_by_score()
+    grasps = list(gg)
+    if not grasps:
+        raise RuntimeError("No GraspNet candidates after filtering.")
+    center = np.mean(cloud_masked, axis=0)
+    # TunTunClaw's empirical selector: prefer grasps near the segmented object centre.
+    max_dist = max(np.linalg.norm(g.translation - center) for g in grasps) or 1.0
+    best = max(grasps, key=lambda g: float(g.score) * 0.1 + (1.0 - np.linalg.norm(g.translation - center) / max_dist) * 0.9)
+    out = GraspGroup()
+    out.add(best)
+    return out
+
+
+def _load_graspnet():
+    _ensure_tuntun_paths()
+    if not CHECKPOINT_PATH.exists():
+        raise FileNotFoundError(
+            f"GraspNet checkpoint missing: {CHECKPOINT_PATH}. "
+            "Download official checkpoint-rs.tar there first."
+        )
+    return _run_graspnet
+
+
+def infer_grasp_from_camera(camera, mask: np.ndarray) -> TaskEGrasp:
+    """Run TunTunClaw GraspNet and convert the selected grasp to Task-E world pose."""
+    rgb, depth, _K, pos_w, quat_wxyz_ros = camera_arrays(camera)
+    run_grasp_inference = _load_graspnet()
+    gg = run_grasp_inference(rgb, depth, mask, _K)
+    if len(gg) == 0:
+        raise RuntimeError("GraspNet returned no grasps.")
+    grasp = list(gg)[0]
+
+    rot_w_cam = Rotation.from_quat(
+        [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]]
+    ).as_matrix()
+    t_cam = np.asarray(grasp.translation, dtype=np.float64)
+    t_w = rot_w_cam @ t_cam + pos_w
+    valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0)
+    if np.any(valid):
+        ys, xs = np.where(valid)
+        z = depth[ys, xs].astype(np.float64)
+        x = (xs.astype(np.float64) - float(_K[0, 2])) / float(_K[0, 0]) * z
+        y = (ys.astype(np.float64) - float(_K[1, 2])) / float(_K[1, 1]) * z
+        pts_cam = np.stack([x, y, z], axis=1)
+        pts_w = (rot_w_cam @ pts_cam.T).T + pos_w
+        # For top-down Piper execution, the upper object-surface cloud is more
+        # stable than a single GraspNet seed point on box/bottle edges.  Keep
+        # GraspNet's yaw/width/score, recenter only the execution target.
+        z_gate = float(np.percentile(pts_w[:, 2], 70))
+        upper = pts_w[pts_w[:, 2] >= z_gate]
+        if len(upper) > 16:
+            # The highest-score GraspNet seed often sits on a visible edge for
+            # Task-E boxes/bottles.  Piper's parallel jaw is more reliable when
+            # executed through the segmented object's robust surface centre.
+            t_w[:2] = np.median(upper[:, :2], axis=0)
+        else:
+            t_w[:2] = np.median(pts_w[:, :2], axis=0)
+        t_w[2] = float(np.percentile(pts_w[:, 2], 85))
+
+    # GraspNet's first column is the approach axis.  We keep its jaw hint but
+    # force the Piper tool z-axis downward because the Task-E IK/top-down setup
+    # is much more stable than arbitrary 6-DoF wrist poses.
+    R_cam_grasp = np.asarray(grasp.rotation_matrix, dtype=np.float64)
+    jaw_hint_w = rot_w_cam @ R_cam_grasp[:, 1]
+    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 = 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 = align_x / max(np.linalg.norm(align_x), 1e-6)
+    jaw_y = np.cross(grip_z, align_x)
+    jaw_y = jaw_y / max(np.linalg.norm(jaw_y), 1e-6)
+    R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1)
+    quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat()
+    quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64)
+
+    return TaskEGrasp(
+        translation_w=t_w.astype(np.float64),
+        quat_wxyz_w=quat_wxyz,
+        score=float(grasp.score),
+        width=float(grasp.width),
+        raw_translation_cam=t_cam,
+    )
+
+
+def quat_wxyz_to_torch(quat_wxyz: np.ndarray, device: str) -> torch.Tensor:
+    return torch.tensor([quat_wxyz], dtype=torch.float32, device=device)
+
+
+def pos_to_torch(pos: np.ndarray, device: str) -> torch.Tensor:
+    return torch.tensor([pos], dtype=torch.float32, device=device)

scripts/pi05/compare_pi05_vs_act_baseline.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Compare a pi0.5 Task-E eval directory against the current ACT/XSA evidence."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import re
+import statistics
+
+
+RESULT_RE = re.compile(r"\[RESULT\].*?score=([0-9.]+).*?steps=([0-9]+).*?done=(True|False)")
+BASKET_RE = re.compile(r"\[BASKET\].*?(object_[123]): .*?inside=(True|False)")
+
+DEFAULT_BASELINE_LOGS = [
+    Path("logs/eval_task_e_xsa_final_seed11_recheck.log"),
+    Path("logs/eval_task_e_xsa_final_seed12_recheck.log"),
+    Path("logs/eval_task_e_xsa_final_seed13_recheck.log"),
+    Path("logs/eval_task_e_deployed_xsa_final_seed11_verify.log"),
+]
+CURRENT_POLICY_SHA = "c3eacae3f1b0ec8ccde9fdc05d680fff119cc2ca70e1f79e4ddd5610c4bbfa93"
+
+
+def parse_log(path: Path) -> tuple[float | None, dict[str, bool]]:
+    if not path.exists():
+        return None, {}
+    text = path.read_text(errors="replace")
+    result = RESULT_RE.search(text)
+    baskets = {obj: inside == "True" for obj, inside in BASKET_RE.findall(text)}
+    return (float(result.group(1)) if result else None), baskets
+
+
+def collect_pi05(eval_dir: Path) -> list[tuple[Path, float, dict[str, bool]]]:
+    rows = []
+    for log in sorted(eval_dir.glob("seed*.log")):
+        score, baskets = parse_log(log)
+        if score is not None:
+            rows.append((log, score, baskets))
+    return rows
+
+
+def print_rows(title: str, rows: list[tuple[Path, float, dict[str, bool]]]) -> None:
+    print(f"[{title}]")
+    if not rows:
+        print("  no complete result logs")
+        return
+    for path, score, baskets in rows:
+        basket_text = ", ".join(f"{obj}={inside}" for obj, inside in sorted(baskets.items()))
+        print(f"  {path}: score={score:.2f}; {basket_text or 'basket=unknown'}")
+    scores = [score for _, score, _ in rows]
+    print(
+        f"  summary: n={len(scores)} mean={statistics.fmean(scores):.2f} "
+        f"min={min(scores):.2f} max={max(scores):.2f}"
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("eval_dir", type=Path)
+    parser.add_argument("--repo", type=Path, default=Path.cwd())
+    args = parser.parse_args()
+
+    repo = args.repo.resolve()
+    eval_dir = args.eval_dir if args.eval_dir.is_absolute() else repo / args.eval_dir
+    baseline_rows = []
+    for log in DEFAULT_BASELINE_LOGS:
+        path = log if log.is_absolute() else repo / log
+        score, baskets = parse_log(path)
+        if score is not None:
+            baseline_rows.append((path, score, baskets))
+
+    pi05_rows = collect_pi05(eval_dir)
+    print(f"[CURRENT_DEPLOYED_POLICY_SHA] {CURRENT_POLICY_SHA}")
+    print_rows("ACT_XSA_BASELINE_EVIDENCE", baseline_rows)
+    print_rows("PI05_CANDIDATE_EVIDENCE", pi05_rows)
+
+    if len(pi05_rows) < 3:
+        print("[DECISION] HOLD: pi0.5 does not yet have all seed11/12/13 results.")
+        return 0
+
+    pi05_scores = [score for _, score, _ in pi05_rows]
+    baseline_independent = [score for path, score, _ in baseline_rows if "xsa_final_seed" in path.name]
+    baseline_mean = statistics.fmean(baseline_independent) if baseline_independent else 0.0
+    pi05_mean = statistics.fmean(pi05_scores)
+
+    if min(pi05_scores) >= baseline_mean and pi05_mean > baseline_mean:
+        print("[DECISION] REVIEW_FOR_DEPLOY: pi0.5 is clearly better on this evidence set.")
+    else:
+        print("[DECISION] HOLD_ACT_XSA: pi0.5 is not clearly better than the current ACT/XSA baseline.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/pi05/convert_task_e_hdf5_to_lerobot.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Convert ATEC Task E ACT HDF5 demos to a LeRobot dataset for OpenPI/pi0.5.
+
+The existing Task E demos store a single 8-DoF Piper arm action:
+6 arm joints + 2 gripper joints.  The local OpenPI EBench tabletop policy
+expects a 16-D fixed-base action split as 12 arm joints + 4 gripper joints,
+so this converter pads the unused second-arm slots with zeros.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+import shutil
+
+import h5py
+import numpy as np
+from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
+from tqdm import tqdm
+
+
+DEFAULT_PROMPT = "identify all objects, pick them up, and place them into the target basket"
+
+
+def _sorted_traj_keys(h5_file: h5py.File) -> list[str]:
+    keys = [key for key in h5_file.keys() if key.startswith("traj_")]
+    return sorted(keys, key=lambda item: int(item.split("_", 1)[1]))
+
+
+def _pad_state(qpos8: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    qpos8 = np.asarray(qpos8, dtype=np.float32)
+    joints = np.zeros(12, dtype=np.float32)
+    gripper = np.zeros(4, dtype=np.float32)
+    joints[:6] = qpos8[:6]
+    gripper[:2] = qpos8[6:8]
+    return joints, gripper
+
+
+def _pad_action(action8: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    action8 = np.asarray(action8, dtype=np.float32)
+    joints = np.zeros(12, dtype=np.float32)
+    gripper = np.zeros(4, dtype=np.float32)
+    joints[:6] = action8[:6]
+    gripper[:2] = action8[6:8]
+    return joints, gripper
+
+
+def create_dataset(
+    *,
+    repo_id: str,
+    root: Path,
+    fps: int,
+    use_videos: bool,
+    overwrite: bool,
+    image_writer_processes: int,
+    image_writer_threads: int,
+    image_height: int,
+    image_width: int,
+) -> LeRobotDataset:
+    dataset_dir = root / repo_id
+    if dataset_dir.exists():
+        if not overwrite:
+            raise FileExistsError(f"{dataset_dir} already exists; pass --overwrite to replace it")
+        shutil.rmtree(dataset_dir)
+
+    features = {
+        "video.overlook_camera_view": {
+            "dtype": "image",
+            "shape": (image_height, image_width, 3),
+            "names": ["height", "width", "channel"],
+        },
+        "video.left_camera_view": {
+            "dtype": "image",
+            "shape": (image_height, image_width, 3),
+            "names": ["height", "width", "channel"],
+        },
+        "video.right_camera_view": {
+            "dtype": "image",
+            "shape": (image_height, image_width, 3),
+            "names": ["height", "width", "channel"],
+        },
+        "state.joints": {
+            "dtype": "float32",
+            "shape": (12,),
+            "names": ["joint"],
+        },
+        "state.gripper": {
+            "dtype": "float32",
+            "shape": (4,),
+            "names": ["gripper"],
+        },
+        "action.joints": {
+            "dtype": "float32",
+            "shape": (12,),
+            "names": ["joint"],
+        },
+        "action.gripper": {
+            "dtype": "float32",
+            "shape": (4,),
+            "names": ["gripper"],
+        },
+    }
+    return LeRobotDataset.create(
+        repo_id=repo_id,
+        root=dataset_dir,
+        robot_type="atec_piper_task_e",
+        fps=fps,
+        features=features,
+        use_videos=use_videos,
+        image_writer_processes=image_writer_processes,
+        image_writer_threads=image_writer_threads,
+    )
+
+
+def _resize_image(rgb: np.ndarray, height: int, width: int) -> np.ndarray:
+    if rgb.shape[0] == height and rgb.shape[1] == width:
+        return rgb
+    import cv2
+
+    return cv2.resize(rgb, (width, height), interpolation=cv2.INTER_AREA)
+
+
+def convert(args: argparse.Namespace) -> None:
+    input_path = Path(args.input).expanduser().resolve()
+    root = Path(args.root).expanduser().resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    os.environ.setdefault("HF_LEROBOT_HOME", str(root))
+
+    dataset = create_dataset(
+        repo_id=args.repo_id,
+        root=root,
+        fps=args.fps,
+        use_videos=args.use_videos,
+        overwrite=args.overwrite,
+        image_writer_processes=args.image_writer_processes,
+        image_writer_threads=args.image_writer_threads,
+        image_height=args.image_height,
+        image_width=args.image_width,
+    )
+
+    with h5py.File(input_path, "r") as h5_file:
+        traj_keys = _sorted_traj_keys(h5_file)
+        if args.max_episodes is not None:
+            traj_keys = traj_keys[: args.max_episodes]
+        if not traj_keys:
+            raise ValueError(f"No traj_* groups found in {input_path}")
+
+        for traj_key in tqdm(traj_keys, desc="episodes"):
+            group = h5_file[traj_key]
+            qpos = group["obs"]
+            actions = group["actions"]
+            images = group["images/rgb"]
+            length = min(len(qpos), len(actions), len(images))
+            if length <= 0:
+                continue
+
+            for step in range(0, length, args.stride):
+                state_joints, state_gripper = _pad_state(qpos[step])
+                action_joints, action_gripper = _pad_action(actions[step])
+                rgb = _resize_image(images[step], args.image_height, args.image_width)
+                dataset.add_frame(
+                    {
+                        "video.overlook_camera_view": rgb,
+                        "video.left_camera_view": rgb,
+                        "video.right_camera_view": rgb,
+                        "state.joints": state_joints,
+                        "state.gripper": state_gripper,
+                        "action.joints": action_joints,
+                        "action.gripper": action_gripper,
+                        "task": args.prompt,
+                    }
+                )
+            dataset.save_episode()
+
+    print(f"[OK] Wrote LeRobot dataset repo_id={args.repo_id} root={root}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--input",
+        default="datasets/atec_task_e_obj321_servo_100demos/trajectory_filtered.hdf5",
+        help="Filtered ATEC Task E HDF5 file.",
+    )
+    parser.add_argument(
+        "--root",
+        default="/home/ubuntu/projects/robotics_shared/datasets/lerobot",
+        help="LeRobot dataset root. Also exported as HF_LEROBOT_HOME by this script.",
+    )
+    parser.add_argument("--repo_id", default="atec/task_e_obj321_servo_100demos")
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT)
+    parser.add_argument("--fps", type=int, default=50)
+    parser.add_argument("--image_height", type=int, default=224)
+    parser.add_argument("--image_width", type=int, default=224)
+    parser.add_argument("--stride", type=int, default=1, help="Temporal subsampling stride.")
+    parser.add_argument("--max_episodes", type=int, default=None)
+    parser.add_argument("--use_videos", action=argparse.BooleanOptionalAction, default=False)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--image_writer_processes", type=int, default=0)
+    parser.add_argument("--image_writer_threads", type=int, default=0)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    convert(parse_args())

scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""Convert ATEC Task E HDF5 demos to a native 8D Piper LeRobot dataset.
+
+This variant keeps the ATEC action/state representation intact:
+6 arm joints + 2 gripper joints.  The OpenPI transform pads the 8D vector to
+the pi0.5 model dimension later, which avoids the old fixed-base 12+4 mapping.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+import shutil
+
+import h5py
+import numpy as np
+from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
+from tqdm import tqdm
+
+
+DEFAULT_PROMPT = "identify all objects, pick them up, and place them into the target basket"
+DEFAULT_JOINT_POS = np.asarray([0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035], dtype=np.float32)
+ACTION_SCALE = np.float32(0.5)
+
+
+def _sorted_traj_keys(h5_file: h5py.File) -> list[str]:
+    keys = [key for key in h5_file.keys() if key.startswith("traj_")]
+    return sorted(keys, key=lambda item: int(item.split("_", 1)[1]))
+
+
+def _resize_image(rgb: np.ndarray, height: int, width: int) -> np.ndarray:
+    if rgb.shape[0] == height and rgb.shape[1] == width:
+        return rgb
+    import cv2
+
+    return cv2.resize(rgb, (width, height), interpolation=cv2.INTER_AREA)
+
+
+def create_dataset(
+    *,
+    repo_id: str,
+    root: Path,
+    fps: int,
+    use_videos: bool,
+    overwrite: bool,
+    image_writer_processes: int,
+    image_writer_threads: int,
+    image_height: int,
+    image_width: int,
+) -> LeRobotDataset:
+    dataset_dir = root / repo_id
+    if dataset_dir.exists():
+        if not overwrite:
+            raise FileExistsError(f"{dataset_dir} already exists; pass --overwrite to replace it")
+        shutil.rmtree(dataset_dir)
+
+    features = {
+        "video.base_camera_view": {
+            "dtype": "image",
+            "shape": (image_height, image_width, 3),
+            "names": ["height", "width", "channel"],
+        },
+        "state": {
+            "dtype": "float32",
+            "shape": (8,),
+            "names": ["state"],
+        },
+        "action": {
+            "dtype": "float32",
+            "shape": (8,),
+            "names": ["action"],
+        },
+    }
+    return LeRobotDataset.create(
+        repo_id=repo_id,
+        root=dataset_dir,
+        robot_type="atec_piper_task_e_native8",
+        fps=fps,
+        features=features,
+        use_videos=use_videos,
+        image_writer_processes=image_writer_processes,
+        image_writer_threads=image_writer_threads,
+    )
+
+
+def convert(args: argparse.Namespace) -> None:
+    input_path = Path(args.input).expanduser().resolve()
+    root = Path(args.root).expanduser().resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    os.environ.setdefault("HF_LEROBOT_HOME", str(root))
+
+    dataset = create_dataset(
+        repo_id=args.repo_id,
+        root=root,
+        fps=args.fps,
+        use_videos=args.use_videos,
+        overwrite=args.overwrite,
+        image_writer_processes=args.image_writer_processes,
+        image_writer_threads=args.image_writer_threads,
+        image_height=args.image_height,
+        image_width=args.image_width,
+    )
+
+    frame_count = 0
+    with h5py.File(input_path, "r") as h5_file:
+        traj_keys = _sorted_traj_keys(h5_file)
+        if args.max_episodes is not None:
+            traj_keys = traj_keys[: args.max_episodes]
+        if not traj_keys:
+            raise ValueError(f"No traj_* groups found in {input_path}")
+
+        for traj_key in tqdm(traj_keys, desc="episodes"):
+            group = h5_file[traj_key]
+            qpos = group["obs"]
+            actions = group["actions"]
+            images = group["images/rgb"]
+            length = min(len(qpos), len(actions), len(images))
+            if length <= 0:
+                continue
+
+            written_this_episode = 0
+            for step in range(0, length, args.stride):
+                if args.max_frames_per_episode is not None and written_this_episode >= args.max_frames_per_episode:
+                    break
+                rgb = _resize_image(images[step], args.image_height, args.image_width)
+                action = np.asarray(actions[step], dtype=np.float32)
+                if args.action_mode == "absolute_target":
+                    action = DEFAULT_JOINT_POS + ACTION_SCALE * action
+                elif args.action_mode != "env_action":
+                    raise ValueError(f"Unsupported --action_mode={args.action_mode!r}")
+                dataset.add_frame(
+                    {
+                        "video.base_camera_view": rgb,
+                        "state": np.asarray(qpos[step], dtype=np.float32),
+                        "action": action,
+                        "task": args.prompt,
+                    }
+                )
+                frame_count += 1
+                written_this_episode += 1
+            dataset.save_episode()
+
+    print(
+        f"[OK] Wrote native8 LeRobot dataset repo_id={args.repo_id} "
+        f"root={root} episodes={len(traj_keys)} frames={frame_count}"
+    )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", default="datasets/atec_task_e_obj321_servo_100demos/trajectory_filtered.hdf5")
+    parser.add_argument("--root", default="/home/ubuntu/projects/robotics_shared/datasets/lerobot")
+    parser.add_argument("--repo_id", default="atec/task_e_obj321_servo_20demos_native8_s1_224")
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT)
+    parser.add_argument("--fps", type=int, default=50)
+    parser.add_argument("--image_height", type=int, default=224)
+    parser.add_argument("--image_width", type=int, default=224)
+    parser.add_argument("--stride", type=int, default=1)
+    parser.add_argument("--max_episodes", type=int, default=20)
+    parser.add_argument(
+        "--max_frames_per_episode",
+        type=int,
+        default=None,
+        help="Optional cap after stride sampling; useful for fast bridge sanity checks on long raw demos.",
+    )
+    parser.add_argument(
+        "--action_mode",
+        choices=("env_action", "absolute_target"),
+        default="env_action",
+        help=(
+            "Store raw ATEC env actions, or convert them to absolute joint targets with "
+            "joint_target = default_joint_pos + 0.5 * env_action."
+        ),
+    )
+    parser.add_argument("--use_videos", action=argparse.BooleanOptionalAction, default=False)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--image_writer_processes", type=int, default=5)
+    parser.add_argument("--image_writer_threads", type=int, default=10)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    convert(parse_args())

scripts/pi05/eval_task_e_pi05.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""Rollout evaluation for a Task-E pi0.5 websocket policy."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from datetime import datetime
+
+from isaaclab.app import AppLauncher
+
+
+parser = argparse.ArgumentParser(description="Evaluate an OpenPI/pi0.5 server on ATEC Task E.")
+parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper")
+parser.add_argument("--episodes", type=int, default=1)
+parser.add_argument("--max_steps", type=int, default=1500)
+parser.add_argument("--video_path", type=str, default=None, help="Optional MP4 output path for episode 1.")
+parser.add_argument("--video_interval", type=int, default=2)
+parser.add_argument("--video_fps", type=int, default=25)
+parser.add_argument("--seed", type=int, default=None)
+parser.add_argument("--host", type=str, default="127.0.0.1")
+parser.add_argument("--port", type=int, default=8000)
+parser.add_argument("--action_repeat", type=int, default=5)
+parser.add_argument("--solution_module", type=str, default="solution_pi05")
+parser.add_argument("--disable_fabric", action="store_true", default=False)
+parser.add_argument("--debug", action="store_true", default=False)
+AppLauncher.add_app_launcher_args(parser)
+args_cli = parser.parse_args()
+args_cli.enable_cameras = True
+
+repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+os.environ["ATEC_PI05_HOST"] = args_cli.host
+os.environ["ATEC_PI05_PORT"] = str(args_cli.port)
+os.environ["ATEC_PI05_ACTION_REPEAT"] = str(args_cli.action_repeat)
+
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+import gymnasium as gym  # noqa: E402
+import torch  # noqa: E402
+
+from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
+from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402
+
+import atec_rl_lab.tasks  # noqa: F401, E402
+
+demo_dir = os.path.join(repo_root, "demo")
+if repo_root not in sys.path:
+    sys.path.insert(0, repo_root)
+if demo_dir not in sys.path:
+    sys.path.insert(0, demo_dir)
+
+from scripts.act.task_e.collector import basket_status_lines  # noqa: E402
+import importlib  # noqa: E402
+
+AlgSolution = importlib.import_module(args_cli.solution_module).AlgSolution  # noqa: E402
+
+
+def _frame_from_obs(obs) -> object:
+    rgb = obs["image"]["video_rgb"]
+    if isinstance(rgb, torch.Tensor):
+        frame = rgb[0].detach().cpu()
+        if frame.ndim == 3 and frame.shape[0] in (3, 4):
+            frame = frame.permute(1, 2, 0)
+        if frame.shape[-1] == 4:
+            frame = frame[..., :3]
+        if frame.dtype != torch.uint8:
+            frame = (frame.float() * 255.0).clamp(0, 255).to(torch.uint8)
+        return frame.numpy()
+    return rgb[0]
+
+
+def _resolve_video_path() -> str | None:
+    if args_cli.video_path is None:
+        return None
+    if args_cli.video_path:
+        return os.path.abspath(args_cli.video_path)
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return os.path.join(repo_root, "logs", "videos", "task_e_pi05_eval", f"eval_{stamp}.mp4")
+
+
+def evaluate() -> list[dict[str, float]]:
+    env_cfg = parse_env_cfg(
+        args_cli.task,
+        device=args_cli.device,
+        num_envs=1,
+        use_fabric=not args_cli.disable_fabric,
+    )
+    if args_cli.seed is not None:
+        env_cfg.seed = args_cli.seed
+    env = gym.make(args_cli.task, cfg=env_cfg)
+    if isinstance(env.unwrapped, DirectMARLEnv):
+        env = multi_agent_to_single_agent(env)
+
+    policy = AlgSolution()
+    video_path = _resolve_video_path()
+    writer = None
+    if video_path is not None:
+        import imageio.v2 as imageio
+
+        os.makedirs(os.path.dirname(video_path), exist_ok=True)
+        writer = imageio.get_writer(video_path, fps=args_cli.video_fps, quality=7)
+        print(f"[INFO] Recording episode 1 video to: {video_path}")
+
+    results = []
+    try:
+        for episode in range(args_cli.episodes):
+            reset_kwargs = {"seed": args_cli.seed + episode} if args_cli.seed is not None else {}
+            obs, _ = env.reset(**reset_kwargs)
+            policy.reset_episode()
+            total_reward = 0.0
+            elapsed_time = 0.0
+            steps = 0
+            done = False
+            start_wall = time.time()
+            if writer is not None and episode == 0:
+                writer.append_data(_frame_from_obs(obs))
+
+            while simulation_app.is_running() and steps < args_cli.max_steps:
+                resp = policy.predicts(obs, total_reward)
+                if resp["giveup"]:
+                    break
+                action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1)
+                obs, reward, terminated, truncated, info = env.step(action)
+
+                sim_dt = info["Step_dt"]
+                total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt
+                if isinstance(info, dict) and "Elapsed_Time" in info:
+                    elapsed = info["Elapsed_Time"]
+                    elapsed_time = elapsed.item() if hasattr(elapsed, "item") else float(elapsed)
+                else:
+                    elapsed_time += env.unwrapped.step_dt
+                done = bool(terminated.item() or truncated.item())
+                steps += 1
+                if writer is not None and episode == 0 and steps % max(1, args_cli.video_interval) == 0:
+                    writer.append_data(_frame_from_obs(obs))
+                if args_cli.debug and steps % 100 == 0:
+                    print(f"[DEBUG] episode={episode + 1} step={steps} score={total_reward:.2f}")
+                if done:
+                    break
+
+            result = {
+                "episode": episode + 1,
+                "score": float(total_reward),
+                "elapsed_time": float(elapsed_time),
+                "steps": float(steps),
+                "done": float(done),
+                "wall_time": time.time() - start_wall,
+            }
+            results.append(result)
+            try:
+                for line in basket_status_lines(env, [1, 2, 3]):
+                    print(f"[BASKET] episode={episode + 1} {line}")
+            except Exception as exc:
+                if args_cli.debug:
+                    print(f"[DEBUG] basket status unavailable: {exc}")
+            print(
+                "[RESULT] "
+                f"episode={result['episode']:.0f} "
+                f"score={result['score']:.2f} "
+                f"elapsed_time={result['elapsed_time']:.2f} "
+                f"steps={result['steps']:.0f} "
+                f"done={bool(result['done'])} "
+                f"wall_time={result['wall_time']:.1f}s"
+            )
+    finally:
+        if writer is not None:
+            writer.close()
+        env.close()
+
+    return results
+
+
+if __name__ == "__main__":
+    try:
+        results = evaluate()
+        if results:
+            scores = torch.tensor([r["score"] for r in results], dtype=torch.float32)
+            print(f"[SUMMARY] episodes={len(results)} mean_score={scores.mean().item():.2f} best_score={scores.max().item():.2f}")
+    finally:
+        simulation_app.close()

scripts/pi05/run_pi05_20demos_after_convert.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_20demos_s5_224
+CONVERT_UNIT_FILE="$REPO/logs/pi05_convert_task_e_s5_224_20demos.latest_unit"
+STAMP="$(date +%Y%m%d%H%M%S)"
+NORM_LOG="$REPO/logs/pi05_norm_task_e_20demos_s5_224_${STAMP}.log"
+TRAIN_LOG="$REPO/logs/pi05_train_task_e_20demos_s5_224_${STAMP}.log"
+
+export HF_LEROBOT_HOME=/home/ubuntu/projects/robotics_shared/datasets/lerobot
+export HF_HOME=/home/ubuntu/projects/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+export XLA_PYTHON_CLIENT_MEM_FRACTION="${XLA_PYTHON_CLIENT_MEM_FRACTION:-0.80}"
+
+cd "$OPENPI"
+
+if [[ -f "$CONVERT_UNIT_FILE" ]]; then
+  convert_unit="$(cat "$CONVERT_UNIT_FILE").service"
+  echo "[INFO] Waiting for $convert_unit"
+  while systemctl --user is-active --quiet "$convert_unit"; do
+    sleep 60
+  done
+  systemctl --user is-failed --quiet "$convert_unit" && {
+    echo "[ERROR] Conversion unit failed: $convert_unit"
+    systemctl --user status "$convert_unit" --no-pager --lines=80 || true
+    exit 1
+  }
+fi
+
+echo "[INFO] Computing norm stats for $CONFIG" | tee "$NORM_LOG"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  --max-frames 7000 2>&1 | tee -a "$NORM_LOG"
+
+echo "[INFO] Training $CONFIG" | tee "$TRAIN_LOG"
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name atec_task_e_pi05_20demos_s5_224_2k_${STAMP} \
+  --overwrite 2>&1 | tee -a "$TRAIN_LOG"

scripts/pi05/run_pi05_eval_checkpoint.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+OPENPI_PY=/home/ubuntu/envs/openpi-pi05/bin/python
+ISAAC_PY=/home/ubuntu/envs/genmanip-isaac5-py311/bin/python
+
+CONFIG="${CONFIG:-pi05_atec_task_e_s5_224}"
+CHECKPOINT_DIR="${1:-${CHECKPOINT_DIR:-}}"
+PORT="${PORT:-8015}"
+ACTION_REPEAT="${ACTION_REPEAT:-5}"
+STAMP="$(date +%Y%m%d%H%M%S)"
+SERVER_LOG="$REPO/logs/pi05_policy_server_${STAMP}.log"
+EVAL_DIR="$REPO/logs/pi05_eval_${STAMP}"
+
+if [[ -z "$CHECKPOINT_DIR" ]]; then
+  CHECKPOINT_DIR="$(find /home/ubuntu/projects/robotics_shared/checkpoints/openpi/atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)"
+fi
+if [[ -z "$CHECKPOINT_DIR" || ! -d "$CHECKPOINT_DIR" ]]; then
+  echo "[ERROR] Checkpoint dir not found. Pass it as argv[1] or set CHECKPOINT_DIR." >&2
+  exit 1
+fi
+
+mkdir -p "$EVAL_DIR" "$REPO/logs/videos/task_e_pi05_eval"
+
+export HF_LEROBOT_HOME=/home/ubuntu/projects/robotics_shared/datasets/lerobot
+export HF_HOME=/home/ubuntu/projects/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+cd "$OPENPI"
+"$OPENPI_PY" scripts/serve_policy.py \
+  --port "$PORT" \
+  policy:checkpoint \
+  --policy.config "$CONFIG" \
+  --policy.dir "$CHECKPOINT_DIR" \
+  > "$SERVER_LOG" 2>&1 &
+server_pid=$!
+
+cleanup() {
+  kill "$server_pid" 2>/dev/null || true
+}
+trap cleanup EXIT
+
+echo "[INFO] Started OpenPI server pid=$server_pid port=$PORT checkpoint=$CHECKPOINT_DIR"
+for _ in $(seq 1 120); do
+  if grep -q "Creating server" "$SERVER_LOG" 2>/dev/null; then
+    break
+  fi
+  if ! kill -0 "$server_pid" 2>/dev/null; then
+    echo "[ERROR] OpenPI server exited early. Tail:" >&2
+    tail -80 "$SERVER_LOG" >&2 || true
+    exit 1
+  fi
+  sleep 5
+done
+
+export OMNI_KIT_ACCEPT_EULA=YES
+export PYTHONUNBUFFERED=1
+export PYTHONPATH="/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_assets:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_tasks:$REPO/source/atec_rl_lab:$REPO/scripts/act"
+
+cd "$REPO"
+for seed in 11 12 13; do
+  video_arg=()
+  if [[ "$seed" == "11" ]]; then
+    video_arg=(--video_path "$REPO/logs/videos/task_e_pi05_eval/pi05_${CONFIG}_seed11_${STAMP}.mp4")
+  fi
+  "$ISAAC_PY" scripts/pi05/eval_task_e_pi05.py \
+    --episodes 1 \
+    --seed "$seed" \
+    --host 127.0.0.1 \
+    --port "$PORT" \
+    --action_repeat "$ACTION_REPEAT" \
+    --headless \
+    --disable_fabric \
+    "${video_arg[@]}" \
+    > "$EVAL_DIR/seed${seed}.log" 2>&1
+  tail -12 "$EVAL_DIR/seed${seed}.log"
+done
+
+"$ISAAC_PY" scripts/pi05/summarize_pi05_eval.py "$EVAL_DIR" || true
+"$ISAAC_PY" scripts/pi05/compare_pi05_vs_act_baseline.py "$EVAL_DIR" --repo "$REPO" || true
+echo "[INFO] Eval logs: $EVAL_DIR"
+echo "[INFO] Server log: $SERVER_LOG"

scripts/pi05/run_pi05_native8_100demos_prepare.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_100demos_s1_224
+REPO_ID=atec/task_e_obj321_servo_100demos_native8_s1_224
+STAMP="$(date +%Y%m%d%H%M%S)"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+cd "$REPO"
+"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \
+  --root "$HF_LEROBOT_HOME" \
+  --repo_id "$REPO_ID" \
+  --max_episodes 100 \
+  --stride 1 \
+  --fps 50 \
+  --overwrite \
+  2>&1 | tee "logs/pi05_native8_convert_100demos_s1_224_${STAMP}.log"
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_norm_100demos_s1_224_${STAMP}.log"
+
+echo "[INFO] Prepared native8 100-demo dataset/norm stats for $CONFIG"

scripts/pi05/run_pi05_native8_100demos_s2_gate.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_100demos_s2_224
+REPO_ID=atec/task_e_obj321_servo_100demos_native8_s2_224
+STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+mkdir -p "$REPO/logs"
+
+cd "$REPO"
+"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \
+  --root "$HF_LEROBOT_HOME" \
+  --repo_id "$REPO_ID" \
+  --max_episodes 100 \
+  --stride 2 \
+  --fps 25 \
+  --overwrite \
+  2>&1 | tee "logs/pi05_native8_convert_100demos_s2_224_${STAMP}.log"
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_norm_100demos_s2_224_${STAMP}.log"
+
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_100demos_s2_224_10k_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_train_100demos_s2_224_${STAMP}.log"
+
+CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)"
+if [[ -z "$CKPT_DIR" ]]; then
+  echo "[ERROR] No checkpoint found after training for $CONFIG" >&2
+  exit 1
+fi
+
+cd "$REPO"
+CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8023 \
+  scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \
+  2>&1 | tee "logs/pi05_native8_eval_100demos_s2_224_${STAMP}.log"

scripts/pi05/run_pi05_native8_100demos_s2_lora_gate.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_100demos_s2_224_lora
+BASE_CONFIG=pi05_atec_task_e_native8_100demos_s2_224
+REPO_ID=atec/task_e_obj321_servo_100demos_native8_s2_224
+STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+DATA_DIR="$HF_LEROBOT_HOME/$REPO_ID"
+BASE_ASSET_DIR="/data/Data4TB/01Proj/13atec/openpi_atec_runs/assets/$BASE_CONFIG/$REPO_ID"
+LORA_ASSET_DIR="/data/Data4TB/01Proj/13atec/openpi_atec_runs/assets/$CONFIG/$REPO_ID"
+
+mkdir -p "$REPO/logs"
+
+if [[ ! -d "$DATA_DIR" ]]; then
+  echo "[ERROR] Missing native8 100-demo dataset: $DATA_DIR" >&2
+  echo "[ERROR] Run scripts/pi05/run_pi05_native8_100demos_s2_gate.sh once before LoRA." >&2
+  exit 1
+fi
+
+if [[ -f "$BASE_ASSET_DIR/norm_stats.json" ]]; then
+  mkdir -p "$LORA_ASSET_DIR"
+  cp "$BASE_ASSET_DIR/norm_stats.json" "$LORA_ASSET_DIR/norm_stats.json"
+  echo "[INFO] Reused norm stats from $BASE_ASSET_DIR"
+else
+  cd "$OPENPI"
+  "$PY" scripts/compute_norm_stats.py \
+    --config-name "$CONFIG" \
+    2>&1 | tee "$REPO/logs/pi05_native8_lora_norm_100demos_s2_224_${STAMP}.log"
+fi
+
+cd "$OPENPI"
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_100demos_s2_224_lora_7500_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_lora_train_100demos_s2_224_${STAMP}.log"
+
+CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)"
+if [[ -z "$CKPT_DIR" ]]; then
+  echo "[ERROR] No checkpoint found after training for $CONFIG" >&2
+  exit 1
+fi
+
+cd "$REPO"
+CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8024 \
+  scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \
+  2>&1 | tee "logs/pi05_native8_lora_eval_100demos_s2_224_${STAMP}.log"

scripts/pi05/run_pi05_native8_20demos_s2_smoke.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_20demos_s2_224
+REPO_ID=atec/task_e_obj321_servo_20demos_native8_s2_224
+STAMP="$(date +%Y%m%d%H%M%S)"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+cd "$REPO"
+"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \
+  --root "$HF_LEROBOT_HOME" \
+  --repo_id "$REPO_ID" \
+  --max_episodes 20 \
+  --stride 2 \
+  --fps 25 \
+  --overwrite \
+  2>&1 | tee "logs/pi05_native8_convert_20demos_s2_224_${STAMP}.log"
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_norm_20demos_s2_224_${STAMP}.log"
+
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_20demos_s2_224_3k_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_train_20demos_s2_224_${STAMP}.log"
+
+CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)"
+if [[ -z "$CKPT_DIR" ]]; then
+  echo "[ERROR] No checkpoint found after training for $CONFIG" >&2
+  exit 1
+fi
+
+cd "$REPO"
+CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8022 \
+  scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \
+  2>&1 | tee "logs/pi05_native8_eval_20demos_s2_224_${STAMP}.log"

scripts/pi05/run_pi05_native8_20demos_smoke.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_20demos_s1_224
+REPO_ID=atec/task_e_obj321_servo_20demos_native8_s1_224
+STAMP="$(date +%Y%m%d%H%M%S)"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+cd "$REPO"
+"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \
+  --root "$HF_LEROBOT_HOME" \
+  --repo_id "$REPO_ID" \
+  --max_episodes 20 \
+  --stride 1 \
+  --fps 50 \
+  --overwrite \
+  2>&1 | tee "logs/pi05_native8_convert_20demos_s1_224_${STAMP}.log"
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_norm_20demos_s1_224_${STAMP}.log"
+
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_20demos_s1_224_5k_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_train_20demos_s1_224_${STAMP}.log"

scripts/pi05/run_pi05_native8_4demos_s2_sanity.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_4demos_s2_224
+REPO_ID=atec/task_e_obj321_servo_4demos_native8_s2_224
+STAMP="$(date +%Y%m%d%H%M%S)"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+cd "$REPO"
+"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \
+  --root "$HF_LEROBOT_HOME" \
+  --repo_id "$REPO_ID" \
+  --max_episodes 4 \
+  --stride 2 \
+  --fps 25 \
+  --overwrite \
+  2>&1 | tee "logs/pi05_native8_convert_4demos_s2_224_${STAMP}.log"
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_norm_4demos_s2_224_${STAMP}.log"
+
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_4demos_s2_224_1k_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_train_4demos_s2_224_${STAMP}.log"
+
+CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)"
+if [[ -z "$CKPT_DIR" ]]; then
+  echo "[ERROR] No checkpoint found after training for $CONFIG" >&2
+  exit 1
+fi
+
+cd "$REPO"
+CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8023 MAX_STEPS=2200 \
+  scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \
+  2>&1 | tee "logs/pi05_native8_eval_4demos_s2_224_${STAMP}.log"

scripts/pi05/run_pi05_native8_eval_checkpoint.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+OPENPI_PY=/home/ubuntu/envs/openpi-pi05/bin/python
+ISAAC_PY=/home/ubuntu/envs/genmanip-isaac5-py311/bin/python
+
+CONFIG="${CONFIG:-pi05_atec_task_e_native8_20demos_s1_224}"
+CHECKPOINT_DIR="${1:-${CHECKPOINT_DIR:-}}"
+PORT="${PORT:-8021}"
+ACTION_REPEAT="${ACTION_REPEAT:-1}"
+MAX_STEPS="${MAX_STEPS:-2200}"
+SEEDS="${SEEDS:-11 12 13}"
+STAMP="$(date +%Y%m%d%H%M%S)"
+SERVER_LOG="$REPO/logs/pi05_native8_policy_server_${STAMP}.log"
+EVAL_DIR="$REPO/logs/pi05_native8_eval_${STAMP}"
+
+if [[ -z "$CHECKPOINT_DIR" ]]; then
+  CHECKPOINT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)"
+fi
+if [[ -z "$CHECKPOINT_DIR" || ! -d "$CHECKPOINT_DIR" ]]; then
+  echo "[ERROR] Checkpoint dir not found. Pass it as argv[1] or set CHECKPOINT_DIR." >&2
+  exit 1
+fi
+
+mkdir -p "$EVAL_DIR" "$REPO/logs/videos/task_e_pi05_native8_eval"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+cd "$OPENPI"
+"$OPENPI_PY" scripts/serve_policy.py \
+  --port "$PORT" \
+  policy:checkpoint \
+  --policy.config "$CONFIG" \
+  --policy.dir "$CHECKPOINT_DIR" \
+  > "$SERVER_LOG" 2>&1 &
+server_pid=$!
+
+cleanup() {
+  kill "$server_pid" 2>/dev/null || true
+}
+trap cleanup EXIT
+
+echo "[INFO] Started OpenPI native8 server pid=$server_pid port=$PORT checkpoint=$CHECKPOINT_DIR"
+for _ in $(seq 1 120); do
+  if grep -q "Creating server" "$SERVER_LOG" 2>/dev/null; then
+    break
+  fi
+  if ! kill -0 "$server_pid" 2>/dev/null; then
+    echo "[ERROR] OpenPI server exited early. Tail:" >&2
+    tail -80 "$SERVER_LOG" >&2 || true
+    exit 1
+  fi
+  sleep 5
+done
+
+export OMNI_KIT_ACCEPT_EULA=YES
+export PYTHONUNBUFFERED=1
+export PYTHONPATH="/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_assets:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_tasks:$REPO/source/atec_rl_lab:$REPO/scripts/act"
+
+cd "$REPO"
+for seed in $SEEDS; do
+  video_arg=()
+  if [[ "$seed" == "11" ]]; then
+    video_arg=(--video_path "$REPO/logs/videos/task_e_pi05_native8_eval/pi05_native8_${CONFIG}_seed11_${STAMP}.mp4")
+  fi
+  "$ISAAC_PY" scripts/pi05/eval_task_e_pi05.py \
+    --episodes 1 \
+    --seed "$seed" \
+    --host 127.0.0.1 \
+    --port "$PORT" \
+    --action_repeat "$ACTION_REPEAT" \
+    --max_steps "$MAX_STEPS" \
+    --solution_module solution_pi05_native8 \
+    --headless \
+    --disable_fabric \
+    "${video_arg[@]}" \
+    > "$EVAL_DIR/seed${seed}.log" 2>&1
+  tail -12 "$EVAL_DIR/seed${seed}.log"
+done
+
+"$ISAAC_PY" scripts/pi05/summarize_pi05_eval.py "$EVAL_DIR" || true
+echo "[INFO] Eval logs: $EVAL_DIR"
+echo "[INFO] Server log: $SERVER_LOG"

scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_10k_lr5.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_aefull_h10_10k_lr5
+DATASET_DIR=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot/atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224
+STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+mkdir -p "$REPO/logs"
+
+if [[ ! -d "$DATASET_DIR" ]]; then
+  echo "[ERROR] Missing dataset: $DATASET_DIR" >&2
+  exit 1
+fi
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_aefull_h10_10k_lr5_${STAMP}.log"
+
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_aefull_h10_10k_lr5_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_aefull_h10_10k_lr5_${STAMP}.log"

scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_2k.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge
+OPENPI=/home/ubuntu/src/openpi-ebench-clean
+PY=/home/ubuntu/envs/openpi-pi05/bin/python
+CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_aefull_h10_2k
+DATASET_DIR=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot/atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224
+STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}"
+
+export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot
+export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache
+export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src"
+
+mkdir -p "$REPO/logs"
+
+if [[ ! -d "$DATASET_DIR" ]]; then
+  echo "[ERROR] Missing dataset: $DATASET_DIR" >&2
+  exit 1
+fi
+
+cd "$OPENPI"
+"$PY" scripts/compute_norm_stats.py \
+  --config-name "$CONFIG" \
+  2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_aefull_h10_2k_${STAMP}.log"
+
+"$PY" scripts/train.py \
+  "$CONFIG" \
+  --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_aefull_h10_2k_${STAMP}" \
+  --overwrite \
+  2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_aefull_h10_2k_${STAMP}.log"