Add files using upload-large-folder tool

.TimeRecord

@@ -0,0 +1 @@
+u Mr4Z4yC 36QwinZcFfRldpR ==

LICENSE

@@ -0,0 +1,8 @@
+Copyright 2026 ATEC (Advanced Technology Exploration Community)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

atec_robot_model/.gitattributes

@@ -0,0 +1,6 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.usd filter=lfs diff=lfs merge=lfs -text
+*.usda filter=lfs diff=lfs merge=lfs -text
+*.yaml filter=lfs diff=lfs merge=lfs -text
+*.hdr filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text

atec_robot_model/README.md

@@ -0,0 +1,27 @@
+# atec_robot_model
+
+This repository provides robot and object 3D models for simulation and different environments.
+
+## Repository Overview
+
+- `robot/`: robot model assets (USD/USDA and configuration)
+- `objects/`: task-related object assets
+- `scene/`: task-related scene assets
+- `baseline/`: baseline policy weight
+
+## Git Clone (with Git LFS)
+
+This repository stores model files with **Git LFS** 
+
+Clone repository
+
+```bash
+git clone https://github.com/skywoodsz/atec_robot_model.git
+cd atec_robot_model
+```
+
+Pull LFS files
+
+```bash
+git lfs pull
+```

demo/Dockerfile

@@ -0,0 +1,70 @@
+# 基础镜像（选手可自由选择）
+FROM ac2-registry.cn-hangzhou.cr.aliyuncs.com/ac2/pytorch:2.7.1.8-cuda12.8.1-py312-alinux3.2104
+
+# 设置时区（不要改）
+ENV TZ=Asia/Shanghai
+
+# 基础设置（不要改）
+RUN set -x && \
+    groupadd -g 1000 admin && \
+    useradd -u 1000 -g admin -m admin && \
+    mkdir -p /home/admin/appspace/atec2026/robot/solution/ && \
+    chown -R admin:admin /home/admin/appspace
+
+# 将镜像自带的 python ac2 虚拟环境所有者改为 admin 用户（选手根据实际情况调整）
+RUN chown -R admin:admin /opt/ac2
+
+# 设置 pip 源（选手根据实际情况调整）
+ENV PIP_INDEX_URL=https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
+ENV PIP_TRUSTED_HOST=mirrors.tuna.tsinghua.edu.cn
+
+# 使用 admin 用户运行（不要改）
+USER admin
+
+# 工作目录（不要改）
+WORKDIR /home/admin/appspace/atec2026/robot
+
+# 选手的文件都要放到 solution 目录下（不要改）
+
+# 通用文件：run.sh，requirements.txt，server.py
+COPY --chown=admin:admin run.sh ./solution/
+COPY --chown=admin:admin requirements.txt ./solution/
+COPY --chown=admin:admin server.py ./solution/
+
+# Task E ACT/XSA submission
+COPY --chown=admin:admin solution_act.py ./solution/solution.py
+COPY --chown=admin:admin act ./solution/act
+COPY --chown=admin:admin policy_act.pt ./solution/policy_act.pt
+
+# demo2: RL demo
+# COPY --chown=admin:admin solution_rl.py ./solution/solution.py
+# COPY --chown=admin:admin policy.pt ./solution/
+
+# demo3: ACT demo
+# COPY --chown=admin:admin solution_act.py ./solution/solution.py
+# COPY --chown=admin:admin act ./solution/act
+# COPY --chown=admin:admin policy_act.pt ./solution/policy_act.pt
+
+
+# 赋予 run.sh 可执行权限（不要改）
+RUN set -x && \
+    chmod +x ./solution/run.sh
+
+# 在工作目录下创建虚拟环境软链接，复用镜像自带的 python ac2 虚拟环境（选手根据实际情况调整）
+RUN set -x && \
+    ln -s /opt/ac2 venv
+
+# python 虚拟环境设置，并安装HTTP服务所需依赖（不要改）
+RUN set -x && \
+    source ./venv/bin/activate && \
+    pip install --no-cache-dir fastapi==0.136.0 uvicorn==0.45.0 python-multipart==0.0.26
+
+# 依赖安装（选手根据实际情况调整）
+RUN set -x && \
+    source ./venv/bin/activate && \
+    if [ -s "solution/requirements.txt" ]; then \
+        pip install --no-cache-dir -r solution/requirements.txt; \
+    fi
+
+# 选手镜像启动命令（不要改）
+CMD ["./solution/run.sh"]

demo/requirements.txt

@@ -0,0 +1,4 @@
+h5py
+fastapi
+uvicorn
+python-multipart

demo/run.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+mkdir -p /home/admin/logs/atec2026/robot/solution
+cd /home/admin/appspace/atec2026/robot
+source ./venv/bin/activate
+python solution/server.py 2>&1 | tee /home/admin/logs/atec2026/robot/solution/server.stdout

demo/server.py

@@ -0,0 +1,166 @@
+from fastapi import FastAPI, Request, Form, File, UploadFile
+from fastapi.responses import JSONResponse
+import logging
+import os
+import sys
+import signal
+import threading
+import base64
+import torch
+import pickle
+import json
+from io import BytesIO
+import numpy as np
+from typing import Optional
+
+def setup_logging():
+    """Setup logging configuration with LOG_DIR environment variable support"""
+    # default log directory: atec/logs/
+    project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    log_dir = os.environ.get('LOG_DIR', os.path.join(project_dir, 'logs'))
+    
+    # Create log directory if it doesn't exist
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+    
+    log_file = os.path.join(log_dir, 'user.log')
+    
+    # Create module-specific logger
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
+    
+    # Create formatter
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    
+    # Create file handler
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(formatter)
+    
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    
+    # Add handlers to logger
+    logger.addHandler(file_handler)
+    if os.environ.get('LOG_TO_CONSOLE'):
+        logger.addHandler(console_handler)
+    
+    return logger
+
+# Setup logging
+logger = setup_logging()
+
+
+try:
+    from solution import AlgSolution
+    agent = AlgSolution()
+except Exception as e:
+    import traceback
+    logger.error("Failed to initialize AlgSolution: %s", traceback.format_exc())
+    exit(-1)
+
+app = FastAPI()
+
+logger.info("Server started")
+
+@app.post('/step')
+async def step(
+    proprio: UploadFile = File(),
+    extero: Optional[UploadFile] = File(None),
+    head_rgb: Optional[UploadFile] = File(None),
+    head_depth: Optional[UploadFile] = File(None),
+    ee_rgb: UploadFile = File(),
+    ee_depth: UploadFile = File(),
+    video_rgb: Optional[UploadFile] = File(None),
+    video_depth: Optional[UploadFile] = File(None),
+    current_score: float= Form(),
+):
+
+    proprio = torch.tensor(np.frombuffer(await proprio.read(), dtype=np.float32).reshape(1, -1)).cuda()
+    extero = torch.tensor(np.frombuffer(await extero.read(), dtype=np.float32).reshape(1, -1)).cuda() if extero is not None else None
+    head_rgb = torch.tensor(np.frombuffer(await head_rgb.read(), dtype=np.uint8).reshape(1, 480, 640, 3)).cuda() if head_rgb is not None else None
+    head_depth = torch.tensor(np.frombuffer(await head_depth.read(), dtype=np.float32).reshape(1, 480, 640, 1)).cuda() if head_depth is not None else None
+    video_rgb = torch.tensor(np.frombuffer(await video_rgb.read(), dtype=np.uint8).reshape(1, 480, 640, 3)).cuda() if video_rgb is not None else None
+    video_depth = torch.tensor(np.frombuffer(await video_depth.read(), dtype=np.float32).reshape(1, 480, 640, 1)).cuda() if video_depth is not None else None
+
+    ee_rgb = torch.tensor(np.frombuffer(await ee_rgb.read(), dtype=np.uint8).reshape(1, 480, 640, 3)).cuda()
+    ee_depth = torch.tensor(np.frombuffer(await ee_depth.read(), dtype=np.float32).reshape(1, 480, 640, 1)).cuda()
+
+    if head_rgb is not None:
+        obs = {
+            'proprio': proprio,
+            'extero': extero,
+            'image': {
+                'head_rgb': head_rgb,
+                'head_depth': head_depth,
+                'ee_rgb': ee_rgb,
+                'ee_depth': ee_depth,
+            }
+        }
+    else:
+        obs = {
+            'proprio': proprio,
+            'extero': extero,
+            'image': {
+                'video_rgb': video_rgb,
+                'video_depth': video_depth,
+                'ee_rgb': ee_rgb,
+                'ee_depth': ee_depth,
+            }
+        }
+    action = agent.predicts(obs=obs, current_score=current_score)
+    return action
+
+@app.post('/reset')
+async def reset(request: Request):
+    form_data = await request.json()
+    agent.reset(**form_data)
+    return {"message": "success"}
+
+@app.get('/synchronize')
+async def synchronize():
+    return {"message": "success"}
+
+@app.get('/health')
+async def health():
+    return {"message": "success"}
+
+
+@app.get('/get_action_spec')
+async def get_action_spec():
+    if hasattr(agent, 'get_action_spec'):
+        return agent.get_action_spec()
+    logger.warning("'get_action_spec' not found in solution")
+    return {}
+
+
+@app.post('/stop')
+async def stop(request: Request):
+    body = await request.json()
+    msg = body.get('msg')
+    logger.info("Stop message received: %s", msg)
+    return {"message": "success"}
+
+@app.post('/quit')
+async def quit(request: Request):
+    """Gracefully shutdown the FastAPI application"""
+    body = await request.json()
+    msg = body.get('msg', 'quit')
+    logger.info("Quit message received: %s", msg)
+
+    # Use a timer to shutdown the server after sending response
+    def shutdown_server():
+        import uvicorn
+        logger.info("Shutting down the server...")
+        # This will send SIGTERM to the process
+        os.kill(os.getpid(), signal.SIGTERM)
+
+    # Start shutdown in a separate thread with a small delay to ensure response is sent
+    shutdown_timer = threading.Timer(1.0, shutdown_server)
+    shutdown_timer.start()
+
+    return {"message": "Server is shutting down gracefully"}
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=5000)

demo/solution.py

@@ -0,0 +1,17 @@
+"""Submission entry point for ATEC Task E.
+
+The judging server imports `solution.AlgSolution`, so keep this tiny wrapper in
+place and put the actual ACT/XSA implementation in `solution_act.py`.
+"""
+
+import os
+import sys
+
+_DEMO_DIR = os.path.dirname(os.path.abspath(__file__))
+if _DEMO_DIR not in sys.path:
+    sys.path.insert(0, _DEMO_DIR)
+
+try:
+    from .solution_act import AlgSolution
+except ImportError:
+    from solution_act import AlgSolution

demo/solution_act.py

@@ -0,0 +1,292 @@
+import torch
+import torch.nn as nn
+from collections import deque
+import torchvision.transforms.functional as TF
+import torchvision.transforms as T
+from dataclasses import dataclass
+import sys
+import os
+
+current_path = os.path.dirname(os.path.abspath(__file__))
+#sys.path.insert(0, current_path)
+
+from act.detr.backbone import build_backbone
+from act.detr.transformer import build_transformer
+from act.detr.detr_vae import build_encoder, DETRVAE
+
+@dataclass
+class Args:
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    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
+
+
+class Agent(nn.Module):
+    def __init__(self, state_dim: int, act_dim: int, args: Args):
+        super().__init__()
+        self.device = 'cuda'
+        self.state_dim  = state_dim
+        self.act_dim    = act_dim
+        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 get_action(self, obs: dict) -> torch.Tensor:
+        self._preprocess_rgb(obs)
+        a_hat, _ = self.model(self._model_input(obs))
+        return a_hat
+
+
+
+class AlgSolution:
+
+    # Slice into proprio for joint positions (relative to default).
+    _QPOS_SLICE = slice(0, 8)
+    _QVEL_SLICE = slice(8, 16)
+    _RGB_CHANNELS = 3
+    _CONCAT_IMAGE_CHANNELS = 8
+
+    def __init__(self):
+        self.device = 'cuda'
+        # Default to the submission-layout policy file, but allow local eval to
+        # point at a checkpoint without copying 100MB+ files around.
+        policy_path = os.environ.get("ATEC_ACT_POLICY_PATH", current_path + '/policy_act.pt')
+        ckpt = torch.load(policy_path, map_location=self.device)
+        norm_stats = ckpt["norm_stats"]
+        state_dim  = norm_stats["state_mean"].shape[-1]
+        act_dim    = norm_stats["action_mean"].shape[-1]
+        weight_key = "ema_agent"# if use_ema and "ema_agent" in ckpt else "agent"
+
+        train_args = Args()
+        model_args = ckpt.get("model_args", {})
+        for key in (
+            "enc_layers",
+            "dec_layers",
+            "dim_feedforward",
+            "hidden_dim",
+            "dropout",
+            "nheads",
+            "num_queries",
+            "pre_norm",
+            "use_xsa",
+        ):
+            if key in model_args:
+                setattr(train_args, key, model_args[key])
+        train_args.include_rgb = model_args.get(
+            "include_rgb",
+            any("backbone" in k for k in ckpt[weight_key].keys()),
+        )
+
+        self.agent = Agent(state_dim, act_dim, train_args).to(self.device)
+        self.agent.load_state_dict(ckpt[weight_key])
+        self.agent.eval()
+
+        self.num_queries  = train_args.num_queries
+        self.temporal_agg = os.environ.get("ATEC_ACT_TEMPORAL_AGG", "1").lower() not in ("0", "false", "no")
+        self._k           = float(os.environ.get("ATEC_ACT_TEMPORAL_K", "0.01"))
+        self._prefer_new_actions = os.environ.get("ATEC_ACT_PREFER_NEW", "0").lower() in ("1", "true", "yes")
+
+        self.state_mean = norm_stats["state_mean"].to(self.device)   # (1, state_dim)
+        self.state_std  = norm_stats["state_std"].to(self.device)    # (1, state_dim)
+        self.act_mean   = norm_stats["action_mean"].to(self.device)  # (1, act_dim)
+        self.act_std    = norm_stats["action_std"].to(self.device)   # (1, act_dim)
+
+        self.default_joint_pos = torch.tensor(
+            [[0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035]],
+            dtype=torch.float32,
+            device=self.device,
+        )
+        # Per-episode state
+        self._ts: int = 0
+        self._action_history: deque = deque(maxlen=self.num_queries)
+        self._last_action_seq: torch.Tensor | None = None
+
+
+        startup_zero_steps = 25
+        home_qpos_tolerance = 0.10
+        home_hold_steps = 5
+
+        self.teleop_home_joint_pos = torch.tensor(
+            [[-0.000033, 0.924525, -1.514983, 0.000011, 1.219900, -0.000033, 0.035000, -0.035000]],
+            dtype=torch.float32,
+            device=self.device,
+        )
+
+        self._startup_zero_steps = max(0, int(startup_zero_steps))
+        self._home_qpos_tolerance = float(home_qpos_tolerance)
+        self._home_hold_steps = max(0, int(home_hold_steps))
+        self._home_action = torch.clamp(
+            (self.teleop_home_joint_pos - self.default_joint_pos) / 0.5,
+            -1.0,
+            1.0,
+        )
+
+        self._startup_step = 0
+        self._home_stable_steps = 0
+        self._home_done = False
+
+    def reset_episode(self):
+        self._ts = 0
+        self._action_history.clear()
+        self._last_action_seq = None
+        self._startup_step = 0
+        self._home_stable_steps = 0
+        self._home_done = False
+
+    def get_action_spec(self):
+        # Use the official default Task-E Piper action configuration.
+        return None
+
+
+    def _compute_home_action(self, proprio):
+        joint_pos_rel = proprio[:, self._QPOS_SLICE]
+        qpos = joint_pos_rel + self.default_joint_pos
+        qerr = self.teleop_home_joint_pos - qpos
+
+        within_tolerance = torch.all(torch.abs(qerr) <= self._home_qpos_tolerance, dim=1)
+        self._home_stable_steps = self._home_stable_steps + 1 if bool(torch.all(within_tolerance)) else 0
+
+        # Env action is a relative joint-position target, not velocity/torque.
+        # Keep commanding the absolute teleop-home target until the ACT rollout starts.
+        action = self._home_action.repeat(proprio.shape[0], 1)
+        home_reached = self._home_stable_steps >= self._home_hold_steps
+        return action, home_reached
+
+
+    def predicts(self, obs, current_score):
+        if not isinstance(obs, dict) or "proprio" not in obs:
+            raise ValueError("Expected obs dict with 'proprio' key.")
+
+        proprio = obs["proprio"].to(self.device)              # (num_envs, 24)
+
+        # Stage 1: output zero actions for the first few steps.
+        if self._startup_step < self._startup_zero_steps:
+            self._startup_step += 1
+            return {'action': torch.zeros((proprio.shape[0], self.agent.act_dim)).numpy().tolist(), 'giveup': False}
+
+        # Stage 2: move to teleop_home using only observations.
+        if not self._home_done:
+            home_action, home_reached = self._compute_home_action(proprio)
+            if home_reached:
+                self._home_done = True
+                self._ts = 0
+                self._action_history.clear()
+                self._last_action_seq = None
+            return {'action': home_action.cpu().numpy().tolist(), 'giveup': False}
+
+        # Recover absolute joint positions from relative obs.
+        joint_pos_rel = proprio[:, self._QPOS_SLICE]          # (num_envs, 8)
+        qpos  = joint_pos_rel + self.default_joint_pos        # (num_envs, 8)
+        state = (qpos - self.state_mean) / self.state_std     # (num_envs, 8)
+        model_obs = {"state": state}
+
+        if self.agent.include_rgb:
+            rgb = obs["image"]["video_rgb"].to(self.device)
+            if rgb.shape[1] == 4:
+                rgb = rgb[:, :3]                               # drop alpha if RGBA/NCHW
+            if rgb.ndim == 4 and rgb.shape[-1] == 4:
+                rgb = rgb[..., :3]                             # drop alpha if RGBA/NHWC
+            if rgb.dtype != torch.uint8:
+                rgb = (rgb.float() * 255.0).clamp(0, 255).to(torch.uint8)
+            if rgb.ndim == 4 and rgb.shape[1] in (3, 4):
+                pass
+            else:
+                rgb = rgb.permute(0, 3, 1, 2)
+            if rgb.shape[-2:] != (224, 224):
+                rgb = TF.resize(rgb, [224, 224],
+                                interpolation=TF.InterpolationMode.BILINEAR,
+                                antialias=True)
+            model_obs["rgb"] = rgb.unsqueeze(1)                # (num_envs, 1, 3, 224, 224) uint8
+
+        ts = self._ts
+        query_frequency = 1 if self.temporal_agg else self.num_queries
+
+        if ts % query_frequency == 0:
+            with torch.no_grad():
+                action_seq = self.agent.get_action(model_obs)  # (num_envs, num_queries, act_dim)
+            if self.temporal_agg:
+                self._action_history.append(action_seq)
+            else:
+                self._last_action_seq = action_seq
+
+        if self.temporal_agg:
+            n = len(self._action_history)
+            # deque[i=0] = oldest (added n-1 steps ago); for current step its offset = n-1-i
+            actions_for_curr = torch.stack(
+                [seq[:, n - 1 - i, :] for i, seq in enumerate(self._action_history)],
+                dim=1,
+            )  # (num_envs, n, act_dim)
+
+            # Default preserves the original convention.  ATECs long-horizon
+            # rollout can also be evaluated with newer predictions weighted
+            # higher via ATEC_ACT_PREFER_NEW=1.
+            order = torch.arange(n, device=self.device)
+            if self._prefer_new_actions:
+                order = torch.flip(order, dims=[0])
+            exp_weights = torch.exp(-self._k * order)
+            exp_weights = (exp_weights / exp_weights.sum()).unsqueeze(0).unsqueeze(-1)
+            raw_action = (actions_for_curr * exp_weights).sum(dim=1)   # (num_envs, act_dim)
+        else:
+            raw_action = self._last_action_seq[:, ts % query_frequency]  # (num_envs, act_dim)
+
+        # Denormalise → env action format
+        action = raw_action * self.act_std + self.act_mean
+        self._ts += 1
+        return {'action': action.tolist(), 'giveup': False}

demo/solution_dual_act.py

@@ -0,0 +1,66 @@
+"""Two-ACT relay experiment for ATEC Task E.
+
+Both policies are stepped on every observation so their temporal histories stay
+aligned with the actual rollout.  The primary policy controls the reliable
+early phase; after the score reaches the configured band, the secondary policy
+may take over the late object_1 phase.
+"""
+
+from __future__ import annotations
+
+import os
+
+from solution_act import AlgSolution as _ActSolution
+
+
+class AlgSolution:
+    def __init__(self):
+        self._primary_path = os.environ.get("ATEC_DUAL_PRIMARY_POLICY", os.environ.get("ATEC_ACT_POLICY_PATH", ""))
+        self._secondary_path = os.environ.get("ATEC_DUAL_SECONDARY_POLICY", "")
+        if not self._secondary_path:
+            raise RuntimeError("ATEC_DUAL_SECONDARY_POLICY is required for solution_dual_act")
+
+        old_policy_path = os.environ.get("ATEC_ACT_POLICY_PATH")
+        try:
+            if self._primary_path:
+                os.environ["ATEC_ACT_POLICY_PATH"] = self._primary_path
+            self.primary = _ActSolution()
+            os.environ["ATEC_ACT_POLICY_PATH"] = self._secondary_path
+            self.secondary = _ActSolution()
+        finally:
+            if old_policy_path is None:
+                os.environ.pop("ATEC_ACT_POLICY_PATH", None)
+            else:
+                os.environ["ATEC_ACT_POLICY_PATH"] = old_policy_path
+
+        self._switch_score = float(os.environ.get("ATEC_DUAL_SWITCH_SCORE", "12.0"))
+        self._switch_act_steps = int(os.environ.get("ATEC_DUAL_SWITCH_ACT_STEPS", "900"))
+        self._mode = "primary"
+        self._step = 0
+
+    def reset_episode(self):
+        self.primary.reset_episode()
+        self.secondary.reset_episode()
+        self._mode = "primary"
+        self._step = 0
+
+    def get_action_spec(self):
+        return None
+
+    def predicts(self, obs, current_score):
+        self._step += 1
+        primary_resp = self.primary.predicts(obs, current_score)
+        secondary_resp = self.secondary.predicts(obs, current_score)
+        primary_steps = int(getattr(self.primary, "_ts", 0))
+        if (
+            self._mode == "primary"
+            and float(current_score) >= self._switch_score
+            and primary_steps >= self._switch_act_steps
+        ):
+            self._mode = "secondary"
+            print(
+                f"[DUAL_ACT] switching to secondary score={float(current_score):.2f} "
+                f"primary_steps={primary_steps}",
+                flush=True,
+            )
+        return secondary_resp if self._mode == "secondary" else primary_resp

demo/solution_hybrid_obj1_pca.py

@@ -0,0 +1,68 @@
+"""ACT plus object_1-only PCA rescue for Task E experiments.
+
+This is intentionally conservative: keep the ACT policy in control until the
+episode has already reached the 15-point band, then spend remaining time trying
+to move object_1 into the basket.  It is not the protected submission baseline.
+"""
+
+from __future__ import annotations
+
+import os
+
+os.environ.setdefault("ATEC_PCA_OBJECTS", "1")
+
+from solution_act import AlgSolution as _ActSolution
+from solution_pca import AlgSolution as _PcaSolution
+
+
+class AlgSolution:
+    def __init__(self):
+        self.act = _ActSolution()
+        self.pca = _PcaSolution()
+        self._mode = "act"
+        self._pca_started = False
+        self._switch_score = float(os.environ.get("ATEC_HYBRID_SWITCH_SCORE", "15.0"))
+        self._min_act_policy_steps = int(os.environ.get("ATEC_HYBRID_MIN_ACT_POLICY_STEPS", "900"))
+        self._force_act_policy_steps = int(os.environ.get("ATEC_HYBRID_FORCE_ACT_POLICY_STEPS", "999999"))
+        self._force_env_steps = int(os.environ.get("ATEC_HYBRID_FORCE_ENV_STEPS", "999999"))
+        self._env_steps = 0
+
+    def reset_episode(self):
+        self.act.reset_episode()
+        self.pca.reset_episode()
+        self._mode = "act"
+        self._pca_started = False
+        self._env_steps = 0
+
+    def get_action_spec(self):
+        return None
+
+    def _start_pca(self, reason=""):
+        self.pca.reset_episode()
+        # ACT has already moved the arm into the workspace.  Skip PCA startup
+        # and home, otherwise the late rescue often times out.
+        self.pca.t = 25
+        self.pca.home_count = 80
+        self._mode = "pca"
+        self._pca_started = True
+        print(f"[HYBRID] switching to object_1 PCA rescue {reason}".rstrip(), flush=True)
+
+    def predicts(self, obs, current_score):
+        if self._mode == "act":
+            self._env_steps += 1
+            act_steps = int(getattr(self.act, "_ts", 0))
+            score_gate = (
+                float(current_score) >= self._switch_score
+                and act_steps >= self._min_act_policy_steps
+            )
+            act_gate = act_steps >= self._force_act_policy_steps
+            env_gate = self._env_steps >= self._force_env_steps
+            if score_gate or act_gate or env_gate:
+                self._start_pca(
+                    f"score={float(current_score):.2f} act_steps={act_steps} "
+                    f"env_steps={self._env_steps} gate="
+                    f"{'score' if score_gate else ('act' if act_gate else 'env')}"
+                )
+            else:
+                return self.act.predicts(obs, current_score)
+        return self.pca.predicts(obs, current_score)

demo/solution_pca.py

@@ -0,0 +1,1243 @@
+"""Observation-only GraspGen-style PCA/AABB controller for ATEC Task E.
+
+This is an experimental submit-style policy: it uses only proprioception plus
+the fixed external RGB-D camera observation to estimate object centres, then
+drives a calibrated Piper pick/place primitive with local kinematics.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+
+try:
+    import pinocchio as pin
+except Exception:  # pragma: no cover - handled at runtime by the judge/server
+    pin = None
+
+
+TABLE_CENTER_X = 1.00
+TABLE_CENTER_Y = 0.00
+TABLE_DIMS_AT_0P008 = (0.6468062441005529, 0.9084968693231588, 0.6613141183247961)
+TABLE_SCALE = 0.01
+TABLE_DIMS = tuple(dim * (TABLE_SCALE / 0.008) for dim in TABLE_DIMS_AT_0P008)
+TABLE_HALF_X = TABLE_DIMS[0] * 0.5
+TABLE_TOP_Z = TABLE_DIMS[2]
+BASKET_CENTER_X = TABLE_CENTER_X + 0.08
+BASKET_CENTER_Y = TABLE_CENTER_Y - 0.30
+
+DEFAULT_Q = np.array([0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035], dtype=np.float64)
+HOME_Q = np.array([-0.000033, 0.924525, -1.514983, 0.000011, 1.219900, -0.000033, 0.035, -0.035], dtype=np.float64)
+ACTION_SCALE = 0.5
+GRIP_OPEN = np.array([0.035, -0.035], dtype=np.float64)
+GRIP_HALF = np.array([0.018, -0.018], dtype=np.float64)
+GRIP_CLOSE = np.array([0.0, 0.0], dtype=np.float64)
+OBJ1_HOLD_GAP = 0.0415
+OBJ3_HOLD_GAP = float(os.environ.get("ATEC_PCA_OBJ3_HOLD_GAP", "0.0675"))
+OBJ3_CLOSE_MIN_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_CLOSE_MIN_STEPS", "160"))
+OBJ3_LOW_HOLD_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_LOW_HOLD_STEPS", "0"))
+OBJ3_LIFT_CLEARANCE = float(os.environ.get("ATEC_PCA_OBJ3_LIFT_CLEARANCE", "0.12"))
+OBJ3_CARRY_CLEARANCE = float(os.environ.get("ATEC_PCA_OBJ3_CARRY_CLEARANCE", "0.145"))
+OBJ3_OBJECT_SERVO_GAIN = float(os.environ.get("ATEC_PCA_OBJ3_OBJECT_SERVO_GAIN", "1.0"))
+OBJ3_OBJECT_SERVO_MAX_XY = float(os.environ.get("ATEC_PCA_OBJ3_OBJECT_SERVO_MAX_XY", "0.300"))
+OBJ3_FINGER_SERVO_MAX_XY = float(os.environ.get("ATEC_PCA_OBJ3_FINGER_SERVO_MAX_XY", "0.240"))
+OBJ3_APPROACH_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_APPROACH_FINGER_Z", str(TABLE_TOP_Z + 0.090)))
+OBJ3_CLOSE_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_CLOSE_FINGER_Z", str(TABLE_TOP_Z + 0.000)))
+OBJ3_LIFT_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_LIFT_FINGER_Z", str(TABLE_TOP_Z + 0.045)))
+OBJ3_ENABLE_INSERT = os.environ.get("ATEC_PCA_OBJ3_ENABLE_INSERT", "0") != "0"
+OBJ3_PREGRASP_OFFSET = np.array(
+    [
+        float(os.environ.get("ATEC_PCA_OBJ3_PREGRASP_X_OFFSET", "0.000")),
+        float(os.environ.get("ATEC_PCA_OBJ3_PREGRASP_Y_OFFSET", "0.080")),
+    ],
+    dtype=np.float64,
+)
+OBJ3_SIDE_APPROACH_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_SIDE_APPROACH_STEPS", "160"))
+OBJ3_SIDE_LOW_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_SIDE_LOW_STEPS", "140"))
+OBJ3_INSERT_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_INSERT_STEPS", "220"))
+OBJ3_PREGRASP_LOW_FINGER_Z = float(os.environ.get("ATEC_PCA_OBJ3_PREGRASP_LOW_FINGER_Z", str(TABLE_TOP_Z + 0.024)))
+OBJ3_FALLBACK_DRAG_Z = float(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_DRAG_Z", str(TABLE_TOP_Z + 0.035)))
+OBJ3_FALLBACK_START_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_START_STEPS", "60"))
+OBJ3_FALLBACK_MID_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_MID_STEPS", "260"))
+OBJ3_FALLBACK_END_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_END_STEPS", "260"))
+OBJ3_FALLBACK_OPEN_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_FALLBACK_OPEN_STEPS", "100"))
+OBJ3_DRAG_START_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_START_STEPS", "80"))
+OBJ3_DRAG_MID_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_MID_STEPS", "360"))
+OBJ3_DRAG_END_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_END_STEPS", "360"))
+OBJ3_DRAG_SETTLE_STEPS = int(os.environ.get("ATEC_PCA_OBJ3_DRAG_SETTLE_STEPS", "120"))
+PCA_DLS_MAX_DELTA = float(os.environ.get("ATEC_PCA_DLS_MAX_DELTA", "0.18"))
+PCA_FINGER_IK_MAX_DELTA = float(os.environ.get("ATEC_PCA_FINGER_IK_MAX_DELTA", "0.18"))
+OBJ3_GRIPPER_MAX_DELTA = float(os.environ.get("ATEC_PCA_OBJ3_GRIPPER_MAX_DELTA", "0.003"))
+OBJ3_HOLD_GRIP_DEFAULT = np.array(
+    [
+        float(os.environ.get("ATEC_PCA_OBJ3_HOLD_Q_POS", "0.0000")),
+        float(os.environ.get("ATEC_PCA_OBJ3_HOLD_Q_NEG", "0.0000")),
+    ],
+    dtype=np.float64,
+)
+
+BASE_POS_W = np.array([TABLE_CENTER_X + TABLE_HALF_X, TABLE_CENTER_Y, TABLE_TOP_Z], dtype=np.float64)
+R_W_B = np.diag([-1.0, -1.0, 1.0])
+K_VIDEO = np.array([[732.99927, 0.0, 320.0], [0.0, 732.99927, 240.0], [0.0, 0.0, 1.0]], dtype=np.float64)
+CAM_POS_W = np.array([-0.2, 0.0, 1.6266427], dtype=np.float64)
+CAM_QUAT_WXYZ = np.array([-0.33350849, 0.62351596, -0.62351584, 0.33350849], dtype=np.float64)
+
+OBJ_Y_BANDS = {
+    1: (TABLE_CENTER_Y + 0.25, TABLE_CENTER_Y + 0.29),
+    2: (TABLE_CENTER_Y + 0.14, TABLE_CENTER_Y + 0.20),
+    3: (TABLE_CENTER_Y + 0.03, TABLE_CENTER_Y + 0.09),
+}
+OBJ_Z_LIMITS = {
+    1: (TABLE_TOP_Z + 0.035, TABLE_TOP_Z + 0.130),
+    2: (TABLE_TOP_Z + 0.020, TABLE_TOP_Z + 0.190),
+    3: (TABLE_TOP_Z + 0.012, TABLE_TOP_Z + 0.095),
+}
+OBJ_GRASP_CENTER_OFFSETS = {
+    1: np.array([0.0, 0.0], dtype=np.float64),
+    2: np.array([0.060, 0.0], dtype=np.float64),
+    3: np.array([float(os.environ.get("ATEC_PCA_OBJ3_X_OFFSET", "0.0")), 0.0], dtype=np.float64),
+}
+OBJ_CENTER_COMPLETION_OFFSETS = {
+    # The fixed camera sees object_1 from the lower-y side when it is near the
+    # top band edge; RGB-D AABB/median centres land on the visible side instead
+    # of the root/contact centre.  This completes the centre before applying
+    # the Piper finger offset below.
+    1: np.array([0.020, 0.0], dtype=np.float64),
+    2: np.array([0.0, 0.0], dtype=np.float64),
+    3: np.array(
+        [
+            0.0,
+            float(os.environ.get("ATEC_PCA_OBJ3_CENTER_Y_OFFSET", "0.000")),
+        ],
+        dtype=np.float64,
+    ),
+}
+OBJ_TCP_Z = {1: 0.140, 2: 0.040, 3: 0.090}
+OBJ_CLOSE_Z_OFFSETS = {1: 0.020, 2: 0.020, 3: float(os.environ.get("ATEC_PCA_OBJ3_CLOSE_Z_OFFSET", "-0.005"))}
+OBJ_CLOSE_Z = {
+    1: TABLE_TOP_Z + 0.030,  # low close plane; compensate submit IK's high-contact bias
+    2: TABLE_TOP_Z + 0.030,
+    3: TABLE_TOP_Z + 0.030,
+}
+OBJ_ROOT_Z_EST = {
+    1: TABLE_TOP_Z + 0.045,
+    2: TABLE_TOP_Z + 0.055,
+    3: TABLE_TOP_Z + 0.035,
+}
+OBJ_PRECLOSE_INSERT_OFFSETS = {
+    1: np.array([0.0, 0.0], dtype=np.float64),
+}
+OBJ_FINGER_XY_OFFSETS = {
+    # Calibrated from successful 2026-05-20 scripted traces.  Banana succeeds
+    # when the actual link7/link8 centre is slightly on the -X side of the
+    # object root, cradling the curve instead of pushing from the +X side.
+    3: np.array(
+        [
+            float(os.environ.get("ATEC_PCA_OBJ3_FINGER_X_OFFSET", "-0.010")),
+            float(os.environ.get("ATEC_PCA_OBJ3_FINGER_Y_OFFSET", "0.000")),
+        ],
+        dtype=np.float64,
+    ),
+}
+OBJ_FINGER_TARGET_REL_Z = {
+    1: -0.025,
+    3: float(os.environ.get("ATEC_PCA_OBJ3_FINGER_REL_Z", "0.027")),
+}
+OBJ_FINGER_SERVO_MAX_Z = {1: 0.050, 3: 0.040}
+OBJ_REACH_STEPS = {1: 200, 2: 200, 3: 200}
+OBJ_CLOSE_STEPS = {1: 220, 2: 180, 3: int(os.environ.get("ATEC_PCA_OBJ3_CLOSE_STEPS", "90"))}
+OBJ_LIFT_STEPS = {1: 300, 2: 200, 3: int(os.environ.get("ATEC_PCA_OBJ3_LIFT_STEPS", "35"))}
+OBJ_TRANSPORT_STEPS = {1: 1400, 2: 1400, 3: int(os.environ.get("ATEC_PCA_OBJ3_TRANSPORT_STEPS", "440"))}
+OBJ_PLACE_STEPS = {1: 260, 2: 260, 3: 220}
+OBJ_OPEN_STEPS = {1: 260, 2: 260, 3: 220}
+OBJ_PLACE_XY_OFFSETS = {
+    1: np.array([0.0, 0.0], dtype=np.float64),
+    3: np.array(
+        [
+            float(os.environ.get("ATEC_PCA_OBJ3_PLACE_X_OFFSET", "0.0")),
+            float(os.environ.get("ATEC_PCA_OBJ3_PLACE_Y_OFFSET", "0.0")),
+        ],
+        dtype=np.float64,
+    ),
+}
+
+
+def _quat_wxyz_to_rot(q: np.ndarray) -> np.ndarray:
+    q = np.asarray(q, dtype=np.float64)
+    q = q / max(np.linalg.norm(q), 1e-12)
+    w, x, y, z = q
+    return np.array(
+        [
+            [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+            [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+            [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)],
+        ],
+        dtype=np.float64,
+    )
+
+
+def _rot_error(current: np.ndarray, target: np.ndarray) -> np.ndarray:
+    err = target @ current.T
+    return 0.5 * np.array(
+        [err[2, 1] - err[1, 2], err[0, 2] - err[2, 0], err[1, 0] - err[0, 1]],
+        dtype=np.float64,
+    )
+
+
+def _world_to_base_pos(pos_w: np.ndarray) -> np.ndarray:
+    return R_W_B.T @ (np.asarray(pos_w, dtype=np.float64) - BASE_POS_W)
+
+
+def _world_to_base_rot(rot_w: np.ndarray) -> np.ndarray:
+    return R_W_B.T @ rot_w
+
+
+@dataclass
+class PoseTarget:
+    pos_w: np.ndarray
+    rot_w: np.ndarray
+    grip: np.ndarray
+    steps: int
+    finger_xy: np.ndarray | None = None
+    finger_z: float | None = None
+    servo_obj_z: float | None = None
+    servo_target_rel_z: float | None = None
+    freeze_arm: bool = False
+    label: str = ""
+
+
+class _PiperIK:
+    def __init__(self):
+        if pin is None:
+            raise RuntimeError("pinocchio is required for solution_pca.py")
+        root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        urdf = os.path.join(root, "third_party", "Agilex-College", "piper", "handpose_det", "models", "modified_piper_without_camera.urdf")
+        if not os.path.exists(urdf):
+            urdf = os.environ.get("ATEC_PIPER_URDF", urdf)
+        self.model = pin.buildModelFromUrdf(urdf)
+        self.data = self.model.createData()
+        self.frame_id = self.model.getFrameId("gripper_base")
+        self.link7_id = self.model.getFrameId("link7")
+        self.link8_id = self.model.getFrameId("link8")
+        self._last_q = HOME_Q[:6].copy()
+
+    def fk_base(self, q6: np.ndarray):
+        q = np.concatenate([np.asarray(q6, dtype=np.float64), GRIP_OPEN])
+        pin.forwardKinematics(self.model, self.data, q)
+        pin.updateFramePlacements(self.model, self.data)
+        M = self.data.oMf[self.frame_id]
+        return M.translation.copy(), M.rotation.copy()
+
+    def solve(self, q_current8: np.ndarray, pos_w: np.ndarray, rot_w: np.ndarray) -> np.ndarray:
+        target_pos_b = _world_to_base_pos(pos_w)
+        target_rot_b = _world_to_base_rot(rot_w)
+        q6 = np.asarray(q_current8[:6], dtype=np.float64).copy()
+        if not np.all(np.isfinite(q6)):
+            q6 = self._last_q.copy()
+        for _ in range(35):
+            pos_b, rot_b = self.fk_base(q6)
+            err = np.concatenate([target_pos_b - pos_b, _rot_error(rot_b, target_rot_b)])
+            if np.linalg.norm(err[:3]) < 0.003 and np.linalg.norm(err[3:]) < 0.03:
+                break
+            J = pin.computeFrameJacobian(
+                self.model,
+                self.data,
+                np.concatenate([q6, GRIP_OPEN]),
+                self.frame_id,
+                pin.ReferenceFrame.LOCAL_WORLD_ALIGNED,
+            )[:, :6]
+            damping = 0.020
+            dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(6), err)
+            dq = np.clip(dq, -0.20, 0.20)
+            q6 = np.clip(q6 + dq, [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944], [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944])
+        # Near contact, being centimetres high is worse than a small wrist
+        # orientation error.  The successful simulator runner effectively
+        # servos the link7/link8 centre every step; this position-only cleanup
+        # gives the submit-style IK the same priority.
+        for _ in range(20):
+            pos_b, _ = self.fk_base(q6)
+            pos_err = target_pos_b - pos_b
+            if np.linalg.norm(pos_err) < 0.002:
+                break
+            J = pin.computeFrameJacobian(
+                self.model,
+                self.data,
+                np.concatenate([q6, GRIP_OPEN]),
+                self.frame_id,
+                pin.ReferenceFrame.LOCAL_WORLD_ALIGNED,
+            )[:3, :6]
+            damping = 0.012
+            dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(3), pos_err)
+            dq = np.clip(dq, -0.18, 0.18)
+            q6 = np.clip(q6 + dq, [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944], [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944])
+        self._last_q = q6.copy()
+        return q6
+
+    def step_dls(
+        self,
+        q_current8: np.ndarray,
+        pos_w: np.ndarray,
+        rot_w: np.ndarray,
+        *,
+        lambda_val: float = 0.05,
+        max_joint_delta: float = PCA_DLS_MAX_DELTA,
+        position_only: bool = False,
+    ) -> np.ndarray:
+        """One DifferentialIK-style DLS update from the current joint state.
+
+        The successful simulator runner uses IsaacLab's CartesianController,
+        which computes a small damped least-squares update from the current
+        PhysX state on every frame.  This mirrors that behavior more closely
+        than solving a full IK target and then clipping the final joint target.
+        """
+        target_pos_b = _world_to_base_pos(pos_w)
+        target_rot_b = _world_to_base_rot(rot_w)
+        q6 = np.asarray(q_current8[:6], dtype=np.float64).copy()
+        if not np.all(np.isfinite(q6)):
+            q6 = self._last_q.copy()
+        q8 = np.concatenate([q6, GRIP_OPEN])
+        pos_b, rot_b = self.fk_base(q6)
+        J_full = pin.computeFrameJacobian(
+            self.model,
+            self.data,
+            q8,
+            self.frame_id,
+            pin.ReferenceFrame.LOCAL_WORLD_ALIGNED,
+        )[:, :6]
+        if position_only:
+            err = target_pos_b - pos_b
+            J = J_full[:3, :]
+        else:
+            err = np.concatenate([target_pos_b - pos_b, _rot_error(rot_b, target_rot_b)])
+            J = J_full
+        damping = float(lambda_val)
+        dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(J.shape[0]), err)
+        dq = np.clip(dq, -max_joint_delta, max_joint_delta)
+        q6 = np.clip(
+            q6 + dq,
+            [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944],
+            [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944],
+        )
+        self._last_q = q6.copy()
+        return q6
+
+    def finger_center_world(self, q_current8: np.ndarray) -> np.ndarray:
+        q = np.asarray(q_current8, dtype=np.float64).copy()
+        pin.forwardKinematics(self.model, self.data, q)
+        pin.updateFramePlacements(self.model, self.data)
+        p7 = self.data.oMf[self.link7_id].translation
+        p8 = self.data.oMf[self.link8_id].translation
+        center_b = 0.5 * (p7 + p8)
+        return BASE_POS_W + R_W_B @ center_b
+
+    def finger_gap(self, q_current8: np.ndarray) -> float:
+        q = np.asarray(q_current8, dtype=np.float64).copy()
+        pin.forwardKinematics(self.model, self.data, q)
+        pin.updateFramePlacements(self.model, self.data)
+        p7 = self.data.oMf[self.link7_id].translation
+        p8 = self.data.oMf[self.link8_id].translation
+        return float(np.linalg.norm(p7 - p8))
+
+    def solve_finger(self, q_current8: np.ndarray, finger_w: np.ndarray, rot_w: np.ndarray) -> np.ndarray:
+        """IK on the actual link7/link8 centre, not the gripper_base proxy."""
+        target_pos_b = _world_to_base_pos(finger_w)
+        target_rot_b = _world_to_base_rot(rot_w)
+        q_current8 = np.asarray(q_current8, dtype=np.float64).copy()
+        q6 = q_current8[:6].copy()
+        grip = q_current8[6:8].copy()
+        if not np.all(np.isfinite(q6)):
+            q6 = self._last_q.copy()
+        for _ in range(40):
+            q8 = np.concatenate([q6, grip])
+            pin.forwardKinematics(self.model, self.data, q8)
+            pin.updateFramePlacements(self.model, self.data)
+            p7 = self.data.oMf[self.link7_id].translation
+            p8 = self.data.oMf[self.link8_id].translation
+            center_b = 0.5 * (p7 + p8)
+            gb_rot = self.data.oMf[self.frame_id].rotation
+            pos_err = target_pos_b - center_b
+            rot_err = _rot_error(gb_rot, target_rot_b)
+            if np.linalg.norm(pos_err) < 0.002 and np.linalg.norm(rot_err) < 0.05:
+                break
+            J7 = pin.computeFrameJacobian(self.model, self.data, q8, self.link7_id, pin.ReferenceFrame.LOCAL_WORLD_ALIGNED)[:3, :6]
+            J8 = pin.computeFrameJacobian(self.model, self.data, q8, self.link8_id, pin.ReferenceFrame.LOCAL_WORLD_ALIGNED)[:3, :6]
+            Jpos = 0.5 * (J7 + J8)
+            Jrot = pin.computeFrameJacobian(self.model, self.data, q8, self.frame_id, pin.ReferenceFrame.LOCAL_WORLD_ALIGNED)[3:, :6]
+            rot_wt = 0.05
+            J = np.vstack([Jpos, rot_wt * Jrot])
+            err = np.concatenate([pos_err, rot_wt * rot_err])
+            damping = 0.018
+            dq = J.T @ np.linalg.solve(J @ J.T + damping * damping * np.eye(6), err)
+            dq = np.clip(dq, -PCA_FINGER_IK_MAX_DELTA, PCA_FINGER_IK_MAX_DELTA)
+            q6 = np.clip(q6 + dq, [-2.618, 0.0, -2.967, -1.745, -1.22, -2.0944], [2.618, 3.14, 0.0, 1.745, 1.22, 2.0944])
+        self._last_q = q6.copy()
+        return q6
+
+
+class AlgSolution:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.ik = _PiperIK()
+        self.reset()
+
+    def reset(self, **_kwargs):
+        self.t = 0
+        self.home_count = 0
+        self.plan: list[PoseTarget] = []
+        self.plan_idx = 0
+        self.step_in_target = 0
+        self.detected = False
+        self.fallback_done = False
+        self.objects: tuple[int, ...] = ()
+        self._last_action = np.zeros(8, dtype=np.float64)
+        self._obj1_hold_grip: np.ndarray | None = None
+        self._obj3_hold_grip: np.ndarray | None = None
+        self._obj3_carry_offset_xy: np.ndarray | None = None
+        self._detected_centers: dict[int, np.ndarray] = {}
+
+    def reset_episode(self):
+        self.reset()
+
+    def _obs_qpos(self, obs: dict) -> np.ndarray:
+        proprio = obs["proprio"]
+        if isinstance(proprio, torch.Tensor):
+            p = proprio.detach().cpu().numpy()[0]
+        else:
+            p = np.asarray(proprio)[0]
+        return p[:8].astype(np.float64) + DEFAULT_Q
+
+    def _video_rgb_depth(self, obs: dict) -> tuple[np.ndarray, np.ndarray]:
+        rgb = obs["image"]["video_rgb"]
+        if isinstance(rgb, torch.Tensor):
+            rgb_arr = rgb.detach().cpu().numpy()[0]
+        else:
+            rgb_arr = np.asarray(rgb)[0]
+        if rgb_arr.ndim == 3 and rgb_arr.shape[0] in (3, 4):
+            rgb_arr = np.transpose(rgb_arr[:3], (1, 2, 0))
+        if rgb_arr.shape[-1] == 4:
+            rgb_arr = rgb_arr[..., :3]
+        if np.issubdtype(rgb_arr.dtype, np.floating):
+            rgb_arr = (rgb_arr * 255.0).clip(0, 255).astype(np.uint8)
+
+        depth = obs["image"]["video_depth"]
+        if isinstance(depth, torch.Tensor):
+            arr = depth.detach().cpu().numpy()[0]
+        else:
+            arr = np.asarray(depth)[0]
+        if arr.ndim == 3:
+            arr = arr[..., 0]
+        return rgb_arr.astype(np.uint8, copy=False), arr.astype(np.float64)
+
+    def _points_for_object(
+        self,
+        rgb: np.ndarray,
+        depth: np.ndarray,
+        obj_idx: int,
+        *,
+        wide: bool = False,
+        fill_holes: bool = True,
+    ) -> np.ndarray:
+        h, w = depth.shape
+        ys, xs = np.where(np.isfinite(depth) & (depth > 0.0) & (depth < 6.0))
+        if len(xs) == 0:
+            return np.zeros((0, 3), dtype=np.float64)
+        z = depth[ys, xs]
+        x = (xs.astype(np.float64) - K_VIDEO[0, 2]) / K_VIDEO[0, 0] * z
+        y = (ys.astype(np.float64) - K_VIDEO[1, 2]) / K_VIDEO[1, 1] * z
+        pts_cam = np.stack([x, y, z], axis=1)
+        rot_w_cam = _quat_wxyz_to_rot(CAM_QUAT_WXYZ)
+        pts = (rot_w_cam @ pts_cam.T).T + CAM_POS_W
+        y0, y1 = OBJ_Y_BANDS[obj_idx]
+        if wide:
+            y0 = BASKET_CENTER_Y - 0.10
+            y1 = OBJ_Y_BANDS[obj_idx][1] + (0.045 if obj_idx == 3 else 0.10)
+        z0, z1 = OBJ_Z_LIMITS[obj_idx]
+        if wide:
+            z0 = TABLE_TOP_Z + 0.005
+            if obj_idx == 3:
+                z1 = TABLE_TOP_Z + 0.220
+        rgb_pts = rgb[ys, xs].astype(np.float32)
+        maxc = rgb_pts.max(axis=1)
+        minc = rgb_pts.min(axis=1)
+        non_gray = ((maxc - minc) > 18.0) | (maxc > 170.0)
+        if obj_idx == 3:
+            # Use the banana's yellow appearance for dynamic tracking.  The broad
+            # world band can include the pink basket, white gripper, and mustard;
+            # a simple color gate is more reliable than generic non-gray there.
+            r, g, b = rgb_pts[:, 0], rgb_pts[:, 1], rgb_pts[:, 2]
+            non_gray = (r > 105.0) & (g > 75.0) & (b < 130.0) & ((r - b) > 35.0)
+        keep = (
+            (pts[:, 0] >= TABLE_CENTER_X - 0.18)
+            & (pts[:, 0] <= TABLE_CENTER_X + 0.18)
+            & (pts[:, 1] >= y0 - 0.035)
+            & (pts[:, 1] <= y1 + 0.035)
+            & (pts[:, 2] >= z0)
+            & (pts[:, 2] <= z1)
+            & non_gray
+        )
+        if np.count_nonzero(keep) == 0:
+            return pts[keep]
+        if not fill_holes:
+            return pts[keep]
+        # Mirror rgbd_band_object_mask(): fill shallow holes inside the detected
+        # component ROI, still constrained by the legal world band and z gate.
+        yy = ys[keep]
+        xx = xs[keep]
+        x1, x2 = int(xx.min()), int(xx.max())
+        y1p, y2p = int(yy.min()), int(yy.max())
+        in_roi = (xs >= x1) & (xs <= x2) & (ys >= y1p) & (ys <= y2p)
+        fill_keep = (
+            in_roi
+            & (pts[:, 0] >= TABLE_CENTER_X - 0.18)
+            & (pts[:, 0] <= TABLE_CENTER_X + 0.18)
+            & (pts[:, 1] >= y0 - 0.035)
+            & (pts[:, 1] <= y1 + 0.035)
+            & (pts[:, 2] >= z0)
+            & (pts[:, 2] <= z1)
+        )
+        return pts[fill_keep]
+
+    def _estimate_grasp(self, rgb: np.ndarray, depth: np.ndarray, obj_idx: int, *, wide: bool = False) -> tuple[np.ndarray, np.ndarray]:
+        pts = self._points_for_object(rgb, depth, obj_idx, wide=wide, fill_holes=(obj_idx != 1))
+        if len(pts) < 64:
+            # Spawn-band fallback keeps the controller alive if one frame is bad.
+            y0, y1 = OBJ_Y_BANDS[obj_idx]
+            center = np.array([TABLE_CENTER_X, 0.5 * (y0 + y1), TABLE_TOP_Z + 0.06], dtype=np.float64)
+            return center, _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
+        center = pts.mean(axis=0)
+        world_aabb_center = 0.5 * (pts.min(axis=0) + pts.max(axis=0))
+        cov = (pts - center).T @ (pts - center) / max(len(pts) - 1, 1)
+        vals, vecs = np.linalg.eigh(cov)
+        order = np.argsort(vals)[::-1]
+        axes = vecs[:, order]
+        if np.linalg.det(axes) < 0:
+            axes[:, 2] *= -1
+        local = (axes.T @ (pts - center).T).T
+        mn, mx = local.min(axis=0), local.max(axis=0)
+        aabb_center = axes @ ((mn + mx) * 0.5) + center
+        extents = mx - mn
+        if obj_idx == 3:
+            exec_center = aabb_center.copy()
+            # The banana is curved; when the visible PCA/AABB centre drifts
+            # toward the far end of the crescent, the calibrated -X finger
+            # offset is cancelled and the gripper closes on the outside.  In
+            # that case the RGB-D point mean is a better proxy for the contact
+            # root used by the successful runner traces.
+            if abs(float(aabb_center[0] - center[0])) > float(os.environ.get("ATEC_PCA_OBJ3_AABB_MEAN_X_SWITCH", "0.025")):
+                exec_center[0] = center[0] + float(os.environ.get("ATEC_PCA_OBJ3_MEAN_X_BIAS", "0.005"))
+        else:
+            upper = pts[pts[:, 2] >= np.percentile(pts[:, 2], 70)]
+            # Object 1/2 visible-surface medians can be biased toward the
+            # camera-facing side by 2+ cm.  Use the world AABB centre for XY
+            # completion, while keeping a high visible-surface z for approach.
+            exec_center = world_aabb_center.copy()
+            z_src = upper if len(upper) else pts
+            exec_center[2] = float(np.percentile(z_src[:, 2], 85))
+        if os.environ.get("ATEC_PCA_DEBUG_TARGET"):
+            upper = pts[pts[:, 2] >= np.percentile(pts[:, 2], 70)]
+            upper_med = np.median(upper if len(upper) else pts, axis=0)
+            print(
+                f"[PCA_EST] obj={obj_idx} n={len(pts)} "
+                f"mean=({center[0]:.3f},{center[1]:.3f},{center[2]:.3f}) "
+                f"world_aabb=({world_aabb_center[0]:.3f},{world_aabb_center[1]:.3f},{world_aabb_center[2]:.3f}) "
+                f"upper_med=({upper_med[0]:.3f},{upper_med[1]:.3f},{upper_med[2]:.3f}) "
+                f"exec=({exec_center[0]:.3f},{exec_center[1]:.3f},{exec_center[2]:.3f})",
+                flush=True,
+            )
+
+        grasp_axis = int(np.argmin(extents))
+        if grasp_axis == 0:
+            jaw_hint_w = axes[:, 1]
+        else:
+            jaw_hint_w = axes[:, 0]
+        jaw_xy = np.array([jaw_hint_w[0], jaw_hint_w[1], 0.0], dtype=np.float64)
+        if np.linalg.norm(jaw_xy) < 1e-6:
+            jaw_xy = np.array([0.0, 1.0, 0.0], dtype=np.float64)
+        jaw_xy /= np.linalg.norm(jaw_xy)
+        grip_z = np.array([0.0, 0.0, -1.0], dtype=np.float64)
+        align_x = np.cross(jaw_xy, grip_z)
+        align_x /= max(np.linalg.norm(align_x), 1e-6)
+        jaw_y = np.cross(grip_z, align_x)
+        jaw_y /= max(np.linalg.norm(jaw_y), 1e-6)
+        rot_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1)
+        return exec_center.astype(np.float64), rot_w_tool.astype(np.float64)
+
+    def _estimate_object3_current_center(self, obs: dict) -> np.ndarray | None:
+        rgb, depth = self._video_rgb_depth(obs)
+        pts = self._points_for_object(rgb, depth, 3, wide=True, fill_holes=True)
+        if len(pts) < 64:
+            return None
+        center = 0.5 * (pts.min(axis=0) + pts.max(axis=0))
+        # Track the table-near/lifted banana body, not high gripper occluders.
+        center[2] = float(np.percentile(pts[:, 2], 65))
+        center[:2] += OBJ_CENTER_COMPLETION_OFFSETS[3]
+        if not np.all(np.isfinite(center)):
+            return None
+        if not (TABLE_CENTER_X - 0.22 <= center[0] <= TABLE_CENTER_X + 0.22):
+            return None
+        if not (BASKET_CENTER_Y - 0.14 <= center[1] <= OBJ_Y_BANDS[3][1] + 0.10):
+            return None
+        return center.astype(np.float64)
+
+    def _build_object3_drag_fallback(self, obs: dict) -> bool:
+        topdown = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
+        # Re-localize the banana at fallback time.  Use the same narrow
+        # closed-drag recovery that succeeded in run_graspnet_pick.py: keep the
+        # gripper closed and drag from the current object centre to the basket
+        # centre in two smooth segments.
+        drag_z = OBJ3_FALLBACK_DRAG_Z
+        c_live = self._estimate_object3_current_center(obs)
+        c0 = c_live if c_live is not None else self._detected_centers.get(
+            3, np.array([TABLE_CENTER_X, OBJ_Y_BANDS[3][0], TABLE_TOP_Z], dtype=np.float64)
+        )
+        start = np.array([c0[0], c0[1], drag_z], dtype=np.float64)
+        mid = np.array([BASKET_CENTER_X, 0.5 * (c0[1] + BASKET_CENTER_Y), drag_z], dtype=np.float64)
+        end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y, drag_z], dtype=np.float64)
+        print(
+            f"[PCA_FALLBACK] object_3 closed_drag cur=({c0[0]:.3f},{c0[1]:.3f},{c0[2]:.3f}) "
+            f"mid=({mid[0]:.3f},{mid[1]:.3f},{mid[2]:.3f}) "
+            f"end=({end[0]:.3f},{end[1]:.3f},{end[2]:.3f})",
+            flush=True,
+        )
+        self.plan = []
+        self.plan_idx = 0
+        self.step_in_target = 0
+        hold_grip = self._obj3_hold_grip.copy() if self._obj3_hold_grip is not None else OBJ3_HOLD_GRIP_DEFAULT.copy()
+        finger_offset = OBJ_FINGER_XY_OFFSETS[3]
+        start_finger = start[:2] + finger_offset
+        mid_finger = mid[:2] + finger_offset
+        end_finger = end[:2] + finger_offset
+        self._add_pose([start_finger[0], start_finger[1], drag_z], topdown, hold_grip, OBJ3_FALLBACK_START_STEPS, finger_xy=start_finger, finger_z=drag_z, label="fallback_closed_drag_start")
+        self._add_pose([mid_finger[0], mid_finger[1], drag_z], topdown, hold_grip, OBJ3_FALLBACK_MID_STEPS, finger_xy=mid_finger, finger_z=drag_z, label="fallback_closed_drag_mid")
+        self._add_pose([end_finger[0], end_finger[1], drag_z], topdown, hold_grip, OBJ3_FALLBACK_END_STEPS, finger_xy=end_finger, finger_z=drag_z, label="fallback_closed_drag_end")
+        self._add_pose([end_finger[0], end_finger[1], drag_z], topdown, GRIP_OPEN, OBJ3_FALLBACK_OPEN_STEPS, finger_xy=end_finger, finger_z=drag_z, label="fallback_closed_drag_open")
+        self._add_pose([BASKET_CENTER_X, BASKET_CENTER_Y, TABLE_TOP_Z + 0.18], topdown, GRIP_OPEN, 120, label="fallback_retract")
+        return True
+
+    def _build_object1_drag_rescue(self, obs: dict) -> bool:
+        rgb, depth = self._video_rgb_depth(obs)
+        pts = self._points_for_object(rgb, depth, 1, wide=True, fill_holes=False)
+        if len(pts) < 64:
+            print(f"[PCA_RESCUE] skip object_1 drag: only {len(pts)} points", flush=True)
+            return False
+        # After transport failures object_1 is usually back on the table.  The
+        # high visible points can be the gripper/finger occluder or a lifted
+        # face, so estimate the rescue push centre from table-near points only.
+        low = pts[(pts[:, 2] >= TABLE_TOP_Z + 0.030) & (pts[:, 2] <= TABLE_TOP_Z + 0.110)]
+        if len(low) >= 32:
+            c = 0.5 * (low.min(axis=0) + low.max(axis=0))
+            c[2] = float(np.median(low[:, 2]))
+        else:
+            c, _ = self._estimate_grasp(rgb, depth, 1, wide=True)
+        if not np.all(np.isfinite(c)):
+            return False
+        topdown = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
+        drag_z = TABLE_TOP_Z + 0.055
+        # Push from the object's positive-y side toward the basket.  A fixed
+        # start_y misses the cube after ACT/hybrid rollouts because object_1
+        # often remains around y=0.26..0.34.
+        lanes_x = [
+            float(np.clip(c[0] - 0.045, TABLE_CENTER_X - 0.16, TABLE_CENTER_X + 0.22)),
+            float(np.clip(c[0], TABLE_CENTER_X - 0.16, TABLE_CENTER_X + 0.22)),
+            float(np.clip(c[0] + 0.045, TABLE_CENTER_X - 0.16, TABLE_CENTER_X + 0.22)),
+        ]
+        start_y = float(np.clip(c[1] + 0.085, TABLE_CENTER_Y + 0.085, TABLE_CENTER_Y + 0.46))
+        end_y = BASKET_CENTER_Y
+        print(
+            f"[PCA_RESCUE] object_1 drag c=({c[0]:.3f},{c[1]:.3f},{c[2]:.3f}) "
+            f"low_n={len(low)} "
+            f"lanes={','.join(f'{x:.2f}' for x in lanes_x)} y=({start_y:.3f}->{end_y:.3f})",
+            flush=True,
+        )
+        self.objects = (1,)
+        self.plan = []
+        self.plan_idx = 0
+        self.step_in_target = 0
+        for i, lane_x in enumerate(lanes_x):
+            start = np.array([lane_x, start_y, drag_z], dtype=np.float64)
+            end = np.array([lane_x, end_y, drag_z], dtype=np.float64)
+            self._add_pose([lane_x, start_y, TABLE_TOP_Z + 0.20], topdown, GRIP_OPEN, 70, label=f"obj1_rescue_lane{i}_pre")
+            self._add_pose(start, topdown, GRIP_OPEN, 100, finger_xy=start[:2], finger_z=drag_z, label=f"obj1_rescue_lane{i}_start")
+            self._add_pose(end, topdown, GRIP_OPEN, 520, finger_xy=end[:2], finger_z=drag_z, label=f"obj1_rescue_lane{i}_mid")
+        self._add_pose([BASKET_CENTER_X, BASKET_CENTER_Y, TABLE_TOP_Z + 0.15], topdown, GRIP_OPEN, 160, label="obj1_rescue_open")
+        self._add_pose([RETRACT_X, RETRACT_Y, TABLE_TOP_Z + 0.40], topdown, GRIP_OPEN, 80, label="obj1_rescue_retract")
+        return True
+
+    def _build_plan(self, obs: dict):
+        rgb, depth = self._video_rgb_depth(obs)
+        topdown = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.0, 0.0], dtype=np.float64))
+        self.plan = []
+        objects = tuple(int(x) for x in os.environ.get("ATEC_PCA_OBJECTS", "3,2,1").replace(" ", ",").split(",") if x)
+        self.objects = objects
+        for obj_idx in objects:
+            c, grasp_rot = self._estimate_grasp(rgb, depth, obj_idx)
+            if obj_idx == 1:
+                grasp_rot = _quat_wxyz_to_rot(np.array([0.0, 0.709, 0.705, 0.0], dtype=np.float64))
+            # The submit-style RGB-D PCA estimate is biased toward the visible
+            # left crescent of the banana.  Keep GraspGen/PCA for its centre,
+            # but use the task-calibrated top-down wrist pose that the runner
+            # already validated for object_3.
+            if obj_idx == 3 and os.environ.get("ATEC_PCA_OBJ3_USE_PCA_ROT") != "1":
+                grasp_rot = _quat_wxyz_to_rot(np.array([0.0, 1.0, 0.004, 0.0], dtype=np.float64))
+            c[:2] += OBJ_CENTER_COMPLETION_OFFSETS[obj_idx]
+            self._detected_centers[obj_idx] = c.copy()
+            pick_xy = c[:2] + OBJ_GRASP_CENTER_OFFSETS[obj_idx]
+            yaw = float(np.arctan2(grasp_rot[1, 1], grasp_rot[0, 1]))
+            print(
+                f"[PCA_PLAN] obj={obj_idx} center=({c[0]:.3f},{c[1]:.3f},{c[2]:.3f}) "
+                f"pick=({pick_xy[0]:.3f},{pick_xy[1]:.3f}) jaw_yaw={yaw:+.2f}",
+                flush=True,
+            )
+            reach_z = max(float(c[2] + OBJ_TCP_Z[obj_idx]), TABLE_TOP_Z + 0.055)
+            # The PCA point cloud z is a visible-surface estimate, not the USD
+            # object root z used by the validated runner.  Closing from
+            # c[2]+offset is too high for object_1 and makes the gripper miss
+            # the cube.  Use the calibrated task close plane instead.
+            root_z_est = OBJ_ROOT_Z_EST.get(obj_idx, TABLE_TOP_Z + 0.045)
+            close_z = max(root_z_est + OBJ_CLOSE_Z_OFFSETS.get(obj_idx, 0.020), TABLE_TOP_Z + 0.030)
+            lift_z = TABLE_TOP_Z + (OBJ3_LIFT_CLEARANCE if obj_idx == 3 else 0.30)
+            release_z = TABLE_TOP_Z + (OBJ3_CARRY_CLEARANCE if obj_idx == 3 else (0.32 if obj_idx == 1 else 0.24))
+            open_z = TABLE_TOP_Z + (OBJ3_CARRY_CLEARANCE if obj_idx == 3 else (0.24 if obj_idx == 1 else 0.15))
+            place_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y]) + OBJ_PLACE_XY_OFFSETS.get(
+                obj_idx, np.zeros(2, dtype=np.float64)
+            )
+            # Keep the calibrated top-down task quaternion for all objects.  The
+            # PCA/AABB centre supplies translation; Task-E contact tuning supplies
+            # the wrist orientation and release heights.
+            finger_xy = pick_xy.copy() + OBJ_FINGER_XY_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64)) if obj_idx in (1, 2, 3) else None
+            close_finger_xy = (
+                pick_xy
+                + OBJ_PRECLOSE_INSERT_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64))
+                + OBJ_FINGER_XY_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64))
+            )
+            closed_grip = OBJ3_HOLD_GRIP_DEFAULT.copy() if obj_idx == 3 else GRIP_CLOSE
+            finger_z = reach_z if obj_idx in (1, 2) else None
+            place_rot = grasp_rot if obj_idx in (1, 2) else topdown
+            self._add_pose([pick_xy[0], pick_xy[1], TABLE_TOP_Z + 0.30], grasp_rot, GRIP_OPEN, 90, label=f"obj{obj_idx}_pre")
+            servo_rel_z = OBJ_FINGER_TARGET_REL_Z.get(obj_idx)
+            if obj_idx == 3 and OBJ3_ENABLE_INSERT:
+                # Diagnostic-only guarded side approach.  Local tests showed
+                # low open-finger insertion can shove the banana laterally, so
+                # the default path below matches the successful GraspNet runner:
+                # reach the calibrated contact point first, then close there.
+                side_finger_xy = close_finger_xy + OBJ3_PREGRASP_OFFSET
+                self._add_pose(
+                    [side_finger_xy[0], side_finger_xy[1], reach_z],
+                    grasp_rot,
+                    GRIP_OPEN,
+                    OBJ3_SIDE_APPROACH_STEPS,
+                    finger_xy=side_finger_xy,
+                    finger_z=OBJ3_APPROACH_FINGER_Z,
+                    servo_obj_z=root_z_est,
+                    servo_target_rel_z=None,
+                    label=f"obj{obj_idx}_side_pre",
+                )
+                self._add_pose(
+                    [side_finger_xy[0], side_finger_xy[1], close_z],
+                    grasp_rot,
+                    GRIP_OPEN,
+                    OBJ3_SIDE_LOW_STEPS,
+                    finger_xy=side_finger_xy,
+                    finger_z=OBJ3_PREGRASP_LOW_FINGER_Z,
+                    servo_obj_z=root_z_est,
+                    servo_target_rel_z=None,
+                    label=f"obj{obj_idx}_side_low",
+                )
+                self._add_pose(
+                    [close_finger_xy[0], close_finger_xy[1], close_z],
+                    grasp_rot,
+                    GRIP_OPEN,
+                    OBJ3_INSERT_STEPS,
+                    finger_xy=close_finger_xy,
+                    finger_z=OBJ3_PREGRASP_LOW_FINGER_Z,
+                    servo_obj_z=root_z_est,
+                    servo_target_rel_z=None,
+                    label=f"obj{obj_idx}_insert",
+                )
+            else:
+                self._add_pose(
+                    [pick_xy[0], pick_xy[1], reach_z],
+                    grasp_rot,
+                    GRIP_OPEN,
+                    OBJ_REACH_STEPS[obj_idx],
+                    finger_xy=finger_xy,
+                    finger_z=None,
+                    servo_obj_z=root_z_est,
+                    servo_target_rel_z=None,
+                    label=f"obj{obj_idx}_reach",
+                )
+            if obj_idx != 3 and np.linalg.norm(OBJ_PRECLOSE_INSERT_OFFSETS.get(obj_idx, np.zeros(2, dtype=np.float64))) > 1e-6:
+                self._add_pose(
+                    [close_finger_xy[0], close_finger_xy[1], close_z],
+                    grasp_rot,
+                    GRIP_OPEN,
+                    180,
+                    finger_xy=close_finger_xy,
+                    finger_z=None,
+                    servo_obj_z=root_z_est,
+                    servo_target_rel_z=servo_rel_z,
+                    label=f"obj{obj_idx}_insert",
+                )
+            obj3_finger_z = OBJ3_CLOSE_FINGER_Z if obj_idx == 3 else None
+            self._add_pose(
+                [close_finger_xy[0], close_finger_xy[1], close_z],
+                grasp_rot,
+                closed_grip,
+                OBJ_CLOSE_STEPS[obj_idx],
+                finger_xy=close_finger_xy,
+                finger_z=obj3_finger_z,
+                servo_obj_z=root_z_est,
+                servo_target_rel_z=None if obj_idx == 3 else servo_rel_z,
+                label=f"obj{obj_idx}_close",
+            )
+            if obj_idx == 3:
+                self._add_pose(
+                    [close_finger_xy[0], close_finger_xy[1], close_z],
+                    grasp_rot,
+                    closed_grip,
+                    OBJ3_LOW_HOLD_STEPS,
+                    finger_xy=close_finger_xy,
+                    finger_z=OBJ3_CLOSE_FINGER_Z,
+                    servo_obj_z=root_z_est,
+                    servo_target_rel_z=None,
+                    label=f"obj{obj_idx}_low_hold",
+                )
+            if obj_idx == 1:
+                self._add_pose(
+                    [close_finger_xy[0], close_finger_xy[1], close_z],
+                    grasp_rot,
+                    GRIP_CLOSE,
+                    160,
+                    finger_xy=None,
+                    finger_z=None,
+                    freeze_arm=True,
+                    label=f"obj{obj_idx}_squeeze",
+                )
+            self._add_pose(
+                [close_finger_xy[0], close_finger_xy[1], lift_z],
+                grasp_rot,
+                closed_grip,
+                OBJ_LIFT_STEPS[obj_idx],
+                finger_xy=close_finger_xy,
+                finger_z=OBJ3_LIFT_FINGER_Z if obj_idx == 3 else None,
+                servo_obj_z=None if obj_idx == 3 else root_z_est,
+                servo_target_rel_z=None if obj_idx == 3 else servo_rel_z,
+                label=f"obj{obj_idx}_lift",
+            )
+            if obj_idx == 3:
+                # After a short lift confirms contact, do not keep a high-air
+                # friction grasp.  Banana is contact-sensitive in official
+                # physics; a low closed-drag/cradle path preserves contact and
+                # avoids the DLS high-transport singularity seen in videos.
+                drag_z = OBJ3_FALLBACK_DRAG_Z
+                drag_start_finger = close_finger_xy.copy()
+                drag_mid_obj = np.array([BASKET_CENTER_X, 0.5 * (pick_xy[1] + BASKET_CENTER_Y)], dtype=np.float64)
+                drag_end_obj = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64)
+                drag_mid_finger = drag_mid_obj + OBJ_FINGER_XY_OFFSETS[3]
+                drag_end_finger = drag_end_obj + OBJ_FINGER_XY_OFFSETS[3]
+                self._add_pose(
+                    [drag_start_finger[0], drag_start_finger[1], drag_z],
+                    topdown,
+                    closed_grip,
+                    OBJ3_DRAG_START_STEPS,
+                    finger_xy=drag_start_finger,
+                    finger_z=drag_z,
+                    label=f"obj{obj_idx}_drag_start",
+                )
+                self._add_pose(
+                    [drag_mid_finger[0], drag_mid_finger[1], drag_z],
+                    topdown,
+                    closed_grip,
+                    OBJ3_DRAG_MID_STEPS,
+                    finger_xy=drag_mid_finger,
+                    finger_z=drag_z,
+                    label=f"obj{obj_idx}_drag_mid",
+                )
+                self._add_pose(
+                    [drag_end_finger[0], drag_end_finger[1], drag_z],
+                    topdown,
+                    closed_grip,
+                    OBJ3_DRAG_END_STEPS,
+                    finger_xy=drag_end_finger,
+                    finger_z=drag_z,
+                    label=f"obj{obj_idx}_drag_end",
+                )
+                self._add_pose(
+                    [drag_end_finger[0], drag_end_finger[1], drag_z],
+                    topdown,
+                    closed_grip,
+                    OBJ3_DRAG_SETTLE_STEPS,
+                    finger_xy=drag_end_finger,
+                    finger_z=drag_z,
+                    label=f"obj{obj_idx}_drag_settle",
+                )
+                self._add_pose(
+                    [drag_end_finger[0], drag_end_finger[1], drag_z],
+                    topdown,
+                    GRIP_OPEN,
+                    OBJ_OPEN_STEPS[obj_idx],
+                    finger_xy=drag_end_finger,
+                    finger_z=drag_z,
+                    label=f"obj{obj_idx}_drag_open",
+                )
+                self._add_pose([RETRACT_X, RETRACT_Y, TABLE_TOP_Z + 0.40], topdown, GRIP_OPEN, 80, label=f"obj{obj_idx}_retract")
+                continue
+            mid = np.array([(close_finger_xy[0] + place_xy[0]) * 0.5, (close_finger_xy[1] + place_xy[1]) * 0.5, release_z])
+            if obj_idx == 3:
+                carry_mid_finger = mid[:2] + OBJ_FINGER_XY_OFFSETS[3]
+                release_finger = place_xy + OBJ_FINGER_XY_OFFSETS[3]
+            else:
+                carry_mid_finger = mid[:2] if obj_idx in (1, 2) else None
+                release_finger = place_xy if obj_idx in (1, 2) else None
+            carry_finger_z = OBJ3_LIFT_FINGER_Z if obj_idx == 3 else None
+            self._add_pose(
+                mid,
+                place_rot,
+                closed_grip,
+                max(OBJ_TRANSPORT_STEPS[obj_idx] // 2, 1),
+                finger_xy=carry_mid_finger,
+                finger_z=carry_finger_z,
+                label=f"obj{obj_idx}_mid",
+            )
+            if obj_idx == 1:
+                self._add_pose(
+                    mid,
+                    place_rot,
+                    GRIP_CLOSE,
+                    140,
+                    freeze_arm=True,
+                    label=f"obj{obj_idx}_mid_squeeze",
+                )
+            self._add_pose(
+                [place_xy[0], place_xy[1], release_z],
+                place_rot,
+                closed_grip,
+                max(OBJ_TRANSPORT_STEPS[obj_idx] - OBJ_TRANSPORT_STEPS[obj_idx] // 2, 1),
+                finger_xy=release_finger,
+                finger_z=carry_finger_z,
+                label=f"obj{obj_idx}_release",
+            )
+            if obj_idx == 3:
+                # Match the runner's basket-hold phase: keep the gripper closed
+                # above the release pose while the object centre is servoed into
+                # the real basket centre before opening.
+                self._add_pose(
+                    [place_xy[0], place_xy[1], release_z],
+                    place_rot,
+                    closed_grip,
+                    420,
+                    finger_xy=release_finger,
+                    finger_z=carry_finger_z,
+                    label=f"obj{obj_idx}_basket_hold",
+                )
+            if obj_idx == 1 and os.environ.get("ATEC_PCA_ENABLE_OBJ1_RESCUE") == "1":
+                self._add_pose([place_xy[0], place_xy[1], release_z], place_rot, GRIP_CLOSE, 1, label="obj1_relocalize_drag")
+            settle_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64) if obj_idx == 1 else place_xy
+            settle_finger = release_finger if obj_idx == 3 else (settle_xy if obj_idx in (1, 2) else None)
+            self._add_pose([settle_xy[0], settle_xy[1], open_z], place_rot, closed_grip, 80 if obj_idx != 3 else 120, finger_xy=settle_finger, label=f"obj{obj_idx}_settle")
+            self._add_pose([settle_xy[0], settle_xy[1], open_z], place_rot, GRIP_OPEN, OBJ_OPEN_STEPS[obj_idx], label=f"obj{obj_idx}_open")
+            self._add_pose([RETRACT_X, RETRACT_Y, TABLE_TOP_Z + 0.40], topdown, GRIP_OPEN, 80, label=f"obj{obj_idx}_retract")
+        self.detected = True
+
+    def _add_pose(
+        self,
+        pos,
+        rot,
+        grip,
+        steps,
+        finger_xy=None,
+        finger_z=None,
+        servo_obj_z=None,
+        servo_target_rel_z=None,
+        freeze_arm=False,
+        label="",
+    ):
+        if int(steps) <= 0:
+            return
+        self.plan.append(
+            PoseTarget(
+                np.asarray(pos, dtype=np.float64),
+                np.asarray(rot, dtype=np.float64),
+                np.asarray(grip, dtype=np.float64),
+                int(steps),
+                None if finger_xy is None else np.asarray(finger_xy, dtype=np.float64),
+                None if finger_z is None else float(finger_z),
+                None if servo_obj_z is None else float(servo_obj_z),
+                None if servo_target_rel_z is None else float(servo_target_rel_z),
+                bool(freeze_arm),
+                str(label),
+            )
+        )
+
+    def predicts(self, obs, current_score):
+        qpos = self._obs_qpos(obs)
+        if self.t < 25:
+            self.t += 1
+            return {"action": np.zeros((1, 8), dtype=np.float32).tolist(), "giveup": False}
+        if self.home_count < 80:
+            self.home_count += 1
+            action = np.clip((HOME_Q - DEFAULT_Q) / ACTION_SCALE, -3.0, 3.0)
+            return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
+        if not self.detected:
+            if (
+                os.environ.get("ATEC_PCA_OBJ1_DIRECT_RESCUE") == "1"
+                and tuple(int(x) for x in os.environ.get("ATEC_PCA_OBJECTS", "3,2,1").replace(" ", ",").split(",") if x) == (1,)
+                and self._build_object1_drag_rescue(obs)
+            ):
+                self.detected = True
+            else:
+                self._build_plan(obs)
+        if self.plan_idx >= len(self.plan):
+            if (
+                not self.fallback_done
+                and 3 in self.objects
+                and os.environ.get("ATEC_PCA_ENABLE_FALLBACK") == "1"
+            ):
+                self.fallback_done = True
+                if self._build_object3_drag_fallback(obs):
+                    target = self.plan[self.plan_idx]
+                    pos_w = target.pos_w.copy()
+                else:
+                    action = np.clip((HOME_Q - DEFAULT_Q) / ACTION_SCALE, -3.0, 3.0)
+                    return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
+            else:
+                action = np.clip((HOME_Q - DEFAULT_Q) / ACTION_SCALE, -3.0, 3.0)
+                return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
+        else:
+            target = self.plan[self.plan_idx]
+            pos_w = target.pos_w.copy()
+        if target.label == "obj1_relocalize_drag":
+            if self._build_object1_drag_rescue(obs):
+                target = self.plan[self.plan_idx]
+                pos_w = target.pos_w.copy()
+            else:
+                self.plan_idx += 1
+                return {"action": np.zeros((1, 8), dtype=np.float32).tolist(), "giveup": False}
+        raw_pos_w = pos_w.copy()
+        dynamic_finger_xy = None
+        finger_target_w = None
+        if target.label in ("obj3_basket_hold", "obj3_settle") and os.environ.get(
+            "ATEC_PCA_OBJ3_OBJECT_SERVO", "1"
+        ) != "0":
+            c_now = self._estimate_object3_current_center(obs)
+            if c_now is not None:
+                if self._obj3_carry_offset_xy is None:
+                    finger_now = self.ik.finger_center_world(qpos)
+                    observed_offset = finger_now[:2] - c_now[:2]
+                    # Preserve the actual contact relation reached at lift,
+                    # but bound it so a bad visual frame cannot launch the arm.
+                    observed_offset = np.clip(observed_offset, [-0.055, -0.055], [0.055, 0.055])
+                    if np.all(np.isfinite(observed_offset)):
+                        self._obj3_carry_offset_xy = observed_offset.astype(np.float64)
+                carry_offset = (
+                    self._obj3_carry_offset_xy
+                    if self._obj3_carry_offset_xy is not None
+                    else OBJ_FINGER_XY_OFFSETS[3]
+                )
+                object_target_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64)
+                correction = np.zeros(2, dtype=np.float64)
+                correction = (object_target_xy - c_now[:2]) * OBJ3_OBJECT_SERVO_GAIN
+                corr_norm = float(np.linalg.norm(correction))
+                max_corr = OBJ3_OBJECT_SERVO_MAX_XY
+                if corr_norm > max_corr:
+                    correction = correction / max(corr_norm, 1e-6) * max_corr
+                pos_w[:2] = raw_pos_w[:2] + correction
+                raw_pos_w = pos_w.copy()
+                # Keep the same finger-to-object contact relation while
+                # servoing the object centre into the basket.  Pointing the
+                # finger target at c_now pins the hand near the old table pose
+                # and fights the basket correction.
+                dynamic_finger_xy = object_target_xy + carry_offset
+                if (
+                    os.environ.get("ATEC_PCA_ENABLE_FALLBACK") == "1"
+                    and
+                    os.environ.get("ATEC_PCA_OBJ3_DYNAMIC_FALLBACK", "1") != "0"
+                    and not self.fallback_done
+                    and target.label in ("obj3_mid", "obj3_release", "obj3_basket_hold")
+                    and c_now[1] > BASKET_CENTER_Y + 0.16
+                    and c_now[2] < TABLE_TOP_Z + 0.045
+                    and self.step_in_target > 80
+                ):
+                    self.fallback_done = True
+                    print(
+                        f"[PCA_FALLBACK_TRIGGER] object_3 stalled c=({c_now[0]:.3f},{c_now[1]:.3f},{c_now[2]:.3f}) "
+                        f"target={target.label} step={self.step_in_target}",
+                        flush=True,
+                    )
+                    if self._build_object3_drag_fallback(obs):
+                        target = self.plan[self.plan_idx]
+                        pos_w = target.pos_w.copy()
+                        raw_pos_w = pos_w.copy()
+                        dynamic_finger_xy = None
+                if os.environ.get("ATEC_PCA_DEBUG_TARGET") and self.step_in_target % 25 == 0:
+                    print(
+                        f"[PCA_OBJ_SERVO] {target.label} c=({c_now[0]:.3f},{c_now[1]:.3f}) "
+                        f"target=({object_target_xy[0]:.3f},{object_target_xy[1]:.3f}) "
+                        f"corr=({correction[0]:+.3f},{correction[1]:+.3f})",
+                        flush=True,
+                    )
+        if target.finger_xy is not None:
+            finger = self.ik.finger_center_world(qpos)
+            gb_b, _ = self.ik.fk_base(qpos[:6])
+            gb_w = BASE_POS_W + R_W_B @ gb_b
+            finger_from_gb = finger - gb_w
+            desired_finger_xy = target.finger_xy if dynamic_finger_xy is None else dynamic_finger_xy
+            finger_target_z = target.finger_z if target.finger_z is not None else finger[2]
+            finger_target_w = np.array([desired_finger_xy[0], desired_finger_xy[1], finger_target_z], dtype=np.float64)
+            xy_error = finger[:2] - desired_finger_xy
+            correction = -xy_error
+            corr_norm = float(np.linalg.norm(correction))
+            max_xy = 0.12
+            if target.label.startswith("obj3_") and (
+                ("_mid" in target.label)
+                or ("_release" in target.label)
+                or ("_basket_hold" in target.label)
+                or ("_settle" in target.label)
+                or ("_drag" in target.label)
+            ):
+                max_xy = OBJ3_FINGER_SERVO_MAX_XY
+            elif ("_mid" in target.label) or ("_release" in target.label) or ("_settle" in target.label):
+                max_xy = 0.32
+            if corr_norm > max_xy:
+                correction = correction / max(corr_norm, 1e-6) * max_xy
+            pos_w[:2] = raw_pos_w[:2] + correction
+            if target.finger_z is not None:
+                pos_w[2] = float(target.finger_z - finger_from_gb[2])
+            elif target.servo_obj_z is not None and target.servo_target_rel_z is not None:
+                rel_z = float(finger[2] - target.servo_obj_z)
+                z_error = float(target.servo_target_rel_z - rel_z)
+                obj_for_label = 3 if target.label.startswith("obj3_") else 1
+                max_z = OBJ_FINGER_SERVO_MAX_Z.get(obj_for_label, 0.050)
+                if obj_for_label == 3:
+                    z_correction = float(np.clip(z_error, -max_z, max_z))
+                else:
+                    z_correction = min(0.0, max(-max_z, z_error))
+                pos_w[2] = float(raw_pos_w[2] + z_correction)
+            if os.environ.get("ATEC_PCA_DEBUG_TARGET") and self.step_in_target % 25 == 0:
+                print(
+                    f"[PCA_TARGET] plan={self.plan_idx} step={self.step_in_target} "
+                    f"raw=({raw_pos_w[0]:.3f},{raw_pos_w[1]:.3f},{raw_pos_w[2]:.3f}) "
+                    f"gb=({gb_w[0]:.3f},{gb_w[1]:.3f},{gb_w[2]:.3f}) "
+                    f"finger=({finger[0]:.3f},{finger[1]:.3f},{finger[2]:.3f}) "
+                    f"desired=({desired_finger_xy[0]:.3f},{desired_finger_xy[1]:.3f}) "
+                    f"pos=({pos_w[0]:.3f},{pos_w[1]:.3f},{pos_w[2]:.3f})",
+                    flush=True,
+                )
+        # Use a submit-side equivalent of the runner's CartesianController:
+        # one DLS update from the current qpos per simulator step.  Close/reach
+        # phases prioritize position because centimetres of z error are enough
+        # to miss the object, while a small wrist error is tolerable.
+        position_only = (
+            ("_reach" in target.label)
+            or ("_side_pre" in target.label)
+            or ("_side_low" in target.label)
+            or ("_insert" in target.label)
+            or ("_close" in target.label)
+            or ("_low_hold" in target.label)
+            or (target.label.startswith("obj3_") and any(key in target.label for key in ("drag", "mid", "release", "basket_hold", "settle")))
+        )
+        if target.freeze_arm:
+            q6 = qpos[:6].copy()
+        elif (
+            finger_target_w is not None
+            and (
+                (
+                    target.label.startswith("fallback_")
+                    and os.environ.get("ATEC_PCA_FALLBACK_FINGER_IK", "0") != "0"
+                )
+                or (
+                    target.label.startswith("obj3_")
+                    and os.environ.get("ATEC_PCA_OBJ3_USE_FINGER_IK", "0") == "1"
+                    and any(key in target.label for key in ("mid", "release", "basket_hold", "settle"))
+                )
+            )
+        ):
+            q6 = self.ik.solve_finger(qpos, finger_target_w, target.rot_w)
+        elif os.environ.get("ATEC_PCA_USE_FULL_IK") == "1":
+            q6 = self.ik.solve(qpos, pos_w, target.rot_w)
+        else:
+            q6 = self.ik.step_dls(qpos, pos_w, target.rot_w, position_only=position_only)
+        q_target = np.concatenate([q6, target.grip])
+        if target.label.startswith("obj1_"):
+            gap = self.ik.finger_gap(qpos)
+            if (
+                self._obj1_hold_grip is None
+                and
+                target.label in ("obj1_close", "obj1_lift", "obj1_mid")
+                and gap <= OBJ1_HOLD_GAP
+                and self.step_in_target > 10
+            ):
+                self._obj1_hold_grip = qpos[6:8].copy()
+            if self._obj1_hold_grip is not None and any(
+                key in target.label for key in ("close", "squeeze", "lift", "mid", "release", "settle")
+            ):
+                q_target[6:8] = self._obj1_hold_grip
+        if target.label.startswith("obj3_"):
+            gap = self.ik.finger_gap(qpos)
+            if (
+                self._obj3_hold_grip is None
+                and target.label == "obj3_lift"
+                and gap <= OBJ3_HOLD_GAP
+                and self.step_in_target >= int(os.environ.get("ATEC_PCA_OBJ3_LIFT_LATCH_STEP", "20"))
+            ):
+                self._obj3_hold_grip = qpos[6:8].copy()
+            if self._obj3_hold_grip is not None and any(
+                key in target.label for key in ("close", "low_hold", "lift", "mid", "release", "basket_hold", "settle", "drag")
+            ):
+                q_target[6:8] = self._obj3_hold_grip
+        # Match IsaacLab CartesianController's per-step clamp; gripper fingers
+        # still close gradually so they do not shove the object sideways.
+        gripper_max_delta = 0.010
+        if target.label.startswith("obj3_") and self._obj3_hold_grip is None and any(
+            key in target.label for key in ("close", "low_hold")
+        ):
+            gripper_max_delta = OBJ3_GRIPPER_MAX_DELTA
+        max_delta = np.array(
+            [0.18, 0.18, 0.18, 0.18, 0.18, 0.18, gripper_max_delta, gripper_max_delta],
+            dtype=np.float64,
+        )
+        q_target = qpos + np.clip(q_target - qpos, -max_delta, max_delta)
+        action = np.clip((q_target - DEFAULT_Q) / ACTION_SCALE, -5.0, 5.0)
+        self.step_in_target += 1
+        advance = self.step_in_target >= target.steps
+        if target.label == "obj1_close" and self._obj1_hold_grip is not None:
+            advance = True
+        if (
+            target.label == "obj3_close"
+            and self._obj3_hold_grip is not None
+            and self.step_in_target >= OBJ3_CLOSE_MIN_STEPS
+        ):
+            advance = True
+        if "_squeeze" in target.label:
+            gap = self.ik.finger_gap(qpos)
+            if self._obj1_hold_grip is not None and target.label.startswith("obj1_"):
+                advance = self.step_in_target >= 20
+            elif gap > OBJ1_HOLD_GAP and self.step_in_target < 420:
+                advance = False
+            if os.environ.get("ATEC_PCA_DEBUG_TARGET") and self.step_in_target % 25 == 0:
+                print(f"[PCA_SQUEEZE] step={self.step_in_target} gap={gap:.4f} advance={advance}", flush=True)
+        if advance:
+            if os.environ.get("ATEC_PCA_DEBUG_TARGET") and target.label.startswith("obj3_"):
+                c_dbg = self._estimate_object3_current_center(obs)
+                f_dbg = self.ik.finger_center_world(qpos)
+                gap_dbg = self.ik.finger_gap(qpos)
+                c_msg = "none"
+                if c_dbg is not None:
+                    c_msg = f"({c_dbg[0]:.3f},{c_dbg[1]:.3f},{c_dbg[2]:.3f})"
+                print(
+                    f"[PCA_STAGE_END] {target.label} c={c_msg} "
+                    f"finger=({f_dbg[0]:.3f},{f_dbg[1]:.3f},{f_dbg[2]:.3f}) "
+                    f"gap={gap_dbg:.4f} hold="
+                    f"{None if self._obj3_hold_grip is None else [float(v) for v in self._obj3_hold_grip]}",
+                    flush=True,
+                )
+            self.step_in_target = 0
+            self.plan_idx += 1
+        return {"action": action.reshape(1, -1).astype(np.float32).tolist(), "giveup": False}
+
+
+RETRACT_X = TABLE_CENTER_X + TABLE_HALF_X - 0.05
+RETRACT_Y = TABLE_CENTER_Y

demo/solution_pi05.py

@@ -0,0 +1,169 @@
+"""ATEC Task E adapter for an OpenPI/pi0.5 websocket policy server.
+
+This is a local evaluation bridge, not the current submission default.  Start
+the OpenPI server first, then evaluate this solution against the Isaac task.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import torchvision.transforms.functional as TF
+
+
+_OPENPI_REPO = Path(os.environ.get("OPENPI_REPO", "/home/ubuntu/src/openpi-ebench-clean"))
+_OPENPI_CLIENT = _OPENPI_REPO / "packages" / "openpi-client" / "src"
+if str(_OPENPI_CLIENT) not in sys.path:
+    sys.path.insert(0, str(_OPENPI_CLIENT))
+
+from openpi_client import websocket_client_policy  # noqa: E402
+
+
+class AlgSolution:
+    """Competition-style solution wrapper backed by a pi0.5 action chunk server."""
+
+    _QPOS_SLICE = slice(0, 8)
+    _DEFAULT_PROMPT = "identify all objects, pick them up, and place them into the target basket"
+
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        host = os.environ.get("ATEC_PI05_HOST", "127.0.0.1")
+        port = int(os.environ.get("ATEC_PI05_PORT", "8000"))
+        self.policy = websocket_client_policy.WebsocketClientPolicy(host=host, port=port)
+        self.prompt = os.environ.get("ATEC_PI05_PROMPT", self._DEFAULT_PROMPT)
+
+        self.default_joint_pos = torch.tensor(
+            [[0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035]],
+            dtype=torch.float32,
+            device=self.device,
+        )
+        self.teleop_home_joint_pos = torch.tensor(
+            [[-0.000033, 0.924525, -1.514983, 0.000011, 1.219900, -0.000033, 0.035000, -0.035000]],
+            dtype=torch.float32,
+            device=self.device,
+        )
+        self._home_action = torch.clamp(
+            (self.teleop_home_joint_pos - self.default_joint_pos) / 0.5,
+            -1.0,
+            1.0,
+        )
+        self._startup_zero_steps = int(os.environ.get("ATEC_PI05_STARTUP_ZERO_STEPS", "25"))
+        self._home_qpos_tolerance = float(os.environ.get("ATEC_PI05_HOME_QPOS_TOLERANCE", "0.10"))
+        self._home_hold_steps = int(os.environ.get("ATEC_PI05_HOME_HOLD_STEPS", "5"))
+        self._action_repeat = max(1, int(os.environ.get("ATEC_PI05_ACTION_REPEAT", "5")))
+        self._resize_size = (224, 224)
+        self.reset_episode()
+
+    def reset_episode(self):
+        self._startup_step = 0
+        self._home_stable_steps = 0
+        self._home_done = False
+        self._action_queue: deque[np.ndarray] = deque()
+        self._held_action: np.ndarray | None = None
+        self._held_remaining = 0
+
+    def _compute_home_action(self, proprio: torch.Tensor) -> tuple[torch.Tensor, bool]:
+        joint_pos_rel = proprio[:, self._QPOS_SLICE]
+        qpos = joint_pos_rel + self.default_joint_pos
+        qerr = self.teleop_home_joint_pos - qpos
+        within_tolerance = torch.all(torch.abs(qerr) <= self._home_qpos_tolerance, dim=1)
+        self._home_stable_steps = self._home_stable_steps + 1 if bool(torch.all(within_tolerance)) else 0
+        home_reached = self._home_stable_steps >= self._home_hold_steps
+        return self._home_action.repeat(proprio.shape[0], 1), home_reached
+
+    def _rgb_from_obs(self, obs: dict) -> np.ndarray:
+        rgb = obs["image"]["video_rgb"]
+        if isinstance(rgb, torch.Tensor):
+            rgb = rgb[0].detach().cpu()
+            if rgb.ndim == 3 and rgb.shape[0] in (3, 4):
+                rgb = rgb[:3].permute(1, 2, 0)
+            if rgb.ndim == 3 and rgb.shape[-1] == 4:
+                rgb = rgb[..., :3]
+            if rgb.dtype != torch.uint8:
+                rgb = (rgb.float() * 255.0).clamp(0, 255).to(torch.uint8)
+            if tuple(rgb.shape[:2]) != self._resize_size:
+                rgb = TF.resize(
+                    rgb.permute(2, 0, 1),
+                    list(self._resize_size),
+                    interpolation=TF.InterpolationMode.BILINEAR,
+                    antialias=True,
+                ).permute(1, 2, 0)
+            return rgb.numpy()
+
+        rgb = np.asarray(rgb[0])
+        if rgb.shape[-1] == 4:
+            rgb = rgb[..., :3]
+        if np.issubdtype(rgb.dtype, np.floating):
+            rgb = (rgb * 255.0).clip(0, 255).astype(np.uint8)
+        return rgb.astype(np.uint8, copy=False)
+
+    def _openpi_obs(self, obs: dict, proprio: torch.Tensor) -> dict:
+        qpos = (proprio[:, self._QPOS_SLICE] + self.default_joint_pos).detach().cpu().numpy()[0]
+        joints = np.zeros(12, dtype=np.float32)
+        gripper = np.zeros(4, dtype=np.float32)
+        joints[:6] = qpos[:6]
+        gripper[:2] = qpos[6:8]
+        rgb = self._rgb_from_obs(obs)
+        return {
+            "states/joint": joints,
+            "states/gripper": gripper,
+            "images/head": rgb,
+            "images/hand_left": rgb,
+            "images/hand_right": rgb,
+            "prompt": self.prompt,
+        }
+
+    @staticmethod
+    def _to_env_action(action16: np.ndarray) -> np.ndarray:
+        action16 = np.asarray(action16, dtype=np.float32)
+        env_action = np.zeros(8, dtype=np.float32)
+        env_action[:6] = action16[:6]
+        env_action[6:8] = action16[12:14]
+        return env_action
+
+    def _next_pi05_action(self, obs: dict, proprio: torch.Tensor) -> np.ndarray:
+        if self._held_action is not None and self._held_remaining > 0:
+            self._held_remaining -= 1
+            return self._held_action
+
+        if not self._action_queue:
+            response = self.policy.infer(self._openpi_obs(obs, proprio))
+            actions = np.asarray(response["actions"], dtype=np.float32)
+            if actions.ndim != 2 or actions.shape[-1] < 16:
+                raise ValueError(f"Expected OpenPI actions with shape (T, >=16), got {actions.shape}")
+            for action16 in actions:
+                self._action_queue.append(self._to_env_action(action16))
+
+        self._held_action = self._action_queue.popleft()
+        self._held_remaining = self._action_repeat - 1
+        return self._held_action
+
+    def predicts(self, obs, current_score):
+        if not isinstance(obs, dict) or "proprio" not in obs:
+            raise ValueError("Expected obs dict with 'proprio' key.")
+
+        proprio = obs["proprio"].to(self.device)
+        num_envs = proprio.shape[0]
+        if num_envs != 1:
+            raise ValueError("solution_pi05 currently supports num_envs=1 for websocket inference.")
+
+        if self._startup_step < self._startup_zero_steps:
+            self._startup_step += 1
+            return {"action": np.zeros((1, 8), dtype=np.float32).tolist(), "giveup": False}
+
+        if not self._home_done:
+            home_action, home_reached = self._compute_home_action(proprio)
+            if home_reached:
+                self._home_done = True
+                self._action_queue.clear()
+                self._held_action = None
+                self._held_remaining = 0
+            return {"action": home_action.detach().cpu().numpy().tolist(), "giveup": False}
+
+        action = self._next_pi05_action(obs, proprio)
+        return {"action": action.reshape(1, -1).tolist(), "giveup": False}

demo/solution_pi05_native8.py

@@ -0,0 +1,181 @@
+"""ATEC Task E pi0.5 native-8D websocket policy bridge."""
+
+from __future__ import annotations
+
+from collections import deque
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+import torchvision.transforms.functional as TF
+
+
+_OPENPI_REPO = Path(os.environ.get("OPENPI_REPO", "/home/ubuntu/src/openpi-ebench-clean"))
+_OPENPI_CLIENT = _OPENPI_REPO / "packages" / "openpi-client" / "src"
+if str(_OPENPI_CLIENT) not in sys.path:
+    sys.path.insert(0, str(_OPENPI_CLIENT))
+
+from openpi_client import websocket_client_policy  # noqa: E402
+
+
+class AlgSolution:
+    _QPOS_SLICE = slice(0, 8)
+    _DEFAULT_PROMPT = "identify all objects, pick them up, and place them into the target basket"
+
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        host = os.environ.get("ATEC_PI05_HOST", "127.0.0.1")
+        port = int(os.environ.get("ATEC_PI05_PORT", "8000"))
+        self.policy = websocket_client_policy.WebsocketClientPolicy(host=host, port=port)
+        self.prompt = os.environ.get("ATEC_PI05_PROMPT", self._DEFAULT_PROMPT)
+
+        self.default_joint_pos = torch.tensor(
+            [[0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035]],
+            dtype=torch.float32,
+            device=self.device,
+        )
+        self.teleop_home_joint_pos = torch.tensor(
+            [[-0.000033, 0.924525, -1.514983, 0.000011, 1.219900, -0.000033, 0.035000, -0.035000]],
+            dtype=torch.float32,
+            device=self.device,
+        )
+        self._home_action = torch.clamp(
+            (self.teleop_home_joint_pos - self.default_joint_pos) / 0.5,
+            -1.0,
+            1.0,
+        )
+        self._startup_zero_steps = int(os.environ.get("ATEC_PI05_STARTUP_ZERO_STEPS", "25"))
+        self._home_qpos_tolerance = float(os.environ.get("ATEC_PI05_HOME_QPOS_TOLERANCE", "0.10"))
+        self._home_hold_steps = int(os.environ.get("ATEC_PI05_HOME_HOLD_STEPS", "5"))
+        self._action_repeat = max(1, int(os.environ.get("ATEC_PI05_ACTION_REPEAT", "1")))
+        self._action_clip = float(os.environ.get("ATEC_PI05_ACTION_CLIP", "5.0"))
+        self._chunk_exec_steps = max(1, int(os.environ.get("ATEC_PI05_CHUNK_EXEC_STEPS", "10")))
+        self._zero_noise = os.environ.get("ATEC_PI05_ZERO_NOISE", "0").lower() in ("1", "true", "yes")
+        self._action_horizon = max(1, int(os.environ.get("ATEC_PI05_ACTION_HORIZON", "10")))
+        self._model_action_dim = max(8, int(os.environ.get("ATEC_PI05_MODEL_ACTION_DIM", "32")))
+        self._debug = os.environ.get("ATEC_PI05_DEBUG", "0").lower() in ("1", "true", "yes")
+        self._resize_size = (224, 224)
+        self.reset_episode()
+
+    def reset_episode(self):
+        self._startup_step = 0
+        self._home_stable_steps = 0
+        self._home_done = False
+        self._action_queue: deque[np.ndarray] = deque()
+        self._held_action: np.ndarray | None = None
+        self._held_remaining = 0
+        self._debug_step = 0
+        self._policy_calls = 0
+
+    def _compute_home_action(self, proprio: torch.Tensor) -> tuple[torch.Tensor, bool]:
+        qpos = proprio[:, self._QPOS_SLICE] + self.default_joint_pos
+        qerr = self.teleop_home_joint_pos - qpos
+        within_tolerance = torch.all(torch.abs(qerr) <= self._home_qpos_tolerance, dim=1)
+        self._home_stable_steps = self._home_stable_steps + 1 if bool(torch.all(within_tolerance)) else 0
+        home_reached = self._home_stable_steps >= self._home_hold_steps
+        if self._debug and self._debug_step % 50 == 0:
+            print(
+                "[PI05_DEBUG] "
+                f"home step={self._debug_step} max_abs_qerr={torch.max(torch.abs(qerr)).item():.4f} "
+                f"stable={self._home_stable_steps}/{self._home_hold_steps} "
+                f"qpos={qpos[0].detach().cpu().numpy()[:8]}",
+                flush=True,
+            )
+        return self._home_action.repeat(proprio.shape[0], 1), home_reached
+
+    def _rgb_from_obs(self, obs: dict) -> np.ndarray:
+        rgb = obs["image"]["video_rgb"]
+        if isinstance(rgb, torch.Tensor):
+            rgb = rgb[0].detach().cpu()
+            if rgb.ndim == 3 and rgb.shape[0] in (3, 4):
+                rgb = rgb[:3].permute(1, 2, 0)
+            if rgb.ndim == 3 and rgb.shape[-1] == 4:
+                rgb = rgb[..., :3]
+            if rgb.dtype != torch.uint8:
+                rgb = (rgb.float() * 255.0).clamp(0, 255).to(torch.uint8)
+            if tuple(rgb.shape[:2]) != self._resize_size:
+                rgb = TF.resize(
+                    rgb.permute(2, 0, 1),
+                    list(self._resize_size),
+                    interpolation=TF.InterpolationMode.BILINEAR,
+                    antialias=True,
+                ).permute(1, 2, 0)
+            return rgb.numpy()
+
+        rgb = np.asarray(rgb[0])
+        if rgb.shape[-1] == 4:
+            rgb = rgb[..., :3]
+        if np.issubdtype(rgb.dtype, np.floating):
+            rgb = (rgb * 255.0).clip(0, 255).astype(np.uint8)
+        return rgb.astype(np.uint8, copy=False)
+
+    def _openpi_obs(self, obs: dict, proprio: torch.Tensor) -> dict:
+        qpos = (proprio[:, self._QPOS_SLICE] + self.default_joint_pos).detach().cpu().numpy()[0]
+        openpi_obs = {
+            "state": qpos.astype(np.float32, copy=False),
+            "image": self._rgb_from_obs(obs),
+            "prompt": self.prompt,
+        }
+        if self._zero_noise:
+            openpi_obs["noise"] = np.zeros((self._action_horizon, self._model_action_dim), dtype=np.float32)
+        return openpi_obs
+
+    def _next_pi05_action(self, obs: dict, proprio: torch.Tensor) -> np.ndarray:
+        if self._held_action is not None and self._held_remaining > 0:
+            self._held_remaining -= 1
+            return self._held_action
+
+        if not self._action_queue:
+            response = self.policy.infer(self._openpi_obs(obs, proprio))
+            actions = np.asarray(response["actions"], dtype=np.float32)
+            if actions.ndim != 2 or actions.shape[-1] < 8:
+                raise ValueError(f"Expected OpenPI native8 actions with shape (T, >=8), got {actions.shape}")
+            self._policy_calls += 1
+            if self._debug:
+                print(
+                    "[PI05_DEBUG] "
+                    f"policy_call={self._policy_calls} actions_shape={actions.shape} "
+                    f"first_action={actions[0, :8]}",
+                    flush=True,
+                )
+            for action8 in actions[: self._chunk_exec_steps]:
+                self._action_queue.append(np.clip(action8[:8], -self._action_clip, self._action_clip))
+
+        self._held_action = self._action_queue.popleft()
+        self._held_remaining = self._action_repeat - 1
+        return self._held_action
+
+    def predicts(self, obs, current_score):
+        if not isinstance(obs, dict) or "proprio" not in obs:
+            raise ValueError("Expected obs dict with 'proprio' key.")
+
+        proprio = obs["proprio"].to(self.device)
+        if proprio.shape[0] != 1:
+            raise ValueError("solution_pi05_native8 supports num_envs=1.")
+
+        if self._startup_step < self._startup_zero_steps:
+            self._startup_step += 1
+            self._debug_step += 1
+            if self._debug and self._startup_step in (1, self._startup_zero_steps):
+                print(f"[PI05_DEBUG] startup step={self._startup_step}/{self._startup_zero_steps}", flush=True)
+            return {"action": np.zeros((1, 8), dtype=np.float32).tolist(), "giveup": False}
+
+        if not self._home_done:
+            home_action, home_reached = self._compute_home_action(proprio)
+            if home_reached:
+                self._home_done = True
+                self._action_queue.clear()
+                self._held_action = None
+                self._held_remaining = 0
+                if self._debug:
+                    print(f"[PI05_DEBUG] home_done at step={self._debug_step}", flush=True)
+            self._debug_step += 1
+            return {"action": home_action.detach().cpu().numpy().tolist(), "giveup": False}
+
+        action = self._next_pi05_action(obs, proprio)
+        if self._debug and self._debug_step % 50 == 0:
+            print(f"[PI05_DEBUG] execute step={self._debug_step} action={action[:8]}", flush=True)
+        self._debug_step += 1
+        return {"action": action.reshape(1, -1).tolist(), "giveup": False}

demo/solution_rl.py

@@ -0,0 +1,210 @@
+import os
+import torch
+
+class AlgSolution:
+
+    ACTION_SCALE = 0.5
+    EE_BODY_NAME_CANDIDATES = ("gripper_base", "piper_gripper_base")
+    ARM_JOINT_NAME_CANDIDATES = (
+        ["joint1", "joint2", "joint3", "joint4", "joint5", "joint6"],
+        ["arm_joint1", "arm_joint2", "arm_joint3", "arm_joint4", "arm_joint5", "arm_joint6"],
+    )
+
+    def __init__(self):
+        policy_path = os.path.dirname(os.path.abspath(__file__)) + '/policy.pt'
+        self.device = 'cuda'
+
+        self.policy = torch.jit.load(policy_path, map_location=self.device)
+        self.policy.eval()
+
+        self.leg_action_dim = 12
+        self.arm_action_dim = 8
+
+        self.leg_joint_indices = list(range(12))
+        self.arm_joint_indices = list(range(12, 20))
+
+        self.train_to_env_action_scale = torch.tensor(
+            [
+                0.25, 0.5, 0.5,
+                0.25, 0.5, 0.5,
+                0.25, 0.5, 0.5,
+                0.25, 0.5, 0.5,
+            ],
+            device=self.device,
+            dtype=torch.float32,
+        ).view(1, -1)
+
+        self.env_to_train_action_scale = torch.tensor(
+            [
+                4.0, 2.0, 2.0,
+                4.0, 2.0, 2.0,
+                4.0, 2.0, 2.0,
+                4.0, 2.0, 2.0,
+            ],
+            device=self.device,
+            dtype=torch.float32,
+        ).view(1, -1)
+
+        # Fixed zero base velocity command for policy input.
+        self.fixed_velocity_commands = torch.tensor(
+            [0.5, 0.0, 0.0],
+            device=self.device,
+            dtype=torch.float32,
+        ).view(1, 3)
+
+        self.arm_default_action = torch.zeros(
+            (1, self.arm_action_dim),
+            device=self.device,
+            dtype=torch.float32,
+        )
+
+
+    def _resolve_joint_ids(self, candidates: tuple[list[str], ...]) -> list[int]:
+        last_error = None
+        for names in candidates:
+            try:
+                ids, found_names = self.robot.find_joints(names)
+            except ValueError as err:
+                last_error = err
+                continue
+            if len(ids) == len(names):
+                if candidates is self.ARM_JOINT_NAME_CANDIDATES:
+                    self.arm_joint_names = list(found_names)
+                return list(ids)
+        raise ValueError(
+            f"Cannot resolve required joints from candidates: {candidates}. Last error: {last_error}"
+        )
+
+    def _resolve_ee_body_name(self) -> str:
+        last_error = None
+        for name in self.EE_BODY_NAME_CANDIDATES:
+            try:
+                body_ids, _ = self.robot.find_bodies(name)
+            except ValueError as err:
+                last_error = err
+                continue
+            if len(body_ids) == 1:
+                return name
+        raise ValueError(
+            f"Cannot resolve EE body from candidates: {self.EE_BODY_NAME_CANDIDATES}. Last error: {last_error}"
+        )
+
+    def _ensure_cartesian_targets(self):
+        self.cartesian_ctrl.reset()
+
+    def _compute_arm_overlay_action(self) -> torch.Tensor:
+        self._ensure_cartesian_targets()
+
+        arm_jpos_des = self.cartesian_ctrl.compute_base(
+            self.ee_pos_target_b,
+            self.ee_quat_target_b,
+        )
+
+        full_target = self.robot.data.joint_pos.clone()
+        full_target[:, self.arm_ids] = arm_jpos_des
+        full_target[:, self.gripper_ids] = self.gripper_open_pos.repeat(full_target.shape[0], 1)
+
+        return (full_target - self.default_joint_pos) / self.ACTION_SCALE
+
+    def _get_velocity_commands(self, proprio: torch.Tensor) -> torch.Tensor:
+        """Return fixed velocity commands for policy input."""
+        num_envs = proprio.shape[0]
+
+        cmd = self.fixed_velocity_commands.to(dtype=proprio.dtype, device=self.device)
+        if num_envs > 1:
+            cmd = cmd.repeat(num_envs, 1)
+        return cmd
+
+    def _extract_policy_obs(self, obs, action_dim) -> torch.Tensor:
+        proprio = obs["proprio"].to(self.device)
+
+        expected_dim = 3 + 3 + 3 + 3 + action_dim + action_dim + action_dim
+
+        idx = 0
+        _base_lin_vel = proprio[:, idx:idx + 3]
+        idx += 3
+
+        base_ang_vel = proprio[:, idx:idx + 3]
+        idx += 3
+
+        _velocity_commands_env = proprio[:, idx:idx + 3]
+        idx += 3
+
+        projected_gravity = proprio[:, idx:idx + 3]
+        idx += 3
+
+        joint_pos_all = proprio[:, idx:idx + action_dim]
+        idx += action_dim
+
+        joint_vel_all = proprio[:, idx:idx + action_dim]
+        idx += action_dim
+
+        actions_all = proprio[:, idx:idx + action_dim]
+
+        joint_pos_leg = joint_pos_all[:, self.leg_joint_indices]
+        joint_vel_leg = joint_vel_all[:, self.leg_joint_indices]
+        actions_env_leg = actions_all[:, self.leg_joint_indices]
+
+        actions_train_leg = actions_env_leg * self.env_to_train_action_scale.to(dtype=proprio.dtype)
+        velocity_commands = self._get_velocity_commands(proprio)
+
+        policy_obs = torch.cat(
+            [
+                base_ang_vel * 0.25,
+                projected_gravity,
+                velocity_commands,
+                joint_pos_leg,
+                joint_vel_leg * 0.05,
+                actions_train_leg,
+            ],
+            dim=-1,
+        )
+
+        return policy_obs
+
+    def _map_policy_action_to_env_action(self, action_train: torch.Tensor, action_dim: int) -> torch.Tensor:
+        """Map training-time 12D leg action to current env 20D full-body action."""
+        if action_train.shape[-1] != self.leg_action_dim:
+            raise ValueError(
+                f"Policy output dim mismatch: got {action_train.shape[-1]}, expected {self.leg_action_dim}"
+            )
+
+        num_envs = action_train.shape[0]
+        leg_action_env = action_train * self.train_to_env_action_scale
+
+        action_env = torch.zeros(
+            (num_envs, action_dim),
+            device=self.device,
+            dtype=torch.float32,
+        )
+
+        action_env[:, self.leg_joint_indices] = leg_action_env
+        action_env[:, self.arm_joint_indices] = self.arm_default_action.repeat(num_envs, 1)
+
+        return action_env
+
+    def predicts(self, obs, current_score):
+        """Run policy inference and return current-env full-body action."""
+        if current_score > 1:
+            return {'action': [], 'giveup': True}
+        proprio = obs["proprio"].to(self.device)
+        action_dim = (int(proprio.shape[-1]) - 12) // 3
+        policy_obs = self._extract_policy_obs(obs, action_dim)
+
+        with torch.inference_mode():
+            action_train = self.policy(policy_obs)
+
+        if not isinstance(action_train, torch.Tensor):
+            action_train = torch.as_tensor(
+                action_train, device=self.device, dtype=torch.float32
+            )
+
+        action_train = action_train.to(device=self.device, dtype=torch.float32)
+
+        if action_train.ndim == 1:
+            action_train = action_train.unsqueeze(0)
+
+        action_env = self._map_policy_action_to_env_action(action_train, action_dim)
+        action_env = action_env.cpu().numpy().tolist()
+        return {'action': action_env, 'giveup': False}
+

demo/solution_zero.py

@@ -0,0 +1,12 @@
+import torch
+
+class AlgSolution:
+
+    def __init__(self):
+        pass
+
+    def predicts(self, obs, current_score):
+        proprio = obs['proprio']
+        action_dim = (int(proprio.shape[-1]) - 12) // 3
+        action = [0 for _ in range(action_dim)]
+        return {'action': action, 'giveup': False}

docs/ATEC2026_TaskE_规则物理配置与提交说明_20260604.md

@@ -0,0 +1,273 @@
+# ATEC2026 L0 Task E：规则、物理配置与当前抓取问题说明
+
+更新时间：2026-06-04  
+工作目录：`/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge`
+
+## 1. 结论先行
+
+1. 当前我们调试的确实是 ATEC2026 官方仿真包里的 `ATEC-TaskE-Piper` 桌面抓取任务，不是 L1 足式/轮腿任务，也不是自定义机械臂任务。
+2. 本地物理配置基本来自官方仓库：Isaac Lab v2.3.2、AgileX Piper、三种 YCB 风格物体、桌面、篮筐、固定 RGB-D 观测与 end-effector RGB-D 观测。Piper/物体/地面摩擦和 solver 参数在源码中可查。
+3. “夹住后滑落”不是一个可以简单甩给 Isaac Sim 的单点 bug。更准确地说：官方物理配置对二指夹爪的摩擦夹持比较敏感，而我们当前 GraspGen-style/PCA submit-side primitive 对香蕉这类非凸弯曲物体仍在依赖摩擦保持；一旦 finger-center、闭合高度、夹爪开度、运输高度或速度有偏差，就会出现短暂抬起后滑落。
+4. 不能通过修改比赛评测环境物理参数来提交。提高 solver iteration、摩擦、接触参数可以作为本地诊断，但最终提交必须在官方 judge 环境下靠 `demo/solution.py` 的观测与动作输出成功。
+5. 当前最强可部署基线仍是 `demo/solution.py` 中的 ACT/XSA 方案；`demo/solution_pca.py` 是实验分支，不应覆盖部署，除非三物体多 seed 连续评估明显超过 ACT/XSA。
+
+## 2. 已下载/整理的官方资料
+
+本次已下载官方 GitHub README 快照：
+
+- 本地快照：`docs/sources/ATEC2026_Simulation_Challenge_official_readme_20260604.md`
+- 官方源链接：<https://github.com/atecup/ATEC2026_Simulation_Challenge>
+- 官方 raw README：<https://raw.githubusercontent.com/atecup/ATEC2026_Simulation_Challenge/main/readme.md>
+
+2026-06-04 进一步做了官方 fresh clone 对照，临时目录：
+
+- `/tmp/ATEC2026_Simulation_Challenge_official_check`
+- 官方 HEAD：`dbe7c251f680b02f357a6db67430b18d3ba45ea1`
+- 最新提交：`dbe7c25 2026-06-04 10:10:16 +0800 Merge pull request #8 from atecup/fix/tron2a_joint_configuration`
+
+对照结论：
+
+- 与 Task E 抓取物理强相关的文件，本地与官方最新版 SHA 完全一致：
+  - `source/atec_rl_lab/atec_rl_lab/assets/robots/piper.py`
+  - `source/atec_rl_lab/atec_rl_lab/assets/objects/task_b/object.py`
+  - `source/atec_rl_lab/atec_rl_lab/tasks/task_e/terrain.py`
+  - `source/atec_rl_lab/atec_rl_lab/tasks/task_e/mdp/rewards.py`
+  - `source/atec_rl_lab/atec_rl_lab/tasks/task_e/mdp/terminations.py`
+- `source/atec_rl_lab/atec_rl_lab/tasks/task_e/env_cfg.py` 只有 action group 字段名差异：官方最新版使用 `joint_leg` / `joint_wheel` / `joint_arm`，本地使用 `joint_pos_leg` / `joint_vel_wheel` / `joint_pos_arm`；Task E 物体、篮筐、相机、随机 Y-band、reward/termination 和 physics material 逻辑一致。
+- `source/atec_rl_lab/atec_rl_lab/tasks/task_base/envs_base_cfg.py` 有两类差异：action group 字段名差异，以及 base reset joint randomization 从官方 `(1.0, 1.0)` 到本地 `(0.5, 1.5)`；Task E Piper 在 `TaskEEnvPiperCfg` 中关闭了相关 reset events，因此这不是香蕉滑落的原因。
+- `demo/server.py` 官方最新版新增 `/get_action_spec` 接口；本地 server 还没有这个接口。这个只影响选手是否能在提交服务里自定义 action mode/scale/clip，不改变官方仿真物理。
+- `demo/Dockerfile` 本地改成 ACT/XSA 提交模板，官方默认仍是 `solution_zero.py` 示例。这是我们自己的提交镜像选择，不是物理环境差异。
+
+同日再次核对官方更新与 issue/PR：
+
+- `git fetch origin` 后，`origin/main` 仍是 `dbe7c251f680b02f357a6db67430b18d3ba45ea1`，没有比 2026-06-04 10:10:16 更新的 commit。
+- GitHub issues/PR 网页搜索未发现公开 issue 提到 Task E / Piper / grasp / physics / friction / banana 滑落问题。
+- `Piper` 搜索命中的是 PR #2：eye-in-hand camera configuration for B2Piper/B2WPiper/G1，不是 Task E 固定 Piper，也不是夹爪滑落。
+- PR #5 是 participant action spec；PR #8 是 Tron2A joint configuration reset bug，和 Task E 抓取物理无关。
+- 已同步唯一低风险兼容修复：在本地 `demo/server.py` 加入官方 `/get_action_spec` endpoint。若 solution 不实现该方法，返回 `{}`，即沿用默认 action 配置。
+
+本地 `readme.md` 与官方 raw README 有少量差异：官方新版 README 增加了 `AlgSolution.get_action_spec()` 可选接口说明；本地文件仍可用于当前代码运行，但提交前应留意官方是否启用了该新接口。
+
+另外，用户此前提供的赛事说明包含：
+
+- L0 Task E：桌面随机摆放三种不同类型物体，桌面级机械臂完成识别、抓取、放置到指定区域。
+- 核心流程：识别、规划、抓取、放置。
+- 代码审查：最高分镜像对应代码需要可复现、合规；技术报告需说明实现思路、代码组织结构、执行流程，使用开源模型需提供下���链接，额外训练模型需提供训练代码和数据来源。
+- 预测阶段只能使用上传镜像中的代码和模型，禁止利用测试集挖掘或外部信息。
+
+## 3. 官方仓库对 Task E 的关键要求
+
+官方 README 明确该仓库提供仿真资产、任务定义和提交脚本，环境基于 Isaac Lab；Task E 在环境矩阵中对应 `ATEC-TaskE-Piper`。参考：
+
+- `readme.md` / 官方 README：Task E 使用 `ATEC-TaskE-Piper`。
+- `readme.md`：仓库开发/测试版本为 Isaac Lab v2.3.2。
+- `readme.md`：参赛者必须实现 `demo/solution.py`，类名为 `AlgSolution`，核心函数为 `predicts(obs, current_score)`，返回 `{"action": action, "giveup": False}`。
+
+本地 Dockerfile 当前提交布局：
+
+- `demo/Dockerfile` 将 `solution_act.py` 复制为镜像内 `solution.py`，并带上 `policy_act.pt`。
+- 这说明当前默认提交镜像仍是 ACT/XSA 路线，不是 PCA/AnyGrasp 路线。
+- 若以后要切换到 GraspGen-style/PCA，必须先改 Dockerfile 复制目标，并完成多 seed 稳定评估。
+
+## 4. Task E 本地评分逻辑
+
+源码位置：`source/atec_rl_lab/atec_rl_lab/tasks/task_e/env_cfg.py` 与 `source/atec_rl_lab/atec_rl_lab/tasks/task_e/mdp/rewards.py`。
+
+本地 Task E 有两类奖励：
+
+1. `grasped_objects_once`：物体被末端执行器接近并抬高到桌面上方一定高度，单物体一次性奖励约 3 分。
+2. `objects_in_basket`：物体进入篮筐成功区域，单物体一次性奖励约 3 分。
+
+因此三物体理论满分通常对应：
+
+- 3 个物体各自“被抓起/抬起”一次：约 9 分。
+- 3 个物体最终入篮：约 9 分。
+- 合计约 18 分。
+
+篮筐成功区域在源码中定义为：
+
+- 成功中心：`BASKET_SUCCESS_CENTER = (1.08, -0.30, TABLE_TOP_Z + 0.15)`
+- XY 半宽：`half_x = 0.20`，`half_y = 0.11`
+- Z 范围：`TABLE_TOP_Z <= object_z <= TABLE_TOP_Z + 0.15`
+
+这解释了一个重要现象：视频里看起来“抓到过”只能拿到抓取/抬升分；真正冲榜需要三个物体都稳定落在篮筐成功区域内。
+
+## 5. 官方/本地物理配置证据
+
+### 5.1 Piper 机械臂配置
+
+源码：`source/atec_rl_lab/atec_rl_lab/assets/robots/piper.py`
+
+关键参数：
+
+- 机器人资产：`robot/piper/piper.usd`
+- 关节：`joint1` 到 `joint8`，其中 `joint7/joint8` 是两指夹爪。
+- 接触传感器：`activate_contact_sensors=True`
+- 关节隐式执行器：`effort_limit=100.0`、`velocity_limit=100.0`、`stiffness=800.0`、`damping=80.0`
+- articulation solver：`solver_position_iteration_count=4`、`solver_velocity_iteration_count=0`
+
+源码：`source/atec_rl_lab/atec_rl_lab/tasks/task_e/env_cfg.py`
+
+Task E Piper 初始状态：
+
+- 机械臂固定在桌子右侧：`pos=(TABLE_CENTER_X + TABLE_HALF_X, TABLE_CENTER_Y, TABLE_TOP_Z)`
+- Task E 中 `piper_cfg.spawn.rigid_props.disable_gravity = True`
+- 夹爪初始张开：`joint7=0.035`、`joint8=-0.035`
+
+这里的 solver iteration 偏低，尤其 `velocity_iteration_count=0` 对接触稳定性不算友好。它不是我们抓取代码改出来的，而是仓库里的 Piper 默认配置。
+
+### 5.2 三个物体配置
+
+源码：`source/atec_rl_lab/atec_rl_lab/assets/objects/task_b/object.py`
+
+三种物体：
+
+- `object_1`：`004_sugar_box.usd`
+- `object_2`：`006_mustard_bottle.usd`
+- `object_3`：`011_banana.usd`
+
+共同物理参数：
+
+- `rigid_body_enabled=True`
+- `kinematic_enabled=False`
+- `linear_damping=2.0`
+- `angular_damping=4.0`
+- `max_depenetration_velocity=0.5`
+- `mass=0.5`
+- `contact_offset=0.01`
+- `rest_offset=0.0`
+
+质量统一 0.5kg 对小香蕉/小盒子来说偏重，会放大二指夹爪靠摩擦夹持时的难度。
+
+### 5.3 地面/桌面物理材料
+
+源码：`source/atec_rl_lab/atec_rl_lab/tasks/task_e/terrain.py`
+
+Task E terrain 物理材料：
+
+- `friction_combine_mode="multiply"`
+- `restitution_combine_mode="multiply"`
+- `static_friction=1.0`
+- `dynamic_friction=1.0`
+- `restitution=0.0`
+
+源码：`source/atec_rl_lab/atec_rl_lab/tasks/task_e/env_cfg.py`
+
+Task E 在 `__post_init__()` 中执行：
+
+- `self.scene.terrain = TASK_E_TERRAIN_CFG`
+- `self.sim.physics_material = self.scene.terrain.physics_material`
+- `self.events.physics_material = None`
+
+这说明 Task E 关闭了默认的 physics material 随机化，使用固定物理材料。对提交而言，这是好事：不是每次都随机摩擦；但对香蕉这种接触几何，固定摩擦也不保证稳抓。
+
+### 5.4 物体随机摆放
+
+源码：`source/atec_rl_lab/atec_rl_lab/tasks/task_e/env_cfg.py`
+
+三个物体在桌面不同 Y-band 中随机：
+
+- `object_1`：`Y in [0.25, 0.29]`
+- `object_2`：`Y in [0.14, 0.20]`
+- `object_3`：`Y in [0.03, 0.09]`
+- `X in [0.90, 1.10]`
+
+这与我们后续做 RGB-D band mask、按物体区域分割是一致的；但最终提交不能读 object root，只能从观测估计位置。
+
+## 6. 为什么香蕉会“夹住又滑落”
+
+当前最合理判断不是“完全没有抓取模型”，也不是“Isaac Sim 完全��了”，而是以下几个因素叠加：
+
+1. 香蕉是弯曲、非凸、局部接触很窄的物体，Piper 二指夹爪如果只夹在局部曲面上，很容易形成滚动/滑动接触。
+2. 当前物体质量统一 0.5kg，香蕉被设置得和盒子一样重，这对 friction-only pinch 很不友好。
+3. Piper solver 参数 `position=4, velocity=0` 对稳定接触不是很强；NVIDIA/Isaac Sim 文档和论坛中也常见“二指夹爪夹物体滑落、需要调接触/solver/摩擦或控制方式”的讨论。
+4. 我们 submit-style PCA 控制器只能用 RGB-D 和 proprio，不读真实 object root；从单视角点云估计出的 grasp center/yaw/闭合高度稍有偏差，就可能出现“看起来夹得很深，但实际 finger contact normal 不足”的情况。
+5. 旧 runner/采集器有时成功，是因为它能更接近官方 scripted primitive：使用更准确的物体状态/动态 servo/真实 finger-center trace。这个能力迁移到 `demo/solution_pca.py` 的 observation-only 控制时会损失。
+
+一句话：这不是“夹爪力不够”这么简单，而是接触几何、闭合高度、夹爪开度、运输阶段轨迹和官方 PhysX 接触参数共同作用。
+
+## 7. 能不能改物理配置
+
+### 可以做的
+
+可以做本地诊断：
+
+- 临时提高 Piper articulation solver iteration，例如 position 从 4 提到 16、velocity 从 0 提到 4。
+- 临时提高物体/夹爪摩擦、检查 contact offset/rest offset。
+- 用这些实验判断“滑落是否主要来自 PhysX 接触求解敏感性”。
+
+### 不建议作为提交依赖
+
+最终提交不应依赖修改官方评测物理：
+
+- 代码审查要求最高分镜像在组委会给定环境上可复现。
+- 如果我们靠本地改物理才能稳，线上 judge 不一定会加载这些修改。
+- 合规路线应是：在官方物理配置下，通过更稳的运动 primitive、低位搬运、under-scoop、慢速稳定、篮筐中心上方再释放等方式完成任务。
+
+## 8. 当前方案状态
+
+### 8.1 ACT/XSA
+
+当前默认可部署基线仍是 ACT/XSA：
+
+- Dockerfile 当前复制 `solution_act.py` 为提交 `solution.py`。
+- 历史评估中 XSA final 曾在 seeds 11/12/13 得到过高分，但也出现过非确定性波动。
+- 这是当前最成熟的镜像路线，但还不能说稳定满分。
+
+### 8.2 pi0.5
+
+pi0.5 已试过 20-demo 和 100-demo 分支，当前效果差：
+
+- 20-demo 快速分支 seeds 11/12/13 均为 0。
+- 100-demo 分支 seeds 11/12/13 约为 `0/0/6`，均值约 2。
+- 主要问题更像适配层/数据表示不对，而不是 pi0.5 模型本身弱。
+
+### 8.3 AnyGrasp
+
+AnyGrasp SDK 已接入并可推理，但有 license/不可分发限制：
+
+- 作为本地 candidate generator 很有价值。
+- 但如果最终提交镜像包含不可分发 SDK 或权重，代码审查风险很高。
+- 可借鉴它的 grasp candidate 思路，但最终最好落成可复现、可分发的几何/PCA/GraspNet-style 方法，或在技术报告中完整说明合法来源和许可。
+
+### 8.4 GraspGen-style PCA/AABB
+
+这是用户要求重点冲刺的真正规划抓取路线：
+
+- `object_1` 在 `demo/solution_pca.py` 中已有 seed11/12/13 单物体成功证据。
+- `object_2` 在 runner 中有单物体成功证据，但 submit-style 还没有完成稳定迁移。
+- `object_3` 当前已能在部分场景短暂强抬，但 mid/transport/release 阶段仍会滑落，尚未达到可提交稳定性。
+
+不能宣称 PCA/AABB 已经满分。它是正确方向之一，但还需要把香蕉运输保持问题和 object_2 submit-side 对齐彻底解决。
+
+## 9. 推荐的后续技术路线
+
+1. 不要再回退到“只训练 ACT/pi0.5”等黑盒路线；继续保留 ACT/XSA 作为提交底线，同时推进 GraspGen-style/PCA 作为冲榜路线。
+2. 对 object_3 做两个分支：
+   - 本地物理增强诊断：提高 solver iteration 看是否立刻不滑，以确认接触求解敏感性。
+   - 官方物理可提交修复：低位转移、under-scoop、缩短高空纯竖直 lift、抓住后沿篮筐方向慢速保持接触移动、篮筐中心高于边缘处稳定后再开爪。
+3. 对 object_2 单独迁移 runner 成功参数，不要套 object_1/object_3 的补偿。
+4. 所有成功证据必须按多 seed 记录：至少 seeds 11/12/13，最好再加 21/22/23。
+5. 最终切换 Dockerfile 前，必须满足：
+   - 三物体同一 episode 得分稳定接近或等于 18。
+   - 有视频证据。
+   - 不读取 env root/object state。
+   - 不依赖 AnyGrasp SDK 不可分发权重，或已完成合规说明。
+   - 技术报告中能解释模型/算法/开源链接/训练或无训练流程。
+
+## 10. 参考链接
+
+- ATEC2026 Simulation Challenge 官方仓库：<https://github.com/atecup/ATEC2026_Simulation_Challenge>
+- 官方 README raw 快照源：<https://raw.githubusercontent.com/atecup/ATEC2026_Simulation_Challenge/main/readme.md>
+- Isaac Lab pip installation 文档：<https://isaac-sim.github.io/IsaacLab/main/source/setup/installation/pip_installation.html>
+- Isaac Sim Physics Simulation Fundamentals：<https://docs.isaacsim.omniverse.nvidia.com/latest/physics/simulation_fundamentals.html>
+- NVIDIA 论坛，Object Gripping and picking：<https://forums.developer.nvidia.com/t/object-gripping-and-picking/291963>
+- NVIDIA 论坛，Stable grasping in Isaac Sim：<https://forums.developer.nvidia.com/t/stable-grasping-in-isaac-sim/354866>
+
+## 11. 给团队的交接提醒
+
+1. 不要把 `demo/solution_pca.py` 直接当最终提交；它是实验控制器。
+2. 不要把 AnyGrasp SDK 直接塞进最终镜像，除非许可证/技术报告/复现检查全部确认无风险。
+3. 不要修改官方物理参数后宣称线上可复现；改物理只能用于定位问题。
+4. 真正要冲榜，必须把“观测估计中心 -> finger-center 控制 -> 闭合 -> 低位运输 -> 篮筐中心上方稳定释放”串成同一条稳定轨迹。
+5. 当前最该解决的是 object_3 香蕉运输阶段滑落，而不是重新换大模型。

example.md

@@ -0,0 +1,95 @@
+## 1. Example Code Guide
+
+This document provides a minimal end-to-end example for training, evaluating, and submitting a policy.
+
+## 2. RL for Locomotion
+
+### 2.1 Train a PPO Policy (Example)
+
+The baseline workflow references: https://github.com/fan-ziqi/robot_lab
+
+Run the following command from the repository root:
+
+```bash
+python scripts/rsl_rl/train.py --task ATEC-Isaac-Velocity-Flat-Unitree-B2-v0 --headless --video
+```
+
+On an **NVIDIA RTX 5090**, this example typically takes around **90 minutes**.
+
+Actual training time depends on driver/runtime version, CPU performance, and current GPU load.
+
+### 2.2 Evaluate the Trained Policy
+
+After training, evaluate with:
+
+```bash
+python scripts/rsl_rl/play.py --task ATEC-Isaac-Velocity-Flat-Unitree-B2-v0
+```
+
+This loads the trained checkpoint and runs rollout in the same task setting.
+
+### 2.3 Test Locally
+
+The file `demo/solution.py` is the only entrance for locally testing and online submission.
+Use the test command:
+
+```bash
+cd ATEC2026_Simulation_Challenge
+python scripts/play_atec_task.py --task ATEC-TaskA-B2Piper --enable_cameras
+```
+
+Notes:
+
+- `--task` selects the arena and robot. See the Environment Matrix in `readme.md`.
+- Use `--debug` to print runtime status and score.
+
+Pretrained baseline checkpoint:
+
+- `./atec_robot_model/baseline/unitree_b2_flat/policy.pt`
+This checkpoint path can be modified in `demo/solution.py`.
+
+![baseline demo](./doc/baseline.gif)
+
+## 3. IL for Manipoulation
+
+This section follows the core idea of ACT (Action Chunking with Transformers).
+
+Reference implementation: https://github.com/tonyzhaozh/act
+
+### 3.1 Collect Demonstrations
+
+Collect expert trajectories for Task E:
+
+```bash
+python scripts/act/collect_demos_task_e.py --pick_objects 3 --num_demos 100 --headless --enable_cameras --save_images
+```
+
+Filter out near-zero actions from the collected dataset:
+
+```bash
+python scripts/act/filter_demos.py \
+	--input datasets/atec_task_e/trajectory.hdf5 \
+	--output datasets/atec_task_e/trajectory_filtered.hdf5 \
+	--threshold 0.001
+```
+
+### 3.2 Train ACT Policy
+
+Run ACT baseline training from the `scripts/act` directory:
+
+```bash
+cd scripts/act
+bash baseline.sh
+```
+
+### 3.3 Run the Trained Policy
+
+Use the test command:
+
+```bash
+python scripts/play_atec_task.py --task ATEC-TaskE-Piper --enable_cameras
+```
+
+Note: `./atec_robot_model/baseline/act/policy.pt` is the provided baseline checkpoint. You can replace it with your own trained policy path in `demo/solution`.
+
+![baseline act demo](./doc/baseline_act.gif)

readme.md

@@ -0,0 +1,238 @@
+## 1. Introduction
+
+The ATEC 2026 Simulation Challenge provides a standardized suite of robot simulation environments built on IsaacLab, designed to evaluate both locomotion and loco-manipulation capabilities. Participants may select one or multiple legged robot platforms to complete a set of representative tasks, including *Off-road Navigation*, *Tabletop Manipulation*, *Garbage Collection*, and *Obstacle Traversal*.  
+
+This repository includes simulation assets, task definitions, and reference scripts to support development, evaluation, and submission.
+
+---
+
+### 1.2 Robots and Sensors
+
+- **Robot platforms**
+  - Humanoid: Unitree G1 (with two-finger gripper)
+  - Dual-wheel legged + manipulator: Tron1 + AgileX Piper
+  - Tron2A legged / wheel + manipulator
+  - Quadruped + manipulator: Unitree B2 + AgileX Piper
+  - Wheel-legged quadruped + manipulator: Unitree B2W + AgileX Piper
+  - Manipulator-only: AgileX Piper
+- **Sensor suite** (standardized across platforms)
+  - 1 × LiDAR  
+  - 1 × eye-to-hand RGB-D camera  
+  - 1 × eye-in-hand RGB-D camera *(humanoids use a stereo pair)*  
+  
+  ## Robot Platforms
+
+
+  |                        Humanoid                        |              Dual-wheel legged + manipulator              |                  Tron2A legged + manipulator                  |                  Tron2A wheel + manipulator                  |                Quadruped + manipulator                |          Wheel-legged quadruped + manipulator          |                        Manipulator                        |
+  | :----------------------------------------------------: | :-------------------------------------------------------: | :-----------------------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------: | :-----------------------------------------------------: | :-------------------------------------------------------: |
+  | <p align="center"><img src="./doc/G1.png" width="180"> | <p align="center"><img src="./doc/Tron1.png" width="180"> | <p align="center"><img src="./doc/Tron2Legged.png" width="180"> | <p align="center"><img src="./doc/Tron2Wheel.png" width="180"> | <p align="center"><img src="./doc/B2.png" width="180"> | <p align="center"><img src="./doc/b2w.png" width="180"> | <p align="center"><img src="./doc/piper.png" width="180"> |
+
+> **Note:** Users may modify or optimize assets (e.g., collision geometry simplification) for training purposes. The provided assets serve as reference models for evaluation.
+
+---
+
+### 1.3 Challenge Arenas
+
+| Arena | Video | Arena | Video |
+| --- | --- | --- | --- |
+| Task A · Off-road Navigation | <p align="center"><img src="./doc/task_a.gif" width="180"> | Task E · Tabletop Manipulation | <p align="center"><img src="./doc/baseline_act.gif" width="180"> |
+| Task B · Garbage Collection | <p align="center"><img src="./doc/task_b.gif" width="180"> | Task D · Obstacle Traversal | <p align="center"><img src="./doc/task_d.gif" width="180"> |
+
+> **Note:** For each task, participants are free to select any supported robot morphology.
+
+---
+
+### 1.4 Environment Matrix
+
+The `atec_rl_lab.tasks` module registers all **arena–robot combinations** as Gym-compatible environments, enabling unified interfaces for evaluation and submission.
+
+
+| Arena \ Robot | G1              | Tron1Piper              | Tron2ALegged              | Tron2AWheel              | B2Piper              | B2wPiper              | Piper              |
+| ------------- | --------------- | ----------------------- | ------------------------- | ------------------------ | -------------------- | --------------------- | ------------------ |
+| Task A        | `ATEC-TaskA-G1` | `ATEC-TaskA-Tron1Piper` | `ATEC-TaskA-Tron2ALegged` | `ATEC-TaskA-Tron2AWheel` | `ATEC-TaskA-B2Piper` | `ATEC-TaskA-B2wPiper` |                    |
+| Task B        | `ATEC-TaskB-G1` | `ATEC-TaskB-Tron1Piper` | `ATEC-TaskB-Tron2ALegged` | `ATEC-TaskB-Tron2AWheel` | `ATEC-TaskB-B2Piper` | `ATEC-TaskB-B2wPiper` |                    |
+| Task D        | `ATEC-TaskD-G1` | `ATEC-TaskD-Tron1Piper` | `ATEC-TaskD-Tron2ALegged` | `ATEC-TaskD-Tron2AWheel` | `ATEC-TaskD-B2Piper` | `ATEC-TaskD-B2wPiper` |                    |
+| Task E        |                 |                         |                           |                          |                      |                       | `ATEC-TaskE-Piper` |
+
+> **Note:** The provided environments are designed for evaluation and submission only and do not support parallelized training. For training, users should implement custom wrappers or leverage external frameworks for efficient learning.
+
+---
+
+## 2. Installation
+
+This repository is developed and tested with **Isaac Lab v2.3.2**. Earlier versions (e.g., v1.4.1) are not validated and may require modification.
+
+Follow the official Isaac Lab installation [guide](https://isaac-sim.github.io/IsaacLab/main/source/setup/installation/pip_installation.html).
+
+### 2.1 Setup
+
+Clone repository
+```bash
+git clone https://github.com/atecup/ATEC2026_Simulation_Challenge.git
+cd ATEC2026_Simulation_Challenge
+```
+
+Activate Isaac Lab Environment
+
+```bash
+conda activate isaaclab
+```
+
+Install ATEC Extension
+```bash
+cd source/atec_rl_lab
+pip install -e .
+```
+
+After installation, all `ATEC-*` environments will be available in the active Python environment.
+
+Download Robot Models
+```bash
+cd ATEC2026_Simulation_Challenge
+curl https://static.atecup.com/atec2026/atec_robot_model.zip -o atec_robot_model.zip
+unzip atec_robot_model.zip -d atec_robot_model
+```
+
+---
+
+## 3. Running the Environments
+
+### 3.1 Environment Check
+
+```bash
+cd ATEC2026_Simulation_Challenge
+python scripts/list_envs.py
+```
+
+Successful execution will list all registered environments, confirming correct module loading.
+
+---
+
+### 3.2 Visualization Utilities
+
+```bash
+scripts/view_robots.py – inspect robot models
+scripts/view_task_a.py – Task A visualization
+scripts/view_task_b.py – Task B visualization
+scripts/view_task_d.py – Task D visualization
+scripts/view_task_e.py – Task E visualization
+```
+
+Example:
+
+```
+python scripts/view_task_a.py --enable_cameras
+```
+
+---
+
+### 3.3 Submission and Evaluation
+
+Participants can test their solutions using:
+```bash
+cd ATEC2026_Simulation_Challenge
+
+python scripts/play_atec_task.py --task ATEC-TaskA-G1 --enable_cameras
+```
+
+#### Implementation Requirement
+
+Participants must implement demo/solution.py, and this file name can not be changed.
+* Class: AlgSolution
+* Function: predicts(obs, current_score), where **obs** is the observation, and **current_score** is the current score
+* Return: {"action": action, "giveup": False}, where action is the prediction action represented by List, and **giveup** is the giveup flag. if **giveup** is True, the scoring job will be terminated.
+
+
+### 3.4 Observations and Actions
+
+#### Tasks A / B / D
+
+Observations are grouped into:
+
+- `Proprioception`: base velocity, joint states, previous actions
+- `Exteroception`: LiDAR-based height scan
+- `Vision`: RGB-D images from head and end-effector cameras
+
+All observation terms are:
+
+- noise-injected
+- order-preserved
+- concatenated per group
+
+#### Task E (Manipulation-only)
+
+Observations include:
+
+- `Proprioception`: joint states (position + velocity)
+
+- `Vision`: RGB-D images from end-effector and external camera
+
+  
+
+**Note:** Joint indices follow fixed ordering per robot (critical for policy deployment).
+
+- b2_piper (20 DoF)
+- b2w_piper (24 DoF)
+- G1 (33 DoF)
+- tron1a_piper (16 DoF)
+- piper (8 DoF)
+
+#### Action Space
+
+Robot control actions are organized by joint type.
+
+- Leg joints and manipulator joints are controlled by joint position commands.
+- Wheel joints of wheeled robots are controlled by joint velocity commands.
+
+The action configuration is as follows:
+
+```
+joint_pos_leg = mdp.JointPositionActionCfg(
+    asset_name="robot",
+    joint_names=[""],
+    scale=0.5,
+    use_default_offset=True,
+    clip=None,
+    preserve_order=True,
+)
+
+joint_vel_wheel = mdp.JointVelocityActionCfg(
+    asset_name="robot",
+    joint_names=[""],
+    scale=5.0,
+    use_default_offset=True,
+    clip=None,
+    preserve_order=True,
+)
+
+joint_pos_arm = mdp.JointPositionActionCfg(
+    asset_name="robot",
+    joint_names=[""],
+    scale=0.5,
+    use_default_offset=True,
+    clip=None,
+    preserve_order=True,
+)
+```
+
+##### Scaling rules
+
+- Leg position commands are scaled by 0.5 before being applied to the robot.
+- Arm position commands are scaled by 0.5 before being applied to the robot.
+- Wheel velocity commands are scaled by 5.0 before being applied to the robot.
+
+Different robots enable different action items according to their structure:
+
+- Standard legged robots
+  (humanoid robots, quadruped mobile manipulator robots, manipulator) do not enable wheel velocity control.
+- Wheeled legged robots
+  (Dual-wheel legged mobile manipulator robots, quadruped-wheel legged mobile manipulator robots)
+  enable wheel velocity control.
+
+## Contributors
+- **[CUHK Legged Robot Lab](https://cuhkleggedrobotlab.github.io/)**
+- **[曾兆阳](https://zengzhaoyang.com/)**
+- **[ATEC (Advanced Technology Exploration Community)](https://www.atecup.com)**
+
+## License
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

scripts/list_envs.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""List all Gym environments registered under ``atec_rl_lab.tasks`` without importing Isaac Sim/Kit.
+
+This script avoids `import atec_rl_lab.tasks` because that may import IsaacLab/Omniverse modules (e.g., `carb`)
+in a pure Python environment. Instead, it scans task modules and executes only `gym.register(...)` statements.
+"""
+
+from __future__ import annotations
+
+import ast
+import sys
+from pathlib import Path
+
+import gymnasium as gym
+from prettytable import PrettyTable
+
+
+def _project_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _find_python_files(pkg_dir: Path) -> list[Path]:
+    return [
+        p for p in pkg_dir.rglob("*.py")
+        if p.name != "__pycache__"
+    ]
+
+
+def _exec_only_gym_register(py_file: Path) -> bool:
+    """Parse a python file and execute only top-level `gym.register(...)` calls.
+
+    Returns True if at least one register call was executed.
+    """
+    src = py_file.read_text(encoding="utf-8")
+    tree = ast.parse(src, filename=str(py_file))
+
+    register_calls: list[ast.stmt] = []
+    for node in tree.body:
+
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            names = []
+            if isinstance(node, ast.Import):
+                names = [n.name for n in node.names]
+            else:
+                mod = node.module or ""
+                names = [mod]
+            if any("gym" in n for n in names):
+                register_calls.append(node)
+        elif isinstance(node, ast.Expr) and isinstance(node.value, ast.Call):
+            call = node.value
+            # detect gym.register(...)
+            if isinstance(call.func, ast.Attribute) and call.func.attr == "register":
+                if isinstance(call.func.value, ast.Name) and call.func.value.id == "gym":
+                    register_calls.append(node)
+
+    if not register_calls:
+        return False
+
+    mod = ast.Module(body=register_calls, type_ignores=[])
+    code = compile(mod, filename=str(py_file), mode="exec")
+
+    # Execute in a controlled namespace: provide gymnasium as gym
+    ns: dict = {"gym": gym}
+    try:
+        exec(code, ns, ns)
+        return True
+    except Exception as e:
+        print(f"[WARN] Failed executing gym.register in {py_file}: {e}", file=sys.stderr)
+        return False
+
+
+def discover_tasks_without_import() -> int:
+    root = _project_root()
+    pkg_dir = root / "source" / "atec_rl_lab" / "atec_rl_lab" / "tasks"
+    if not pkg_dir.exists():
+        pkg_dir = root / "atec_rl_lab" / "tasks"
+
+    if not pkg_dir.exists():
+        raise FileNotFoundError(f"Cannot find tasks package dir under: {root}")
+
+    count = 0
+    for py in _find_python_files(pkg_dir):
+        if py.name in {"env_cfg.py", "scene_cfg.py", "envs_base_cfg.py"}:
+            continue
+        if _exec_only_gym_register(py):
+            count += 1
+    return count
+
+
+def main() -> None:
+    executed_files = discover_tasks_without_import()
+
+    table = PrettyTable(["S. No.", "Task Name", "Entry Point"])
+    table.title = f"Available Environments in ATEC RL Lab (scanned {executed_files} files)"
+    table.align["Task Name"] = "l"
+    table.align["Entry Point"] = "l"
+
+    index = 0
+    for task_spec in gym.registry.values():
+        if "ATEC" in task_spec.id and "Isaac" not in task_spec.id:
+            table.add_row([index + 1, task_spec.id, str(task_spec.entry_point)])
+            index += 1
+
+    print(table)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except ModuleNotFoundError as exc:
+        print(f"Failed to import dependencies while discovering tasks: {exc}")
+        raise

scripts/play_atec_task.py

@@ -0,0 +1,168 @@
+# Created by skywoodsz on 2026/02/07.
+
+import argparse
+import os
+import time
+import json
+
+from isaaclab.app import AppLauncher
+
+from demo.solution import AlgSolution
+solution = AlgSolution()
+
+# -----------------------------------------------------------------------------
+# CLI
+# -----------------------------------------------------------------------------
+parser = argparse.ArgumentParser(description="Play Atec Tasks (ENV only, no RL).")
+parser.add_argument("--video", action="store_true", default=False, help="Record videos during play.")
+parser.add_argument("--video_length", type=int, default=200, help="Length of the recorded video (in steps).")
+parser.add_argument(
+    "--disable_fabric", action="store_true", default=False, help="Disable fabric and use USD I/O operations."
+)
+parser.add_argument("--num_envs", type=int, default=1, help="Number of environments to simulate.")
+parser.add_argument("--task", type=str, default=None, help="Name of the task.")
+parser.add_argument("--real-time", action="store_true", default=False, help="Run in real-time, if possible.")
+parser.add_argument(
+    "--debug",
+    action="store_true",
+    default=False,
+    help="Enable debug prints for per-step reward/time metrics.",
+)
+
+# Isaac Sim / Kit args
+AppLauncher.add_app_launcher_args(parser)
+
+args_cli = parser.parse_args()
+
+# If recording video, need cameras enabled in IsaacLab/Kit
+if args_cli.video:
+    args_cli.enable_cameras = True
+
+# -----------------------------------------------------------------------------
+# Launch Isaac Sim / Kit
+# -----------------------------------------------------------------------------
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+# -----------------------------------------------------------------------------
+# Imports AFTER simulation_app is created (IsaacLab pattern)
+# -----------------------------------------------------------------------------
+import gymnasium as gym  # noqa: E402
+import torch  # noqa: E402
+
+from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
+from isaaclab.utils.dict import print_dict  # noqa: E402
+
+import atec_rl_lab.tasks  # noqa: F401, E402 (register your tasks)
+from isaaclab_tasks.utils import parse_env_cfg
+from rl_utils import camera_follow
+
+
+def play() -> tuple[float, float]:
+    if args_cli.task is None:
+        raise ValueError("Please provide --task, e.g. --task ATEC-TaskA-G1")
+
+    is_task_e = isinstance(args_cli.task, str) and args_cli.task.startswith("ATEC-TaskE")
+    # -------------------------------------------------------------------------
+    # Create env (plain Gym env)
+    # -------------------------------------------------------------------------
+    env_cfg = parse_env_cfg(
+        args_cli.task,
+        device=args_cli.device,
+        num_envs=args_cli.num_envs,
+        use_fabric=not args_cli.disable_fabric
+    )
+
+    env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None)
+
+    # Convert MARL -> single agent if needed (kept from your original script)
+    if isinstance(env.unwrapped, DirectMARLEnv):
+        env = multi_agent_to_single_agent(env)
+
+    # -------------------------------------------------------------------------
+    # Optional: video wrapper
+    # -------------------------------------------------------------------------
+    if args_cli.video:
+        # Put videos in ./logs/videos/play by default (edit as you like)
+        video_kwargs = {
+            "video_folder": os.path.abspath(os.path.join("logs", "videos", args_cli.task, "play")),
+            "step_trigger": lambda step: step == 0,
+            "video_length": args_cli.video_length,
+            "disable_logger": True,
+        }
+        print("[INFO] Recording videos during play.")
+        print_dict(video_kwargs, nesting=4)
+        env = gym.wrappers.RecordVideo(env, **video_kwargs)
+
+
+    # -------------------------------------------------------------------------
+    # Reset
+    # -------------------------------------------------------------------------
+    obs, _ = env.reset()
+
+    dt = env.unwrapped.step_dt if hasattr(env.unwrapped, "step_dt") else None
+    timestep = 0
+
+    # -------------------------------------------------------------------------
+    # Play loop
+    # -------------------------------------------------------------------------
+    total_episode_reward = 0.0
+    total_elapsed_time = 0.0
+    while simulation_app.is_running():
+        with torch.inference_mode():
+            start_time = time.time()
+
+            # ===== Your controller goes here =====
+            resp = solution.predicts(obs, total_episode_reward)
+            giveup = resp["giveup"]
+            if giveup:
+                break
+            actions = resp["action"]
+            actions = torch.tensor(actions, dtype=torch.float32, device='cuda').view(1, -1)
+            obs, reward, terminated, truncated, info = env.step(actions)
+            if not is_task_e:
+                camera_follow(env)
+
+            sim_dt = info["Step_dt"]
+            if isinstance(reward, torch.Tensor):
+                total_episode_reward += reward.mean().item() / sim_dt
+            else:
+                total_episode_reward += float(reward) / sim_dt
+
+            if isinstance(info, dict) and "Elapsed_Time" in info:
+                elapsed = info["Elapsed_Time"]  # simulation time from env as primary source
+                total_elapsed_time = elapsed.item() if hasattr(elapsed, "item") else float(elapsed)
+            elif dt is not None:
+                total_elapsed_time += dt  # wall clock time as fallback
+
+            if args_cli.debug:
+                print(f"total_episode_reward:{total_episode_reward: .2f}")
+                print(f"total_elapsed_time:{total_elapsed_time: .2f}")
+
+            done = (terminated.item() or truncated.item())
+            if done:
+                break
+
+            timestep += 1
+            # If recording one video, exit after video_length steps
+            if args_cli.video and timestep >= args_cli.video_length:
+                break
+
+            # Real-time pacing
+            if args_cli.real_time and dt is not None:
+                sleep_time = dt - (time.time() - start_time)
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+
+    env.close()
+
+    return total_episode_reward, total_elapsed_time
+
+
+if __name__ == "__main__":
+    score, elapsed_time = play()
+    print(f"score: {score:.2f}, elapsed_time: {elapsed_time:.2f} seconds")
+
+    # Finally, close the simulation app
+    print("Closing simulation app...")
+    simulation_app.close()

scripts/rl_utils.py

@@ -0,0 +1,46 @@
+import torch
+import isaaclab.utils.math as math_utils
+
+def camera_follow(env, robot_name: str = "robot", env_index: int = 0, alpha: float = 0.15):
+    unwrapped = env.unwrapped
+
+    if not hasattr(unwrapped, "viewport_camera_controller"):
+        return
+
+    try:
+        robot = unwrapped.scene[robot_name]
+    except KeyError as e:
+        raise KeyError(
+            f"Robot asset '{robot_name}' not found in env.unwrapped.scene."
+        ) from e
+
+    device = unwrapped.device
+
+    robot_pos = robot.data.root_pos_w[env_index]
+    robot_quat = robot.data.root_quat_w[env_index]
+
+    camera_offset = torch.tensor([-6.0, 0.0, 0.8], dtype=torch.float32, device=device)
+
+    target_camera_pos = math_utils.transform_points(
+        camera_offset.unsqueeze(0),
+        pos=robot_pos.unsqueeze(0),
+        quat=robot_quat.unsqueeze(0),
+    ).squeeze(0)
+
+    target_camera_pos[2] = torch.clamp(target_camera_pos[2], min=0.2)
+
+    if not hasattr(camera_follow, "_smooth_pos"):
+        camera_follow._smooth_pos = {}
+
+    if env_index not in camera_follow._smooth_pos:
+        camera_follow._smooth_pos[env_index] = target_camera_pos.clone()
+
+    smooth_camera_pos = camera_follow._smooth_pos[env_index]
+    smooth_camera_pos = (1.0 - alpha) * smooth_camera_pos + alpha * target_camera_pos
+    camera_follow._smooth_pos[env_index] = smooth_camera_pos
+
+    unwrapped.viewport_camera_controller.set_view_env_index(env_index=env_index)
+    unwrapped.viewport_camera_controller.update_view_location(
+        eye=smooth_camera_pos.detach().cpu().numpy(),
+        lookat=robot_pos.detach().cpu().numpy(),
+    )

scripts/view_robots.py

@@ -0,0 +1,109 @@
+# Created by skywoodsz on 2026/01/28.
+import argparse
+import itertools
+from isaaclab.app import AppLauncher
+
+# create argparser
+parser = argparse.ArgumentParser(description="View ATEC Robots.")
+parser.add_argument("--num_envs", type=int, default=1, help="Number of environments to spawn.")
+# append AppLauncher cli args
+AppLauncher.add_app_launcher_args(parser)
+# parse the arguments
+args_cli = parser.parse_args()
+# launch omniverse app
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+"""Rest everything follows."""
+import isaaclab.sim as sim_utils
+from isaaclab.assets import AssetBaseCfg
+from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
+from dataclasses import replace
+from atec_rl_lab.assets.robots import (
+    UNITREE_B2_CFG,
+    UNITREE_B2_PIPER_CFG,
+    UNITREE_B2W_CFG,
+    UNITREE_B2W_PIPER_CFG,
+    TRON1A_WHEEL_CFG,
+    TRON1A_PIPER_CFG,
+    TRON2A_LEGGED_CFG,
+    TRON2A_WHEEL_CFG,
+    PIPER_CFG,
+    UNITREE_G1_29DOF_DEX1_CFG
+)
+
+class ATECSceneCfg(InteractiveSceneCfg):
+    ground = AssetBaseCfg(
+        prim_path="/World/defaultGroundPlane", spawn=sim_utils.GroundPlaneCfg()
+    )
+
+    # lights
+    dome_light = AssetBaseCfg(
+        prim_path="/World/Light",
+        spawn=sim_utils.DomeLightCfg(intensity=3000.0, color=(0.75, 0.75, 0.75)),
+    )
+
+    b2 = replace(UNITREE_B2_CFG, prim_path="{ENV_REGEX_NS}/b2")
+
+    b2w = replace(UNITREE_B2W_CFG, prim_path="{ENV_REGEX_NS}/b2w")
+    b2w.init_state.pos = (b2w.init_state.pos[0], b2w.init_state.pos[1] + 1.0, b2w.init_state.pos[2] + 0.166)
+    
+    b2w_piper = replace(UNITREE_B2W_PIPER_CFG, prim_path="{ENV_REGEX_NS}/b2w_piper")
+    b2w_piper.init_state.pos = (b2w_piper.init_state.pos[0], b2w_piper.init_state.pos[1] + 2.0, b2w_piper.init_state.pos[2] + 0.166)
+
+    b2_piper = replace(UNITREE_B2_PIPER_CFG, prim_path="{ENV_REGEX_NS}/b2_piper")
+    b2_piper.init_state.pos = (b2_piper.init_state.pos[0], b2_piper.init_state.pos[1] + 3.0, b2_piper.init_state.pos[2] + 0.166)
+
+    tron1a = replace(TRON1A_WHEEL_CFG, prim_path="{ENV_REGEX_NS}/tron1a")
+    tron1a.init_state.pos = (tron1a.init_state.pos[0], tron1a.init_state.pos[1] + 4.0, tron1a.init_state.pos[2] + 0.166)
+
+    tron1a_piper = replace(TRON1A_PIPER_CFG, prim_path="{ENV_REGEX_NS}/tron1a_piper")
+    tron1a_piper.init_state.pos = (tron1a_piper.init_state.pos[0], tron1a_piper.init_state.pos[1] + 5.0, tron1a_piper.init_state.pos[2] + 0.166)
+    
+    tron2a_legged = replace(TRON2A_LEGGED_CFG, prim_path="{ENV_REGEX_NS}/tron2a_legged")
+    tron2a_legged.init_state.pos = (tron2a_legged.init_state.pos[0], tron2a_legged.init_state.pos[1] + 6.0, tron2a_legged.init_state.pos[2] + 0.166)
+
+    tron2a_wheel = replace(TRON2A_WHEEL_CFG, prim_path="{ENV_REGEX_NS}/tron2a_wheel")
+    tron2a_wheel.init_state.pos = (tron2a_wheel.init_state.pos[0], tron2a_wheel.init_state.pos[1] + 7.0, tron2a_wheel.init_state.pos[2] + 0.166)
+
+    piper = replace(PIPER_CFG, prim_path="{ENV_REGEX_NS}/piper")
+    piper.init_state.pos = (piper.init_state.pos[0], piper.init_state.pos[1] + 8.0, piper.init_state.pos[2])
+
+    g1 = replace(UNITREE_G1_29DOF_DEX1_CFG, prim_path="{ENV_REGEX_NS}/g1")
+    g1.init_state.pos = (g1.init_state.pos[0], g1.init_state.pos[1] + 9.0, g1.init_state.pos[2])
+
+def main():
+    # Initialize the simulation context
+    sim_cfg = sim_utils.SimulationCfg(dt=0.01, device=args_cli.device)
+    sim = sim_utils.SimulationContext(sim_cfg)
+    # Set main camera
+    sim.set_camera_view([2.0, 0.0, 2.5], [-0.5, 0.0, 0.5])
+
+    scene_cfg = ATECSceneCfg(
+        num_envs=args_cli.num_envs,
+        env_spacing=4.0,
+        replicate_physics=True
+    )
+    scene = InteractiveScene(scene_cfg)
+    # Play the simulator
+    sim.reset()
+    scene.reset()
+
+    for name, articulation in scene.articulations.items():
+        print("-"*100)
+        print("Robot name:", name)
+        print("Bodies:", articulation.num_bodies, "->", articulation.body_names)
+        print("Joints:", articulation.num_joints, "->", articulation.joint_names)
+        articulation.set_joint_position_target(articulation.data.default_joint_pos)
+
+    for i in itertools.count():
+        if not simulation_app.is_running():
+            break
+        scene.write_data_to_sim()
+        sim.step()
+        scene.update(sim.get_physics_dt())
+
+if __name__ == "__main__":
+    main()
+    # close sim app
+    simulation_app.close()

scripts/view_task_a.py

@@ -0,0 +1,57 @@
+# Created by skywoodsz on 2026/01/28.
+import argparse
+import itertools
+import torch
+from isaaclab.app import AppLauncher
+
+# create argparser
+parser = argparse.ArgumentParser(description="View ATEC Task A.")
+parser.add_argument(
+    "--num_envs", type=int, default=1, help="Number of environments to spawn."
+)
+# append AppLauncher cli args
+AppLauncher.add_app_launcher_args(parser)
+# parse the arguments
+args_cli = parser.parse_args()
+# launch omniverse app
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+"""Rest everything follows."""
+from isaaclab.envs import ManagerBasedRLEnv
+
+from atec_rl_lab.tasks.task_a import TaskAEnvB2Cfg
+
+
+def main():
+    env_cfg = TaskAEnvB2Cfg()
+    env_cfg.scene.num_envs = args_cli.num_envs
+
+    env = ManagerBasedRLEnv(env_cfg)
+
+    for name, articulation in env.scene.articulations.items():
+        print("-" * 100)
+        print("Robot name:", name)
+        print("Bodies:", articulation.num_bodies, "->", articulation.body_names)
+        print("Joints:", articulation.num_joints, "->", articulation.joint_names)
+        articulation.set_joint_position_target(articulation.data.default_joint_pos)
+
+    action_space = env.action_space
+    obs, info = env.reset()
+
+    for i in itertools.count():
+        if not simulation_app.is_running():
+            break
+        action = torch.zeros(action_space.shape, device=env.device)
+        obs, reward, terminated, truncated, info = env.step(action)
+        done = terminated | truncated
+
+        if done.any():
+            env_ids = done.nonzero(as_tuple=False).squeeze(-1)
+            env.reset(env_ids=env_ids)
+
+
+if __name__ == "__main__":
+    main()
+    # close sim app
+    simulation_app.close()

scripts/view_task_b.py

@@ -0,0 +1,58 @@
+# Created by skywoodsz on 2026/01/28.
+import argparse
+import itertools
+import torch
+from isaaclab.app import AppLauncher
+
+# create argparser
+parser = argparse.ArgumentParser(description="View ATEC Task A.")
+parser.add_argument(
+    "--num_envs", type=int, default=1, help="Number of environments to spawn."
+)
+# append AppLauncher cli args
+AppLauncher.add_app_launcher_args(parser)
+# parse the arguments
+args_cli = parser.parse_args()
+# launch omniverse app
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+"""Rest everything follows."""
+from isaaclab.envs import ManagerBasedRLEnv
+
+from atec_rl_lab.tasks.task_b import TaskBEnvB2Cfg
+
+
+def main():
+    env_cfg = TaskBEnvB2Cfg()
+    env_cfg.scene.num_envs = args_cli.num_envs
+
+    env = ManagerBasedRLEnv(env_cfg)
+
+    for name, articulation in env.scene.articulations.items():
+        print("-" * 100)
+        print("Robot name:", name)
+        print("Bodies:", articulation.num_bodies, "->", articulation.body_names)
+        print("Joints:", articulation.num_joints, "->", articulation.joint_names)
+        articulation.set_joint_position_target(articulation.data.default_joint_pos)
+
+    action_space = env.action_space
+    obs, info = env.reset()
+
+    for i in itertools.count():
+        if not simulation_app.is_running():
+            break
+        action = torch.zeros(action_space.shape, device=env.device)
+        obs, reward, terminated, truncated, info = env.step(action)
+        done = terminated | truncated
+
+        if done.any():
+            env_ids = done.nonzero(as_tuple=False).squeeze(-1)
+            env.reset(env_ids=env_ids)
+
+
+if __name__ == "__main__":
+    main()
+    # close sim app
+    simulation_app.close()
+

scripts/view_task_d.py

@@ -0,0 +1,58 @@
+# Created by skywoodsz on 2026/01/28.
+import argparse
+import itertools
+import torch
+from isaaclab.app import AppLauncher
+
+# create argparser
+parser = argparse.ArgumentParser(description="View ATEC Task D.")
+parser.add_argument(
+    "--num_envs", type=int, default=1, help="Number of environments to spawn."
+)
+# append AppLauncher cli args
+AppLauncher.add_app_launcher_args(parser)
+# parse the arguments
+args_cli = parser.parse_args()
+# launch omniverse app
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+"""Rest everything follows."""
+
+from isaaclab.envs import ManagerBasedRLEnv
+
+from atec_rl_lab.tasks.task_d import TaskDEnvB2Cfg
+
+
+def main():
+    env_cfg = TaskDEnvB2Cfg()
+    env_cfg.scene.num_envs = args_cli.num_envs
+
+    env = ManagerBasedRLEnv(env_cfg)
+
+    for name, articulation in env.scene.articulations.items():
+        print("-" * 100)
+        print("Robot name:", name)
+        print("Bodies:", articulation.num_bodies, "->", articulation.body_names)
+        print("Joints:", articulation.num_joints, "->", articulation.joint_names)
+        articulation.set_joint_position_target(articulation.data.default_joint_pos)
+
+    action_space = env.action_space
+    obs, info = env.reset()
+
+    for i in itertools.count():
+        if not simulation_app.is_running():
+            break
+        action = torch.zeros(action_space.shape, device=env.device)
+        obs, reward, terminated, truncated, info = env.step(action)
+        done = terminated | truncated
+        
+        if done.any():
+            env_ids = done.nonzero(as_tuple=False).squeeze(-1)
+            env.reset(env_ids=env_ids)
+
+
+if __name__ == "__main__":
+    main()
+    # close sim app
+    simulation_app.close()

scripts/view_task_e.py

@@ -0,0 +1,57 @@
+import argparse
+import itertools
+import torch
+from isaaclab.app import AppLauncher
+
+# create argparser
+parser = argparse.ArgumentParser(description="View ATEC Task E.")
+parser.add_argument(
+    "--num_envs", type=int, default=1, help="Number of environments to spawn."
+)
+# append AppLauncher cli args
+AppLauncher.add_app_launcher_args(parser)
+# parse the arguments
+args_cli = parser.parse_args()
+# launch omniverse app
+app_launcher = AppLauncher(args_cli)
+simulation_app = app_launcher.app
+
+"""Rest everything follows."""
+import isaaclab.sim as sim_utils
+from isaaclab.envs import ManagerBasedRLEnv
+from atec_rl_lab.tasks.task_e.env_cfg import TaskEEnvPiperCfg
+
+
+def main():
+    env_cfg = TaskEEnvPiperCfg()
+    env_cfg.scene.num_envs = args_cli.num_envs
+
+    env = ManagerBasedRLEnv(env_cfg)
+
+    for name, articulation in env.scene.articulations.items():
+        print("-" * 100)
+        print("Robot name:", name)
+        print("Bodies:", articulation.num_bodies, "->", articulation.body_names)
+        print("Joints:", articulation.num_joints, "->", articulation.joint_names)
+        articulation.set_joint_position_target(articulation.data.default_joint_pos)
+
+    action_space = env.action_space
+    obs, info = env.reset()
+
+    for i in itertools.count():
+        if not simulation_app.is_running():
+            break
+        action = torch.zeros(action_space.shape, device=env.device)
+        obs, reward, terminated, truncated, info = env.step(action)
+        done = terminated | truncated
+
+        if done.any():
+            env_ids = done.nonzero(as_tuple=False).squeeze(-1)
+            env.reset(env_ids=env_ids)
+
+
+if __name__ == "__main__":
+    main()
+    # close sim app
+    simulation_app.close()
+

source/atec_rl_lab/atec_rl_lab.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: atec_rl_lab
+Version: 0.2.1
+Summary: Reinforcement Learning Lab for ATEC 2026.
+Home-page: https://github.com/skywoodsz/ATEC2026_Simulation_Challenge
+Author: CUHK LRL
+Maintainer: CUHK LRL
+License: Apache 2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Requires-Dist: argcomplete
+Dynamic: home-page
+Dynamic: requires-python

source/atec_rl_lab/atec_rl_lab.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+setup.py
+atec_rl_lab/__init__.py
+atec_rl_lab.egg-info/PKG-INFO
+atec_rl_lab.egg-info/SOURCES.txt
+atec_rl_lab.egg-info/dependency_links.txt
+atec_rl_lab.egg-info/not-zip-safe
+atec_rl_lab.egg-info/requires.txt
+atec_rl_lab.egg-info/top_level.txt

source/atec_rl_lab/atec_rl_lab.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

source/atec_rl_lab/atec_rl_lab.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

source/atec_rl_lab/atec_rl_lab.egg-info/requires.txt

@@ -0,0 +1 @@
+argcomplete

source/atec_rl_lab/atec_rl_lab.egg-info/top_level.txt

@@ -0,0 +1 @@
+atec_rl_lab