Add DOMINO online-follow adjust_bottle dataset v1

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,112 @@
+---
+pretty_name: DOMINO Online-Follow Adjust Bottle
+language:
+- en
+license: apache-2.0
+task_categories:
+- robotics
+tags:
+- robotics
+- embodied-ai
+- dynamic-manipulation
+- vision-language-action
+- robot-manipulation
+- domino
+- aloha
+- video
+---
+
+# DOMINO Online-Follow: Adjust Bottle
+
+This dataset contains **50** successful `adjust_bottle` demonstrations for the
+ALOHA-AgileX embodiment in the DOMINO simulator.  Unlike the original
+precomputed-interception expert, the bottle first moves independently from outside
+the camera view and the expert repeatedly observes, approaches, follows, grasps,
+lifts, and completes the original upright placement task.  The controller does not
+receive a future object trajectory or a precomputed interception point.
+
+## Data summary
+
+- Episodes: **50** (25 left-arm, 25 right-arm)
+- Object assets: model 13 (**25**) and model 16 (**25**)
+- Recorded control frames: **16,651**
+- Cameras: `cam_high`, `cam_left_wrist`, `cam_right_wrist`
+- Camera frames fully decoded during audit: **66,604**
+- Nominal training FPS: **15**
+- Object speed: 0.040--0.117 m/s
+  (mean 0.0964, median 0.1010)
+- Entry angle: -7.4--7.4 degrees
+- Unique scene seeds: **30**
+- Unique scene-motion combinations: **50**
+- Mean demonstration duration: 10.61 seconds
+
+All 50 HDF5 episodes, instructions, trace files, and videos passed the repository
+quality checker.  All camera frames and videos were fully decoded; timestamps are
+strictly increasing; the inactive arm remains fixed; and no wrong-arm language
+labels were found.  Full per-episode provenance and the acceptance audit are in
+`summary.json` inside the archive.
+
+## Repository structure
+
+```text
+dataset/
+  adjust_bottle/
+    aloha-agilex_clean_follow_fast_50.zip
+provenance/
+  collect_data_dynamic_follow.py
+  demo_dynamicvla_follow_dataset.yml
+  adjust_bottle.py
+  adjust_bottle_instructions.json
+manifest.json
+LICENSE
+```
+
+The ZIP follows the public DOMINO naming/layout convention and expands to:
+
+```text
+aloha-agilex_clean_follow_fast/
+  data/          # episode0.hdf5 ... episode49.hdf5
+  instructions/  # 100 seen + 100 unseen language variants per episode
+  metrics/       # causal object/robot traces and quality measurements
+  video/         # one preview video per episode
+  scene_info.json
+  seed.txt
+  summary.json
+```
+
+Archive size: **0.56 GiB**  
+SHA-256: `bffbe20ba8be9e34b81a4e6c11d2435e6640b17918b85a23346f4568460104fe`
+
+## Download
+
+```bash
+hf download REPO_ID   dataset/adjust_bottle/aloha-agilex_clean_follow_fast_50.zip   --repo-type dataset --local-dir DOMINO-Online-Follow
+
+unzip DOMINO-Online-Follow/dataset/adjust_bottle/aloha-agilex_clean_follow_fast_50.zip -d data/adjust_bottle/
+```
+
+Replace `REPO_ID` with the dataset repository shown at the top of this page.
+
+## Training formats
+
+The archive is the canonical DOMINO HDF5 release.  It was also validated after
+conversion to LeRobot v2.1 (16,601 usable PUMA frames at
+15 FPS).  Derived LeRobot files and optical-flow/object-grounding
+caches are intentionally excluded to avoid duplicating images and publishing
+machine-specific runtime caches.  The conversion scripts are provided by PUMA in
+the DOMINO repository.
+
+## License and attribution
+
+Released under Apache-2.0, following the upstream DOMINO repository and dataset.
+If you use this data, cite the DOMINO paper and comply with the licenses of the
+DOMINO simulator and its underlying robot/object assets.
+
+```bibtex
+@article{fang2026towards,
+  title={Towards Generalizable Robotic Manipulation in Dynamic Environments},
+  author={Fang, Heng and Li, Shangru and Wang, Shuhan and Xi, Xuanyang and Liang, Dingkang and Bai, Xiang},
+  journal={arXiv preprint arXiv:2603.15620},
+  year={2026}
+}
+```

dataset/adjust_bottle/aloha-agilex_clean_follow_fast_50.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bffbe20ba8be9e34b81a4e6c11d2435e6640b17918b85a23346f4568460104fe
+size 603007635

manifest.json

@@ -0,0 +1,81 @@
+{
+  "schema_version": 1,
+  "dataset_name": "DOMINO Online-Follow Adjust Bottle",
+  "format": "DOMINO HDF5 archive",
+  "task": "adjust_bottle",
+  "embodiment": "aloha-agilex",
+  "condition": "clean",
+  "variant": "follow_fast",
+  "episodes": 50,
+  "source_bytes": 1047858870,
+  "episode_group_counts": {
+    "data": 50,
+    "instructions": 50,
+    "metrics": 50,
+    "video": 50
+  },
+  "artifact": {
+    "path": "dataset/adjust_bottle/aloha-agilex_clean_follow_fast_50.zip",
+    "size_bytes": 603007635,
+    "sha256": "bffbe20ba8be9e34b81a4e6c11d2435e6640b17918b85a23346f4568460104fe",
+    "file_count": 203,
+    "internal_root": "aloha-agilex_clean_follow_fast"
+  },
+  "provenance_files": {
+    "provenance/collect_data_dynamic_follow.py": {
+      "size_bytes": 66930,
+      "sha256": "4a501aeac4ab2643d360fd1ef1815656e969ef9e38049466ec0ac510d52add40"
+    },
+    "provenance/demo_dynamicvla_follow_dataset.yml": {
+      "size_bytes": 5139,
+      "sha256": "70a5f92d88006b27bdc6578df5fd21f6c4dc5a341eb595f1f09b2effc5a7750d"
+    },
+    "provenance/adjust_bottle.py": {
+      "size_bytes": 8544,
+      "sha256": "bd122764af3f2f3e8b236280983e8949506c5e96b4b9040529812d61ee48f115"
+    },
+    "provenance/adjust_bottle_instructions.json": {
+      "size_bytes": 2890,
+      "sha256": "3168108cde17a45c0671bda463a46559c4a3e1b0f914324a28c2999b505cf7eb"
+    }
+  },
+  "source_summary_sha256": "7cb74255a3380c5346b548c544a2d89013ec98c5683b3b9d0eef12e7195ceede",
+  "source_finalized_at_utc": "2026-07-28T15:28:44.229534+00:00",
+  "quality_audit": {
+    "audited_at_utc": "2026-07-28T15:39:36.607029+00:00",
+    "repository_checker_clean_episodes": 50,
+    "hdf5_episodes_opened": 50,
+    "hdf5_frames": 16651,
+    "camera_frames_fully_decoded": 66604,
+    "inactive_arm_max_delta_rad": 0.0,
+    "native_timestamps_strictly_increasing": true,
+    "trace_timestamps_match_recorded_timestep": true,
+    "mp4_metadata_validated": 50,
+    "mp4_videos_fully_decoded": 50,
+    "visual_contact_sheet_reviewed": true,
+    "instruction_files_validated": 50,
+    "language_variants_seen_per_episode": 100,
+    "language_variants_unseen_per_episode": 100,
+    "wrong_arm_language_labels": 0,
+    "issues": []
+  },
+  "repository": {
+    "commit": "1c215da781d38cd7defe9aac7a0c9eee661e8726",
+    "dirty": true,
+    "tracked_changes": [
+      "M description/task_instruction/adjust_bottle.json",
+      " M envs/adjust_bottle.py",
+      " M policy/PUMA/PUMA/dataloader/gr00t_lerobot/mixtures.py",
+      "MM script/collect_data_dynamic_follow.py",
+      " M task_config/demo_dynamicvla_follow_dataset.yml",
+      "?? script/publish_dynamic_follow_dataset.py"
+    ],
+    "origin": "https://github.com/H-EmbodVis/DOMINO.git"
+  },
+  "excluded_derived_data": [
+    "ALOHA conversion copy",
+    "LeRobot conversion copy",
+    "history optical-flow cache",
+    "object-grounding cache"
+  ]
+}

provenance/adjust_bottle.py

@@ -0,0 +1,226 @@
+from ._base_task import Base_Task
+from .utils import *
+import sapien
+import math
+import numpy as np
+
+
+class adjust_bottle(Base_Task):
+
+    def setup_demo(self, **kwags):
+        self._forced_qpose_tag = kwags.get("forced_qpose_tag")
+        self._forced_model_id = kwags.get("forced_model_id")
+        super()._init_task_env_(**kwags)
+
+    def load_actors(self):
+
+        self.qpose_tag = np.random.randint(0, 2)
+        qposes = [[0.707, 0.0, 0.0, -0.707], [0.707, 0.0, 0.0, 0.707]]
+        xlims = [[-0.12, -0.08], [0.08, 0.12]]
+
+        self.model_id = np.random.choice([13, 16])
+        # Optional dataset-balancing controls.  Draw the normal random values
+        # first so the remaining scene RNG stream is unchanged; default task
+        # behavior therefore stays byte-for-byte compatible.
+        if self._forced_qpose_tag is not None:
+            forced_qpose_tag = int(self._forced_qpose_tag)
+            if forced_qpose_tag not in (0, 1):
+                raise ValueError("forced_qpose_tag must be 0 (left) or 1 (right)")
+            self.qpose_tag = forced_qpose_tag
+        if self._forced_model_id is not None:
+            forced_model_id = int(self._forced_model_id)
+            if forced_model_id not in (13, 16):
+                raise ValueError("forced_model_id must be 13 or 16")
+            self.model_id = forced_model_id
+
+        self.bottle = rand_create_actor(
+            self,
+            xlim=xlims[self.qpose_tag],
+            ylim=[-0.13, -0.08],
+            zlim=[0.752],
+            rotate_rand=True,
+            qpos=qposes[self.qpose_tag],
+            modelname="001_bottle",
+            convex=True,
+            rotate_lim=(0, 0, 0.4),
+            model_id=self.model_id,
+        )
+
+        if self.use_dynamic:
+            self.bottle.set_mass(0.01)
+            for component in self.bottle.actor.get_components():
+                if isinstance(component, sapien.physx.PhysxRigidDynamicComponent):
+                    component.set_linear_damping(10.0)
+                    component.set_angular_damping(10.0)
+
+        self.delay(4)
+        self.add_prohibit_area(self.bottle, padding=0.15)
+        self.left_target_pose = [-0.25, -0.12, 0.95, 0, 1, 0, 0]
+        self.right_target_pose = [0.25, -0.12, 0.95, 0, 1, 0, 0]
+
+    def play_once(self):
+        if self.use_dynamic:
+            return self._play_once_dynamic()
+        else:
+            return self._play_once_static()
+
+    def _play_once_static(self):
+        arm_tag = ArmTag("right" if self.qpose_tag == 1 else "left")
+        target_pose = (self.right_target_pose if self.qpose_tag == 1 else self.left_target_pose)
+
+        # Grasp -> Lift
+        self.move(self.grasp_actor(self.bottle, arm_tag=arm_tag, pre_grasp_dis=0.1))
+        self.move(self.move_by_displacement(arm_tag=arm_tag, z=0.1, move_axis="arm"))
+
+        # Place
+        self.move(
+            self.place_actor(
+                self.bottle,
+                target_pose=target_pose,
+                arm_tag=arm_tag,
+                functional_point_id=0,
+                pre_dis=0.0,
+                is_open=False,
+            ))
+
+        self.info["info"] = {
+            "{A}": f"001_bottle/base{self.model_id}",
+            "{a}": str(arm_tag),
+        }
+        return self.info
+
+    def _play_once_dynamic(self):
+        arm_tag = ArmTag("right" if self.qpose_tag == 1 else "left")
+        target_pose = (self.right_target_pose if self.qpose_tag == 1 else self.left_target_pose)
+
+        current_bottle_pose = self.bottle.get_pose()
+        end_position = np.array([current_bottle_pose.p[0], current_bottle_pose.p[1], current_bottle_pose.p[2]])
+
+        self._intercept_position = end_position.copy()
+
+        def robot_action_sequence_sync(need_plan_mode):
+            grasp_result = self.grasp_actor(self.bottle, arm_tag=arm_tag, pre_grasp_dis=0.1)
+            if not grasp_result or grasp_result[1] is None or len(grasp_result[1]) == 0:
+                return
+            self.move(grasp_result)
+
+        table_bounds = (-0.35, 0.35, -0.25, 0.15)
+        success, start_pos = self.execute_dynamic_workflow(
+            target_actor=self.bottle,
+            end_position=end_position,
+            robot_action_sequence=robot_action_sequence_sync,
+            table_bounds=table_bounds,
+        )
+
+        if not success:
+            raise RuntimeError("Failed to generate dynamic trajectory")
+
+        for component in self.bottle.actor.get_components():
+            if isinstance(component, sapien.physx.PhysxRigidDynamicComponent):
+                try:
+                    component.set_linear_velocity(np.zeros(3))
+                    component.set_angular_velocity(np.zeros(3))
+                    component.set_linear_damping(10.0)
+                    component.set_angular_damping(10.0)
+                except Exception:
+                    pass
+
+        self.move(self.move_by_displacement(arm_tag=arm_tag, z=0.1, move_axis="arm"))
+
+        self.move(
+            self.place_actor(
+                self.bottle,
+                target_pose=target_pose,
+                arm_tag=arm_tag,
+                functional_point_id=0,
+                pre_dis=0.0,
+                is_open=False,
+            ))
+
+        self.info["info"] = {
+            "{A}": f"001_bottle/base{self.model_id}",
+            "{a}": str(arm_tag),
+        }
+        return self.info
+
+    def get_dynamic_motion_config(self) -> dict:
+        if not self.use_dynamic:
+            return None
+        current_bottle_pose = self.bottle.get_pose()
+        end_position = np.array([current_bottle_pose.p[0], current_bottle_pose.p[1], current_bottle_pose.p[2]])
+        
+        return {
+            'target_actor': self.bottle,
+            'end_position': end_position,
+            'table_bounds': (-0.35, 0.35, -0.15, 0.25),
+        }
+    
+    def check_success(self):
+        target_hight = 0.9
+        bottle_pose = self.bottle.get_functional_point(0)
+        basic_check= ((self.qpose_tag == 0 and bottle_pose[0] < -0.15) or
+                (self.qpose_tag == 1 and bottle_pose[0] > 0.15)) and bottle_pose[2] > target_hight
+        if (not self.use_dynamic) or getattr(self, 'eval_mode', False):
+            return basic_check
+        
+        intercept_pos = getattr(self, '_intercept_position', None)
+        if intercept_pos is None:
+            return basic_check
+
+        current_center = self.bottle.get_pose().p
+        displacement = np.linalg.norm(current_center - intercept_pos)
+        displacement_threshold = 0.1
+        displacement_check = displacement > displacement_threshold
+
+        left_ee_pose = self.robot.get_left_ee_pose()
+        right_ee_pose = self.robot.get_right_ee_pose()
+        left_ee_pos = np.array(left_ee_pose[:3])
+        right_ee_pos = np.array(right_ee_pose[:3])
+        
+        dist_to_left = np.linalg.norm(current_center[:2] - left_ee_pos[:2])
+        dist_to_right = np.linalg.norm(current_center[:2] - right_ee_pos[:2])
+        proximity_threshold = 0.15
+        proximity_check = (dist_to_left < proximity_threshold) or (dist_to_right < proximity_threshold)
+
+        return basic_check and displacement_check and proximity_check
+
+    def check_stable(self):
+        if not self.use_dynamic:
+            return super().check_stable()
+
+        from .utils import cal_quat_dis
+        actors_list, actors_pose_list = [], []
+        dynamic_name = self.bottle.get_name()
+
+        for actor in self.scene.get_all_actors():
+            if actor.get_name() != dynamic_name:
+                actors_list.append(actor)
+
+        def get_sim(p1, p2):
+            return np.abs(cal_quat_dis(p1.q, p2.q) * 180)
+
+        is_stable, unstable_list = True, []
+
+        def check(times):
+            nonlocal is_stable
+            for _ in range(times):
+                self._update_kinematic_tasks()
+                self.scene.step()
+                for idx, actor in enumerate(actors_list):
+                    actors_pose_list[idx].append(actor.get_pose())
+
+            for idx, actor in enumerate(actors_list):
+                final_pose = actors_pose_list[idx][-1]
+                for pose in actors_pose_list[idx][-200:]:
+                    if get_sim(final_pose, pose) > 3.0:
+                        is_stable = False
+                        unstable_list.append(actor.get_name())
+                        break
+
+        for _ in range(2000):
+            self._update_kinematic_tasks()
+            self.scene.step()
+        for actor in actors_list:
+            actors_pose_list.append([actor.get_pose()])
+        check(500)
+        return is_stable, unstable_list

provenance/adjust_bottle_instructions.json

@@ -0,0 +1,69 @@
+{
+  "full_description": "Pick up the bottle on the table headup with the correct arm",
+  "schema": "{A} notifies the bottle, {a} notifies the arm to manipulate the bottle",
+  "preference": "num of words should not exceed 15",
+  "seen": [
+    "Lift {A} head-up from the table.",
+    "Pick {A} up with {a} ensuring it stays head-up.",
+    "Grab {A} from the table and hold it head-up.",
+    "Utilize {a} to lift {A} while keeping it head-up.",
+    "Lift {A} ensuring it remains upright.",
+    "Grab {A} head-up using {a} from the table.",
+    "Hold {A} head-up after lifting it.",
+    "Use {a} to pick {A} up and keep it head-up.",
+    "Pick {A} head-up and hold it steady.",
+    "Use {a} to grab and lift {A} head-up.",
+    "Grab {A} from the table with {a}",
+    "Lift the bottle {A} headup from the table",
+    "Raise {A} in a head-up position",
+    "Use {a} to lift {A} head-up",
+    "Position {A} head-up and lift it",
+    "Grab {A} with {a} in a head-up way",
+    "Lift the bottle {A} up from the table",
+    "Pick {A} head-up using {a}",
+    "Grab {A} and lift it into a head-up position",
+    "Use {a} to pick up {A} in the correct orientation",
+    "Lift {A} from the table upright",
+    "Use {a} to hold {A} from the table",
+    "Identify {A} and grab it with {a}",
+    "Pick {A} upright from the table",
+    "Lift {A} using {a} and hold upright",
+    "Take {A} from the table and keep upright",
+    "Grab {A} and lift it with {a}",
+    "Pick up {A} upright from the table",
+    "Hold {A} upright after lifting with {a}",
+    "Lift {A} from the table and secure upright",
+    "Lift {A} from the table with {a}",
+    "Pick {A} upright from the table",
+    "Grab {A} and lift it upright",
+    "Lift {A} head-up from the table",
+    "Using {a}, pick {A} upright",
+    "Secure {A} upright with {a}",
+    "Hold {A} upright from the table",
+    "Pick {A} and keep it upright",
+    "Lift {A} upright carefully using {a}",
+    "Carefully grab {A} head-up",
+    "Pick up {A} from the table carefully.",
+    "Use {a} to pick up {A} from the table.",
+    "Locate {A} and lift it upright with {a}.",
+    "Raise {A} from the table using the correct arm, {a}.",
+    "Grab {A} and lift it upward from the table.",
+    "Use the correct arm to pick up {A}.",
+    "Lift {A} off the table and hold it upright.",
+    "Pick up {A} from the table using {a}.",
+    "Lift {A} from the table without mentioning the arm.",
+    "Find {A} on the table and raise it using {a}."
+  ],
+  "unseen": [
+    "Pick up {A} from the table head-up.",
+    "Use {a} to grab {A} head-up.",
+    "Use {a} to grab the bottle {A}",
+    "Pick up {A} using the correct arm",
+    "Grab {A} from the table with {a}",
+    "Pick up {A} carefully using {a}",
+    "Pick up {A} using {a} in an upright position",
+    "Use {a} to grab {A} upright",
+    "Lift {A} from the table using {a}.",
+    "Grab {A} on the table and raise it."
+  ]
+}

provenance/collect_data_dynamic_follow.py

@@ -0,0 +1,1659 @@
+#!/usr/bin/env python3
+"""Collect DynamicVLA-style online-follow demonstrations in DOMINO.
+
+This collector is deliberately separate from ``script/collect_data.py``.  It
+does not compute an interception point or pre-generate an object trajectory:
+
+1. the object receives one planar initial velocity and moves under PhysX;
+2. the robot observes only the current/past object poses and estimates velocity
+   with a finite difference;
+3. every short control horizon it replans to the updated approach/grasp pose;
+4. while closing, the object is released back to normal 6-DoF contact dynamics.
+
+The object pose is privileged teacher information used only to create the
+demonstration.  A learned policy is expected to infer the same temporal signal
+from images (for example with object-centric slots), not receive this pose at
+deployment time.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import time
+from dataclasses import dataclass, replace
+from pathlib import Path
+from statistics import NormalDist
+from typing import Any
+
+import numpy as np
+import sapien
+import transforms3d as t3d
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from envs._GLOBAL_CONFIGS import CONFIGS_PATH  # noqa: E402
+from envs.adjust_bottle import adjust_bottle  # noqa: E402
+from envs.utils import ArmTag  # noqa: E402
+
+
+_FATAL_INFRASTRUCTURE_ERROR_MARKERS = (
+    "errorextensionnotpresent",
+    "failed to find a supported physical device",
+    "failed to find device",
+    "vulkan",
+)
+
+
+def is_fatal_infrastructure_error(error: BaseException) -> bool:
+    """Return whether retrying with another scene seed cannot fix ``error``."""
+
+    message = f"{type(error).__name__}: {error}".lower()
+    return any(marker in message for marker in _FATAL_INFRASTRUCTURE_ERROR_MARKERS)
+
+
+@dataclass
+class FollowSettings:
+    controller_mode: str = "plan_prefix"
+    speed_x: float = 0.025
+    speed_y: float = 0.010
+    offscreen_start_x: float = 0.0
+    object_only_seconds: float = 0.55
+    prediction_horizon_seconds: float = 0.23
+    replanning_horizon_steps: int = 40
+    medium_horizon_steps: int = 80
+    catchup_horizon_steps: int = 160
+    frame_stride_steps: int = 8
+    pre_grasp_distance: float = 0.10
+    approach_tolerance: float = 0.025
+    grasp_tolerance: float = 0.018
+    follow_hold_seconds: float = 0.35
+    close_seconds: float = 0.72
+    release_fraction: float = 0.58
+    lift_height: float = 0.14
+    settle_seconds: float = 0.30
+    max_approach_cycles: int = 28
+    max_descend_cycles: int = 18
+    velocity_ema: float = 0.65
+    servo_replan_steps: int = 50
+    servo_position_gain: float = 5.0
+    servo_max_joint_velocity: float = 1.4
+    servo_max_joint_acceleration: float = 3.0
+    servo_max_position_lead: float = 0.08
+    complete_original_task: bool = False
+    place_max_seconds: float = 3.0
+    place_position_tolerance: float = 0.015
+    place_control_position_tolerance: float = 0.015
+    place_orientation_tolerance_degrees: float = 12.0
+    upright_axis_tolerance_degrees: float = 12.0
+    place_max_joint_velocity: float = 0.8
+    place_max_joint_acceleration: float = 1.2
+    object_mass_kg: float | None = None
+    held_linear_damping: float = 0.2
+    held_angular_damping: float = 5.0
+    held_static_friction: float | None = None
+    held_dynamic_friction: float | None = None
+    grasp_settle_seconds: float = 0.0
+    stabilize_grasp_with_drive: bool = False
+    grasp_drive_stiffness: float = 1.0e5
+    grasp_drive_damping: float = 1.0e3
+    grasp_drive_force_limit: float = 1.0e6
+    grasp_drive_limit_epsilon: float = 1.0e-6
+
+    @classmethod
+    def from_dict(cls, values: dict[str, Any] | None) -> "FollowSettings":
+        if not values:
+            return cls()
+        valid = cls.__dataclass_fields__.keys()
+        unknown = sorted(set(values) - set(valid))
+        if unknown:
+            raise ValueError(f"Unknown dynamic_follow settings: {unknown}")
+        settings = cls(**values)
+        if settings.controller_mode not in {"plan_prefix", "smooth_joint_servo"}:
+            raise ValueError(
+                "controller_mode must be 'plan_prefix' or 'smooth_joint_servo'"
+            )
+        if settings.complete_original_task and settings.controller_mode != "smooth_joint_servo":
+            raise ValueError(
+                "complete_original_task currently requires smooth_joint_servo"
+            )
+        return settings
+
+
+@dataclass
+class FollowDistributionSettings:
+    """Deterministic low-discrepancy schedule for a dataset-sized run."""
+
+    enabled: bool = False
+    schedule_size: int = 50
+    speed_mean: float = 0.08
+    speed_sigma: float = 0.1 / 3.0
+    speed_min: float = 0.04
+    speed_max: float = 0.10
+    entry_angle_max_degrees: float = 8.0
+    offscreen_start_min: float = 0.56
+    offscreen_start_max: float = 0.60
+    action_start_abs_x_min: float = 0.44
+    action_start_abs_x_max: float = 0.47
+    follow_hold_min: float = 0.50
+    follow_hold_max: float = 0.70
+
+    @classmethod
+    def from_dict(
+        cls, values: dict[str, Any] | None
+    ) -> "FollowDistributionSettings":
+        if not values:
+            return cls()
+        valid = cls.__dataclass_fields__.keys()
+        unknown = sorted(set(values) - set(valid))
+        if unknown:
+            raise ValueError(
+                f"Unknown dynamic_follow_distribution settings: {unknown}"
+            )
+        settings = cls(**values)
+        if settings.schedule_size <= 0:
+            raise ValueError("distribution schedule_size must be positive")
+        if not 0 < settings.speed_min <= settings.speed_max:
+            raise ValueError("distribution speed range must be positive and ordered")
+        if settings.speed_sigma <= 0:
+            raise ValueError("distribution speed_sigma must be positive")
+        for low_name, high_name in (
+            ("offscreen_start_min", "offscreen_start_max"),
+            ("action_start_abs_x_min", "action_start_abs_x_max"),
+            ("follow_hold_min", "follow_hold_max"),
+        ):
+            if getattr(settings, low_name) > getattr(settings, high_name):
+                raise ValueError(f"{low_name} must not exceed {high_name}")
+        if settings.action_start_abs_x_max >= settings.offscreen_start_min:
+            raise ValueError(
+                "action-start x must remain inside the minimum offscreen x"
+            )
+        return settings
+
+
+def van_der_corput(index: int, base: int) -> float:
+    """Return one element of a one-dimensional low-discrepancy sequence."""
+
+    value = 0.0
+    denominator = 1.0
+    while index > 0:
+        index, remainder = divmod(index, base)
+        denominator *= base
+        value += remainder / denominator
+    return value
+
+
+def build_follow_schedule(
+    base: FollowSettings,
+    distribution: FollowDistributionSettings,
+) -> list[tuple[FollowSettings, dict[str, float]]]:
+    """Create a reproducible schedule whose prefixes already cover the range.
+
+    Speed uses the configured clipped normal distribution.  The dataclass
+    defaults reproduce the old DOMINO sampler, while dataset configs may use a
+    harder profile.  Other variables use different low-discrepancy bases to
+    avoid coupling.
+    """
+
+    if not distribution.enabled:
+        speed = float(np.hypot(base.speed_x, base.speed_y))
+        angle = float(np.degrees(np.arctan2(base.speed_y, base.speed_x)))
+        return [
+            (
+                base,
+                {
+                    "target_speed_mps": speed,
+                    "entry_angle_degrees": angle,
+                    "offscreen_start_abs_x_m": base.offscreen_start_x,
+                    "action_start_abs_x_m": (
+                        base.offscreen_start_x
+                        - base.object_only_seconds * abs(base.speed_x)
+                    ),
+                    "object_only_seconds": base.object_only_seconds,
+                    "follow_hold_seconds": base.follow_hold_seconds,
+                },
+            )
+        ]
+
+    normal = NormalDist(distribution.speed_mean, distribution.speed_sigma)
+    schedule: list[tuple[FollowSettings, dict[str, float]]] = []
+    for episode in range(distribution.schedule_size):
+        # Base 2 gives useful prefix coverage: median, low, high, extreme-low.
+        speed_quantile = van_der_corput(episode + 1, 2)
+        raw_speed = abs(normal.inv_cdf(speed_quantile))
+        speed = float(
+            np.clip(raw_speed, distribution.speed_min, distribution.speed_max)
+        )
+
+        angle_unit = van_der_corput(episode + 1, 3)
+        angle_degrees = (
+            2.0 * angle_unit - 1.0
+        ) * distribution.entry_angle_max_degrees
+        angle_radians = np.radians(angle_degrees)
+        speed_x = float(speed * np.cos(angle_radians))
+        speed_y = float(speed * np.sin(angle_radians))
+
+        offscreen_unit = van_der_corput(episode + 1, 5)
+        offscreen_start = float(
+            distribution.offscreen_start_min
+            + offscreen_unit
+            * (distribution.offscreen_start_max - distribution.offscreen_start_min)
+        )
+        action_start_unit = van_der_corput(episode + 1, 7)
+        action_start_abs_x = float(
+            distribution.action_start_abs_x_min
+            + action_start_unit
+            * (
+                distribution.action_start_abs_x_max
+                - distribution.action_start_abs_x_min
+            )
+        )
+        object_only_seconds = (
+            offscreen_start - action_start_abs_x
+        ) / max(speed_x, 1e-6)
+
+        hold_unit = van_der_corput(episode + 1, 11)
+        follow_hold = float(
+            distribution.follow_hold_min
+            + hold_unit
+            * (distribution.follow_hold_max - distribution.follow_hold_min)
+        )
+        episode_settings = replace(
+            base,
+            speed_x=speed_x,
+            speed_y=speed_y,
+            offscreen_start_x=offscreen_start,
+            object_only_seconds=object_only_seconds,
+            follow_hold_seconds=follow_hold,
+        )
+        schedule.append(
+            (
+                episode_settings,
+                {
+                    "target_speed_mps": speed,
+                    "entry_angle_degrees": float(angle_degrees),
+                    "offscreen_start_abs_x_m": offscreen_start,
+                    "action_start_abs_x_m": action_start_abs_x,
+                    "object_only_seconds": float(object_only_seconds),
+                    "follow_hold_seconds": follow_hold,
+                },
+            )
+        )
+    return schedule
+
+
+class PoseVelocityObserver:
+    """Causal finite-difference velocity observer with light EMA smoothing."""
+
+    def __init__(self, dt: float, ema: float):
+        self.dt = float(dt)
+        self.ema = float(ema)
+        self.last_position: np.ndarray | None = None
+        self.last_step: int | None = None
+        self.velocity = np.zeros(3, dtype=np.float64)
+
+    def observe(self, position: np.ndarray, step: int) -> np.ndarray:
+        position = np.asarray(position, dtype=np.float64)
+        if self.last_position is not None and self.last_step is not None:
+            elapsed = max((step - self.last_step) * self.dt, self.dt)
+            measured = (position - self.last_position) / elapsed
+            self.velocity = self.ema * measured + (1.0 - self.ema) * self.velocity
+        self.last_position = position.copy()
+        self.last_step = int(step)
+        return self.velocity.copy()
+
+
+class OnlineFollowEpisode:
+    """State-machine controller and recorder for one demonstration."""
+
+    def __init__(self, env: adjust_bottle, settings: FollowSettings):
+        self.env = env
+        self.settings = settings
+        self.dt = float(env.scene.get_timestep())
+        self.sim_step = 0
+        self.stage = "initial"
+        self.target_pose = np.full(7, np.nan, dtype=np.float64)
+        self.observer = PoseVelocityObserver(self.dt, settings.velocity_ema)
+        self.records: dict[str, list[Any]] = {
+            "sim_step": [],
+            "sim_time_seconds": [],
+            "stage": [],
+            "object_position": [],
+            "object_linear_velocity_physics": [],
+            "object_linear_velocity_estimate": [],
+            "ee_position": [],
+            "target_position": [],
+            "gripper": [],
+            "arm_joint_position": [],
+            "arm_joint_velocity_command": [],
+        }
+        self._original_shape_materials: list[tuple[Any, Any]] = []
+        self._held_shape_materials: list[tuple[Any, Any]] = []
+        self._held_friction_actor_names: set[str] = set()
+        self._object_component = env._get_rigid_dynamic_component(env.bottle)
+        if self._object_component is None:
+            raise RuntimeError("Bottle has no PhysX rigid-dynamic component")
+        if settings.object_mass_kg is not None:
+            env.bottle.set_mass(float(settings.object_mass_kg))
+        self._released = False
+        self._grasp_drive: Any | None = None
+        self._grasp_contact_links: list[str] = []
+        self._servo_position: np.ndarray | None = None
+        self._servo_velocity = np.zeros(6, dtype=np.float64)
+        self._last_capture_sim_step: int | None = None
+
+    @property
+    def arm(self) -> str:
+        return "right" if self.env.qpose_tag == 1 else "left"
+
+    def _ee_pose(self) -> np.ndarray:
+        pose = (self.env.robot.get_right_ee_pose() if self.arm == "right"
+                else self.env.robot.get_left_ee_pose())
+        return np.asarray(pose, dtype=np.float64)
+
+    def _gripper_value(self) -> float:
+        return float(self.env.robot.get_right_gripper_val() if self.arm == "right"
+                     else self.env.robot.get_left_gripper_val())
+
+    def _object_position(self) -> np.ndarray:
+        return np.asarray(self.env.bottle.get_pose().p, dtype=np.float64)
+
+    def _arm_joint_position(self) -> np.ndarray:
+        values = (self.env.robot.get_right_arm_real_jointState()
+                  if self.arm == "right"
+                  else self.env.robot.get_left_arm_real_jointState())
+        return np.asarray(values[:-1], dtype=np.float64)
+
+    def _record(self) -> None:
+        object_position = self._object_position()
+        velocity_estimate = self.observer.velocity.copy()
+        try:
+            physics_velocity = np.asarray(
+                self._object_component.get_linear_velocity(), dtype=np.float64
+            )
+        except Exception:
+            physics_velocity = np.full(3, np.nan, dtype=np.float64)
+        self.records["sim_step"].append(self.sim_step)
+        self.records["sim_time_seconds"].append(self.sim_step * self.dt)
+        self.records["stage"].append(self.stage)
+        self.records["object_position"].append(object_position)
+        self.records["object_linear_velocity_physics"].append(physics_velocity)
+        self.records["object_linear_velocity_estimate"].append(velocity_estimate)
+        self.records["ee_position"].append(self._ee_pose()[:3])
+        self.records["target_position"].append(self.target_pose[:3].copy())
+        self.records["gripper"].append(self._gripper_value())
+        self.records["arm_joint_position"].append(self._arm_joint_position())
+        self.records["arm_joint_velocity_command"].append(
+            self._servo_velocity.copy()
+        )
+
+    def _capture(self) -> None:
+        # The final quality snapshot can coincide with the regular stride
+        # capture.  Never serialize the same simulator state twice: duplicate
+        # terminal frames create non-increasing native timestamps and subtly
+        # overweight the terminal action during training.
+        if self._last_capture_sim_step == self.sim_step:
+            return
+        self.env._update_render()
+        self.env._take_picture()
+        self._last_capture_sim_step = self.sim_step
+
+    def step(self, gripper_value: float | None = None) -> None:
+        if gripper_value is not None:
+            # A large epsilon applies the requested value directly.  The gripper
+            # drive itself remains force/contact controlled by PhysX.
+            self.env.robot.set_gripper(gripper_value, self.arm, gripper_eps=-1.0)
+        self.env._update_kinematic_tasks()
+        self.env.scene.step()
+        self.sim_step += 1
+        self._record()
+        if self.sim_step % self.settings.frame_stride_steps == 0:
+            self._capture()
+
+    def hold(self, steps: int, gripper_value: float | None = None) -> None:
+        for _ in range(max(0, int(steps))):
+            self.step(gripper_value=gripper_value)
+
+    def start_independent_motion(self, velocity: np.ndarray) -> None:
+        """Apply one physical velocity impulse on a frictionless planar surface."""
+
+        low_friction = self.env.scene.create_physical_material(0.0, 0.0, 0.0)
+        for actor in self.env.scene.get_all_actors():
+            if actor.get_name() not in {self.env.bottle.get_name(), "table"}:
+                continue
+            for component in actor.get_components():
+                if not hasattr(component, "get_collision_shapes"):
+                    continue
+                for shape in component.get_collision_shapes():
+                    self._original_shape_materials.append(
+                        (shape, shape.get_physical_material())
+                    )
+                    shape.set_physical_material(low_friction)
+
+        component = self._object_component
+        component.set_linear_damping(0.0)
+        component.set_angular_damping(0.0)
+        # Planar moving-platform dynamics: x/y are free; z and rotation are held
+        # until the fingers surround the object.  The pose is never teleported.
+        component.set_locked_motion_axes([False, False, True, True, True, True])
+        component.set_angular_velocity(np.zeros(3))
+        component.set_linear_velocity(np.asarray(velocity, dtype=np.float64))
+
+    def release_to_contact_dynamics(self) -> None:
+        if self._released:
+            return
+        for shape, material in self._original_shape_materials:
+            shape.set_physical_material(material)
+        self._original_shape_materials.clear()
+        if (
+            self.settings.held_static_friction is not None
+            and self.settings.held_dynamic_friction is not None
+        ):
+            held_material = self.env.scene.create_physical_material(
+                float(self.settings.held_static_friction),
+                float(self.settings.held_dynamic_friction),
+                0.0,
+            )
+            seen_shapes: set[int] = set()
+
+            def apply_held_material(entity: Any) -> None:
+                components = (
+                    entity.get_components()
+                    if hasattr(entity, "get_components")
+                    else [entity]
+                )
+                for component in components:
+                    if not hasattr(component, "get_collision_shapes"):
+                        continue
+                    for shape in component.get_collision_shapes():
+                        shape_id = id(shape)
+                        if shape_id in seen_shapes:
+                            continue
+                        seen_shapes.add(shape_id)
+                        self._held_shape_materials.append(
+                            (shape, shape.get_physical_material())
+                        )
+                        shape.set_physical_material(held_material)
+                        self._held_friction_actor_names.add(entity.get_name())
+
+            apply_held_material(self.env.bottle.actor)
+            active_gripper = (
+                self.env.robot.right_gripper
+                if self.arm == "right"
+                else self.env.robot.left_gripper
+            )
+            for joint_info in active_gripper:
+                apply_held_material(joint_info[0].child_link)
+            print(
+                "[dynamic-follow] held contact material: "
+                f"{len(self._held_shape_materials)} shapes on "
+                f"{sorted(self._held_friction_actor_names)}"
+            )
+        self._object_component.set_locked_motion_axes([False] * 6)
+        self._object_component.set_linear_damping(
+            self.settings.held_linear_damping
+        )
+        self._object_component.set_angular_damping(
+            self.settings.held_angular_damping
+        )
+        self._released = True
+
+    def restore_materials(self) -> None:
+        if self._grasp_drive is not None:
+            try:
+                self._grasp_drive.disable()
+            except Exception:
+                pass
+            self._grasp_drive = None
+        for shape, material in (
+            self._held_shape_materials + self._original_shape_materials
+        ):
+            try:
+                shape.set_physical_material(material)
+            except Exception:
+                pass
+        self._held_shape_materials.clear()
+        self._original_shape_materials.clear()
+
+    def attach_verified_grasp_drive(self) -> None:
+        """Stabilize an already physical, bilateral grasp without teleporting."""
+
+        active_gripper = (
+            self.env.robot.right_gripper
+            if self.arm == "right"
+            else self.env.robot.left_gripper
+        )
+        finger_links = [joint_info[0].child_link for joint_info in active_gripper]
+        finger_names = {link.get_name() for link in finger_links}
+        bottle_name = self.env.bottle.get_name()
+        contacting: set[str] = set()
+        for contact in self.env.scene.get_contacts():
+            name0 = contact.bodies[0].entity.name
+            name1 = contact.bodies[1].entity.name
+            if name0 == bottle_name and name1 in finger_names:
+                contacting.add(name1)
+            elif name1 == bottle_name and name0 in finger_names:
+                contacting.add(name0)
+        self._grasp_contact_links = sorted(contacting)
+        if contacting != finger_names:
+            raise RuntimeError(
+                "grasp stabilization requires bilateral finger contact: "
+                f"expected={sorted(finger_names)} actual={sorted(contacting)}"
+            )
+
+        ee_joint = (
+            self.env.robot.right_ee
+            if self.arm == "right"
+            else self.env.robot.left_ee
+        )
+        parent_link = ee_joint.child_link
+        parent_pose = parent_link.get_pose()
+        child_pose = self._object_component.get_pose()
+        pose_in_parent = parent_pose.inv() * child_pose
+        drive = self.env.scene.create_drive(
+            parent_link,
+            pose_in_parent,
+            self._object_component,
+            sapien.Pose(),
+        )
+        stiffness = float(self.settings.grasp_drive_stiffness)
+        damping = float(self.settings.grasp_drive_damping)
+        force_limit = float(self.settings.grasp_drive_force_limit)
+        for axis in ("x", "y", "z"):
+            getattr(drive, f"set_drive_property_{axis}")(
+                stiffness,
+                damping,
+                force_limit,
+                "acceleration",
+            )
+        drive.set_drive_property_slerp(
+            stiffness,
+            damping,
+            force_limit,
+            "acceleration",
+        )
+        limit_epsilon = float(self.settings.grasp_drive_limit_epsilon)
+        for axis in ("x", "y", "z"):
+            getattr(drive, f"set_limit_{axis}")(
+                -limit_epsilon, limit_epsilon
+            )
+        drive.set_limit_twist(-limit_epsilon, limit_epsilon)
+        drive.set_limit_cone(limit_epsilon, limit_epsilon)
+        drive.set_drive_target(sapien.Pose())
+        self._grasp_drive = drive
+        print(
+            "[dynamic-follow] verified bilateral grasp drive: "
+            f"{self._grasp_contact_links}"
+        )
+
+    def observe_target(self, offset: np.ndarray, quaternion: np.ndarray) -> np.ndarray:
+        object_position = self._object_position()
+        velocity = self.observer.observe(object_position, self.sim_step)
+        predicted_position = (
+            object_position
+            + np.asarray(offset, dtype=np.float64)
+            + self.settings.prediction_horizon_seconds * velocity
+        )
+        self.target_pose = np.concatenate([predicted_position, quaternion])
+        return self.target_pose.copy()
+
+    def plan(self, target_pose: np.ndarray) -> dict[str, Any]:
+        planner = (self.env.robot.right_plan_path if self.arm == "right"
+                   else self.env.robot.left_plan_path)
+        result = planner(target_pose.tolist())
+        if result.get("status") == "Success":
+            return result
+
+        # A failed predictive goal is retried at the current (non-extrapolated)
+        # object position.  This is still an online goal, not an intercept point.
+        fallback = target_pose.copy()
+        fallback[:3] -= self.settings.prediction_horizon_seconds * self.observer.velocity
+        self.target_pose = fallback
+        result = planner(fallback.tolist())
+        if result.get("status") != "Success":
+            raise RuntimeError(
+                f"{self.arm} planner failed during {self.stage}"
+            )
+        return result
+
+    def execute_plan_prefix(
+        self,
+        result: dict[str, Any],
+        max_steps: int,
+        close_progress: tuple[int, int] | None = None,
+    ) -> int:
+        positions = np.asarray(result["position"])
+        velocities = np.asarray(result["velocity"])
+        count = min(int(max_steps), len(positions))
+        if count <= 0:
+            raise RuntimeError("Planner returned an empty trajectory")
+        for index in range(count):
+            self.env.robot.set_arm_joints(positions[index], velocities[index], self.arm)
+            gripper = None
+            if close_progress is not None:
+                done, total = close_progress
+                fraction = min(1.0, (done + index + 1) / max(total, 1))
+                # Smooth closing avoids a visual/physical discontinuity.
+                smooth = fraction * fraction * (3.0 - 2.0 * fraction)
+                gripper = 1.0 - smooth
+                if (not self._released
+                        and fraction >= self.settings.release_fraction):
+                    self.release_to_contact_dynamics()
+            self.step(gripper_value=gripper)
+        return count
+
+    def _joint_goal_from_plan(self, result: dict[str, Any]) -> np.ndarray:
+        positions = np.asarray(result["position"], dtype=np.float64)
+        if positions.ndim != 2 or len(positions) == 0:
+            raise RuntimeError("Planner returned an invalid trajectory")
+        return positions[-1].copy()
+
+    def execute_smooth_servo(
+        self,
+        joint_goal: np.ndarray,
+        steps: int,
+        close_progress: tuple[int, int] | None = None,
+        fixed_gripper: float | None = None,
+        max_joint_velocity: float | None = None,
+        max_joint_acceleration: float | None = None,
+    ) -> int:
+        """Track a joint goal without resetting velocity at replans.
+
+        CuRobo supplies only a reachable goal.  This acceleration-limited
+        servo owns execution and carries its velocity state across every
+        online target update, removing the stop/start boundary conditions of
+        point-to-point motion plans.
+        """
+
+        joint_goal = np.asarray(joint_goal, dtype=np.float64)
+        if self._servo_position is None:
+            self._servo_position = self._arm_joint_position()
+            self._servo_velocity = np.zeros_like(self._servo_position)
+
+        count = max(0, int(steps))
+        max_velocity = float(
+            self.settings.servo_max_joint_velocity
+            if max_joint_velocity is None else max_joint_velocity
+        )
+        max_accel_step = float(
+            (
+                self.settings.servo_max_joint_acceleration
+                if max_joint_acceleration is None else max_joint_acceleration
+            )
+            * self.dt
+        )
+        max_lead = float(self.settings.servo_max_position_lead)
+
+        for index in range(count):
+            actual = self._arm_joint_position()
+            error = joint_goal - actual
+            desired_velocity = np.clip(
+                self.settings.servo_position_gain * error,
+                -max_velocity,
+                max_velocity,
+            )
+            velocity_delta = np.clip(
+                desired_velocity - self._servo_velocity,
+                -max_accel_step,
+                max_accel_step,
+            )
+            self._servo_velocity += velocity_delta
+            next_position = self._servo_position + self._servo_velocity * self.dt
+            # Do not let the high-stiffness drive target run far ahead of the
+            # physical articulation when contact or inertia causes lag.
+            next_position = actual + np.clip(
+                next_position - actual, -max_lead, max_lead
+            )
+            self._servo_position = next_position
+            self.env.robot.set_arm_joints(
+                self._servo_position, self._servo_velocity, self.arm
+            )
+
+            gripper = fixed_gripper
+            if close_progress is not None:
+                done, total = close_progress
+                fraction = min(1.0, (done + index + 1) / max(total, 1))
+                smooth = fraction * fraction * (3.0 - 2.0 * fraction)
+                gripper = 1.0 - smooth
+                if (not self._released
+                        and fraction >= self.settings.release_fraction):
+                    self.release_to_contact_dynamics()
+            self.step(gripper_value=gripper)
+        return count
+
+    def smooth_track_until(
+        self,
+        offset: np.ndarray,
+        quaternion: np.ndarray,
+        tolerance: float,
+        max_cycles: int,
+    ) -> None:
+        for cycle in range(max_cycles):
+            target = self.observe_target(offset, quaternion)
+            # The predicted target is a feed-forward control lead.  Arrival,
+            # however, must be judged against the object's pose *now*; using
+            # the lead point as the stopping condition makes a correctly
+            # tracking hand chase an intentionally moving goal indefinitely.
+            current_target = (
+                target[:3]
+                - self.settings.prediction_horizon_seconds
+                * self.observer.velocity
+            )
+            distance = float(
+                np.linalg.norm(self._ee_pose()[:3] - current_target)
+            )
+            if distance <= tolerance:
+                return
+            result = self.plan(target)
+            joint_goal = self._joint_goal_from_plan(result)
+            print(
+                f"[dynamic-follow] smooth stage={self.stage} cycle={cycle} "
+                f"current_error={distance:.3f}m "
+                f"execute={self.settings.servo_replan_steps}"
+            )
+            self.execute_smooth_servo(
+                joint_goal, self.settings.servo_replan_steps
+            )
+        current_target = (
+            self.target_pose[:3]
+            - self.settings.prediction_horizon_seconds
+            * self.observer.velocity
+        )
+        final_distance = float(
+            np.linalg.norm(self._ee_pose()[:3] - current_target)
+        )
+        raise RuntimeError(
+            f"{self.stage} did not converge: final EE target error={final_distance:.3f} m"
+        )
+
+    def smooth_follow_for(
+        self,
+        offset: np.ndarray,
+        quaternion: np.ndarray,
+        seconds: float,
+    ) -> None:
+        remaining = max(1, round(seconds / self.dt))
+        while remaining > 0:
+            target = self.observe_target(offset, quaternion)
+            result = self.plan(target)
+            count = min(self.settings.servo_replan_steps, remaining)
+            self.execute_smooth_servo(self._joint_goal_from_plan(result), count)
+            remaining -= count
+
+    def smooth_close_while_following(
+        self,
+        offset: np.ndarray,
+        quaternion: np.ndarray,
+    ) -> None:
+        total = max(1, round(self.settings.close_seconds / self.dt))
+        done = 0
+        while done < total:
+            target = self.observe_target(offset, quaternion)
+            result = self.plan(target)
+            count = min(self.settings.servo_replan_steps, total - done)
+            self.execute_smooth_servo(
+                self._joint_goal_from_plan(result),
+                count,
+                close_progress=(done, total),
+            )
+            done += count
+        self.release_to_contact_dynamics()
+
+    def smooth_lift(self) -> None:
+        start = self._ee_pose().copy()
+        start_rotation = t3d.quaternions.quat2mat(start[3:])
+        # Match Base_Task.move_by_displacement(..., move_axis="arm"): for
+        # this side grasp, negative tool-x is the gripper's natural upward
+        # withdrawal direction and is more reachable than forcing world-z.
+        lift_direction = -start_rotation[:, 0]
+        lift_direction /= max(np.linalg.norm(lift_direction), 1e-12)
+        final_target = start.copy()
+        final_target[:3] += self.settings.lift_height * lift_direction
+        # The lift target is static once the grasp is secured.  Clear the
+        # motion predictor so a planner retry is not shifted sideways by the
+        # bottle's obsolete pre-grasp velocity estimate.
+        self.observer.velocity[:] = 0.0
+
+        # Two shorter plans are substantially easier for CuRobo than one
+        # 14-cm jump near the table, while preserving the same total height
+        # and two-second control budget.
+        max_steps = max(2, round(2.0 / self.dt))
+        stage_steps = max(1, max_steps // 2)
+        chunk = self.settings.servo_replan_steps
+        for fraction in (0.5, 1.0):
+            target = start.copy()
+            target[:3] += (
+                self.settings.lift_height * fraction * lift_direction
+            )
+            self.target_pose = target.copy()
+            result = self.plan(target)
+            joint_goal = self._joint_goal_from_plan(result)
+            remaining = stage_steps
+            while remaining > 0:
+                distance = float(
+                    np.linalg.norm(self._ee_pose()[:3] - target[:3])
+                )
+                if distance <= 0.012:
+                    break
+                count = min(chunk, remaining)
+                self.execute_smooth_servo(
+                    joint_goal, count, fixed_gripper=0.0
+                )
+                remaining -= count
+
+        distance = float(
+            np.linalg.norm(self._ee_pose()[:3] - final_target[:3])
+        )
+        if distance > 0.025:
+            raise RuntimeError(f"smooth lift did not converge: error={distance:.3f} m")
+
+    @staticmethod
+    def quaternion_error_degrees(
+        quaternion: np.ndarray,
+        target_quaternion: np.ndarray,
+    ) -> float:
+        quaternion = np.asarray(quaternion, dtype=np.float64)
+        target_quaternion = np.asarray(target_quaternion, dtype=np.float64)
+        quaternion /= max(np.linalg.norm(quaternion), 1e-12)
+        target_quaternion /= max(np.linalg.norm(target_quaternion), 1e-12)
+        cosine = float(np.clip(abs(np.dot(quaternion, target_quaternion)), 0.0, 1.0))
+        return float(np.degrees(2.0 * np.arccos(cosine)))
+
+    @staticmethod
+    def quaternion_z_axis(quaternion: np.ndarray) -> np.ndarray:
+        """Return the world-space local-z axis for a wxyz quaternion."""
+
+        quaternion = np.asarray(quaternion, dtype=np.float64)
+        quaternion /= max(np.linalg.norm(quaternion), 1e-12)
+        w, x, y, z = quaternion
+        return np.asarray(
+            [
+                2.0 * (x * z + w * y),
+                2.0 * (y * z - w * x),
+                1.0 - 2.0 * (x * x + y * y),
+            ],
+            dtype=np.float64,
+        )
+
+    @classmethod
+    def upright_axis_error_degrees(
+        cls,
+        quaternion: np.ndarray,
+        target_quaternion: np.ndarray,
+    ) -> float:
+        axis = cls.quaternion_z_axis(quaternion)
+        target_axis = cls.quaternion_z_axis(target_quaternion)
+        cosine = float(np.clip(np.dot(axis, target_axis), -1.0, 1.0))
+        return float(np.degrees(np.arccos(cosine)))
+
+    def smooth_place_upright(self) -> np.ndarray:
+        """Carry the grasped bottle to the original task's upright side pose."""
+
+        task_target = np.asarray(
+            self.env.right_target_pose if self.arm == "right"
+            else self.env.left_target_pose,
+            dtype=np.float64,
+        )
+        ee_start = self._ee_pose()
+        functional_start = self.env.bottle.get_functional_point(0, "pose")
+        functional_start_position = np.asarray(
+            functional_start.p, dtype=np.float64
+        )
+        functional_start_rotation = t3d.quaternions.quat2mat(
+            np.asarray(functional_start.q, dtype=np.float64)
+        )
+        ee_target = np.asarray(
+            self.env.get_place_pose(
+                self.env.bottle,
+                ArmTag(self.arm),
+                task_target,
+                functional_point_id=0,
+                pre_dis=0.0,
+            ),
+            dtype=np.float64,
+        )
+
+        # get_place_pose(auto) aligns the bottle using the grasp direction.
+        # Recover that actual functional-point target from the same rigid EE
+        # transform instead of comparing against task_target's raw quaternion.
+        ee_start_rotation = t3d.quaternions.quat2mat(ee_start[3:])
+        ee_target_rotation = t3d.quaternions.quat2mat(ee_target[3:])
+        start_to_target_rotation = (
+            ee_target_rotation @ ee_start_rotation.T
+        )
+        functional_target_position = (
+            ee_target[:3]
+            + start_to_target_rotation
+            @ (functional_start_position - ee_start[:3])
+        )
+        functional_target_quaternion = t3d.quaternions.mat2quat(
+            start_to_target_rotation @ functional_start_rotation
+        )
+        functional_target = np.concatenate(
+            [functional_target_position, functional_target_quaternion]
+        )
+        self.target_pose = ee_target.copy()
+        # This target is static and unrelated to the earlier motion predictor.
+        self.observer.velocity[:] = 0.0
+        result = self.plan(ee_target)
+        joint_goal = self._joint_goal_from_plan(result)
+        remaining = max(1, round(self.settings.place_max_seconds / self.dt))
+        chunk = self.settings.servo_replan_steps
+        while remaining > 0:
+            ee_pose = self._ee_pose()
+            position_error = float(np.linalg.norm(ee_pose[:3] - ee_target[:3]))
+            orientation_error = self.quaternion_error_degrees(
+                ee_pose[3:], ee_target[3:]
+            )
+            if (
+                position_error
+                <= self.settings.place_control_position_tolerance
+                and orientation_error
+                <= self.settings.place_orientation_tolerance_degrees
+            ):
+                return functional_target
+            count = min(chunk, remaining)
+            self.execute_smooth_servo(
+                joint_goal,
+                count,
+                fixed_gripper=0.0,
+                max_joint_velocity=self.settings.place_max_joint_velocity,
+                max_joint_acceleration=self.settings.place_max_joint_acceleration,
+            )
+            remaining -= count
+
+        ee_pose = self._ee_pose()
+        position_error = float(np.linalg.norm(ee_pose[:3] - ee_target[:3]))
+        orientation_error = self.quaternion_error_degrees(
+            ee_pose[3:], ee_target[3:]
+        )
+        # The last servo chunk can be the one that crosses both tolerances.
+        # Re-check after it executes instead of unconditionally rejecting an
+        # otherwise valid trajectory when the step budget reaches zero.  At
+        # this terminal fallback, allow the task's upright tolerance: the
+        # definitive check below is performed on the bottle's functional
+        # point, where yaw around its upright axis is intentionally irrelevant.
+        if (
+            position_error <= self.settings.place_position_tolerance
+            and orientation_error
+            <= self.settings.upright_axis_tolerance_degrees
+        ):
+            return functional_target
+        raise RuntimeError(
+            "smooth upright placement did not converge: "
+            f"position_error={position_error:.3f}m "
+            f"orientation_error={orientation_error:.1f}deg"
+        )
+
+    def smooth_settle(self, seconds: float) -> None:
+        # Braking is acceleration limited as well; no final velocity snap.
+        goal = self._arm_joint_position()
+        self.execute_smooth_servo(
+            goal, round(seconds / self.dt), fixed_gripper=0.0
+        )
+
+    def track_until(
+        self,
+        offset: np.ndarray,
+        quaternion: np.ndarray,
+        tolerance: float,
+        max_cycles: int,
+    ) -> None:
+        for cycle in range(max_cycles):
+            target = self.observe_target(offset, quaternion)
+            distance = float(np.linalg.norm(self._ee_pose()[:3] - target[:3]))
+            if distance <= tolerance:
+                return
+            result = self.plan(target)
+            if distance > 0.12:
+                horizon = self.settings.catchup_horizon_steps
+            elif distance > 0.06:
+                horizon = self.settings.medium_horizon_steps
+            else:
+                horizon = self.settings.replanning_horizon_steps
+            horizon = min(horizon, len(result["position"]))
+            print(
+                f"[dynamic-follow] stage={self.stage} cycle={cycle} "
+                f"error={distance:.3f}m plan={len(result['position'])} "
+                f"execute={horizon}"
+            )
+            self.execute_plan_prefix(result, horizon)
+        final_distance = float(np.linalg.norm(self._ee_pose()[:3] - self.target_pose[:3]))
+        raise RuntimeError(
+            f"{self.stage} did not converge: final EE target error={final_distance:.3f} m"
+        )
+
+    def follow_for(
+        self,
+        offset: np.ndarray,
+        quaternion: np.ndarray,
+        seconds: float,
+    ) -> None:
+        remaining = max(1, round(seconds / self.dt))
+        while remaining > 0:
+            target = self.observe_target(offset, quaternion)
+            result = self.plan(target)
+            executed = self.execute_plan_prefix(
+                result, min(self.settings.replanning_horizon_steps, remaining)
+            )
+            remaining -= executed
+
+    def close_while_following(
+        self,
+        offset: np.ndarray,
+        quaternion: np.ndarray,
+    ) -> None:
+        total = max(1, round(self.settings.close_seconds / self.dt))
+        done = 0
+        while done < total:
+            target = self.observe_target(offset, quaternion)
+            result = self.plan(target)
+            executed = self.execute_plan_prefix(
+                result,
+                min(self.settings.replanning_horizon_steps, total - done),
+                close_progress=(done, total),
+            )
+            done += executed
+        self.release_to_contact_dynamics()
+
+    def lift(self) -> None:
+        current = self._ee_pose()
+        target = current.copy()
+        target[2] += self.settings.lift_height
+        self.target_pose = target
+        result = self.plan(target)
+        self.execute_plan_prefix(result, len(result["position"]))
+
+    def run(self) -> dict[str, Any]:
+        arm_tag = ArmTag(self.arm)
+        grasp_reference_position = self._object_position()
+
+        # Select a feasible grasp once.  Afterwards only its rigid offset and
+        # orientation are reused; the world target is recomputed online.
+        pre_pose, grasp_pose = self.env.choose_grasp_pose(
+            self.env.bottle,
+            arm_tag=arm_tag,
+            pre_dis=self.settings.pre_grasp_distance,
+            target_dis=0.0,
+        )
+        if pre_pose is None or grasp_pose is None:
+            raise RuntimeError("No feasible grasp pose")
+        pre_pose = np.asarray(pre_pose, dtype=np.float64)
+        grasp_pose = np.asarray(grasp_pose, dtype=np.float64)
+        pre_offset = pre_pose[:3] - grasp_reference_position
+        grasp_offset = grasp_pose[:3] - grasp_reference_position
+        quaternion = grasp_pose[3:].copy()
+
+        if self.settings.offscreen_start_x > 0:
+            pose = self.env.bottle.get_pose()
+            start_x = (self.settings.offscreen_start_x
+                       if self.arm == "right"
+                       else -self.settings.offscreen_start_x)
+            start_position = np.asarray(pose.p, dtype=np.float64)
+            start_position[0] = start_x
+            self.env.bottle.actor.set_pose(
+                sapien.Pose(p=start_position, q=pose.q)
+            )
+
+        initial_object_position = self._object_position()
+        initial_object_quaternion = np.asarray(
+            self.env.bottle.get_pose().q, dtype=np.float64
+        )
+        # Enter from the side assigned to the grasping arm.
+        x_direction = -1.0 if self.arm == "right" else 1.0
+        initial_velocity = np.array(
+            [x_direction * self.settings.speed_x, self.settings.speed_y, 0.0],
+            dtype=np.float64,
+        )
+
+        self.observer.observe(initial_object_position, self.sim_step)
+        self.stage = "object_only"
+        self.target_pose[:] = np.nan
+        self._capture()
+        self.start_independent_motion(initial_velocity)
+        self.hold(round(self.settings.object_only_seconds / self.dt))
+
+        self.stage = "approach_follow"
+        if self.settings.controller_mode == "smooth_joint_servo":
+            self.smooth_track_until(
+                pre_offset,
+                quaternion,
+                self.settings.approach_tolerance,
+                self.settings.max_approach_cycles,
+            )
+        else:
+            self.track_until(
+                pre_offset,
+                quaternion,
+                self.settings.approach_tolerance,
+                self.settings.max_approach_cycles,
+            )
+
+        self.stage = "follow_above"
+        if self.settings.controller_mode == "smooth_joint_servo":
+            self.smooth_follow_for(
+                pre_offset, quaternion, self.settings.follow_hold_seconds
+            )
+        else:
+            self.follow_for(pre_offset, quaternion, self.settings.follow_hold_seconds)
+
+        self.stage = "descend_follow"
+        if self.settings.controller_mode == "smooth_joint_servo":
+            self.smooth_track_until(
+                grasp_offset,
+                quaternion,
+                self.settings.grasp_tolerance,
+                self.settings.max_descend_cycles,
+            )
+        else:
+            self.track_until(
+                grasp_offset,
+                quaternion,
+                self.settings.grasp_tolerance,
+                self.settings.max_descend_cycles,
+            )
+
+        self.stage = "close_follow"
+        if self.settings.controller_mode == "smooth_joint_servo":
+            self.smooth_close_while_following(grasp_offset, quaternion)
+        else:
+            self.close_while_following(grasp_offset, quaternion)
+
+        if self.settings.grasp_settle_seconds > 0:
+            self.stage = "grasp_settle"
+            if self.settings.controller_mode == "smooth_joint_servo":
+                self.smooth_settle(self.settings.grasp_settle_seconds)
+            else:
+                self.hold(
+                    round(self.settings.grasp_settle_seconds / self.dt),
+                    gripper_value=0.0,
+                )
+
+        if self.settings.stabilize_grasp_with_drive:
+            self.attach_verified_grasp_drive()
+
+        self.stage = "lift"
+        before_lift = self._object_position()
+        if self.settings.controller_mode == "smooth_joint_servo":
+            self.smooth_lift()
+        else:
+            self.lift()
+
+        functional_target_pose: np.ndarray | None = None
+        if self.settings.complete_original_task:
+            self.stage = "upright_place"
+            functional_target_pose = self.smooth_place_upright()
+
+        self.stage = "settle"
+        self.target_pose[:] = np.nan
+        if self.settings.controller_mode == "smooth_joint_servo":
+            self.smooth_settle(self.settings.settle_seconds)
+        else:
+            self.hold(round(self.settings.settle_seconds / self.dt), gripper_value=0.0)
+        self._capture()
+
+        final_object_position = self._object_position()
+        final_ee_position = self._ee_pose()[:3]
+        object_motion = float(
+            np.linalg.norm(before_lift[:2] - initial_object_position[:2])
+        )
+        lift_delta = float(final_object_position[2] - before_lift[2])
+        final_object_ee_distance = float(
+            np.linalg.norm(final_object_position - final_ee_position)
+        )
+        functional_pose = self.env.bottle.get_functional_point(0, "pose")
+        final_functional_position = np.asarray(
+            functional_pose.p, dtype=np.float64
+        )
+        original_task_success: bool | None = None
+        upright_error_degrees: float | None = None
+        upright_axis_error_degrees: float | None = None
+        placement_position_error: float | None = None
+        final_functional_quaternion = np.asarray(
+            functional_pose.q, dtype=np.float64
+        )
+        if functional_target_pose is not None:
+            original_task_success = bool(self.env.check_success())
+            placement_position_error = float(
+                np.linalg.norm(
+                    final_functional_position - functional_target_pose[:3]
+                )
+            )
+            upright_error_degrees = self.quaternion_error_degrees(
+                final_functional_quaternion,
+                functional_target_pose[3:],
+            )
+            upright_axis_error_degrees = self.upright_axis_error_degrees(
+                final_functional_quaternion,
+                functional_target_pose[3:],
+            )
+
+        grasp_quality = bool(
+            object_motion >= 0.045
+            # This repository's EE pose is behind the finger center by roughly
+            # 12 cm, so a successfully enclosed bottle naturally has an
+            # object-to-EE distance around 18 cm for this side grasp.
+            and final_object_ee_distance <= 0.22
+        )
+        if self.settings.complete_original_task:
+            success = bool(
+                grasp_quality
+                and original_task_success
+                and placement_position_error is not None
+                and placement_position_error
+                <= self.settings.place_position_tolerance
+                and upright_axis_error_degrees is not None
+                and upright_axis_error_degrees
+                <= self.settings.upright_axis_tolerance_degrees
+            )
+        else:
+            success = bool(grasp_quality and lift_delta >= 0.055)
+        return {
+            "success": success,
+            "controller_mode": self.settings.controller_mode,
+            "arm": self.arm,
+            "object_model_id": int(self.env.model_id),
+            "grasp_reference_position": grasp_reference_position.tolist(),
+            "initial_object_position": initial_object_position.tolist(),
+            "initial_object_quaternion": initial_object_quaternion.tolist(),
+            "initial_velocity": initial_velocity.tolist(),
+            "object_motion_before_lift_m": object_motion,
+            "lift_delta_m": lift_delta,
+            "final_object_ee_distance_m": final_object_ee_distance,
+            "final_functional_point_position": final_functional_position.tolist(),
+            "final_functional_point_quaternion": final_functional_quaternion.tolist(),
+            "original_task_success": original_task_success,
+            "placement_position_error_m": placement_position_error,
+            "full_orientation_error_degrees": upright_error_degrees,
+            "upright_axis_error_degrees": upright_axis_error_degrees,
+            "held_friction_shape_count": len(self._held_shape_materials),
+            "held_friction_actor_names": sorted(
+                self._held_friction_actor_names
+            ),
+            "grasp_constraint_used": self._grasp_drive is not None,
+            "grasp_contact_links": self._grasp_contact_links,
+            "upright_target_pose": (
+                None if functional_target_pose is None
+                else functional_target_pose.tolist()
+            ),
+            "duration_seconds": self.sim_step * self.dt,
+            "sim_steps": self.sim_step,
+            "frames": self.env.FRAME_IDX,
+        }
+
+    def save_trace(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        arrays: dict[str, np.ndarray] = {}
+        for key, values in self.records.items():
+            if key == "stage":
+                arrays[key] = np.asarray(values, dtype="U24")
+            else:
+                arrays[key] = np.asarray(values)
+        np.savez_compressed(path, **arrays)
+
+
+def load_config(path: Path) -> dict[str, Any]:
+    with path.open("r", encoding="utf-8") as handle:
+        args = yaml.load(handle, Loader=yaml.FullLoader)
+
+    embodiment = args["embodiment"]
+    if len(embodiment) != 1:
+        raise ValueError("This preview collector currently expects one dual-arm embodiment")
+    with (Path(CONFIGS_PATH) / "_embodiment_config.yml").open(
+        "r", encoding="utf-8"
+    ) as handle:
+        embodiment_types = yaml.load(handle, Loader=yaml.FullLoader)
+    robot_file = embodiment_types[embodiment[0]]["file_path"]
+    with (Path(robot_file) / "config.yml").open("r", encoding="utf-8") as handle:
+        robot_config = yaml.load(handle, Loader=yaml.FullLoader)
+
+    args.update(
+        task_name="adjust_bottle",
+        task_config=path.stem,
+        left_robot_file=robot_file,
+        right_robot_file=robot_file,
+        left_embodiment_config=robot_config,
+        right_embodiment_config=robot_config,
+        dual_arm_embodied=True,
+        need_plan=True,
+        save_data=True,
+        use_dynamic=False,
+        render_freq=0,
+        record_native_timestamps=True,
+    )
+    args["save_path"] = str(
+        REPO_ROOT / args["save_path"] / args["task_name"] / args["task_config"]
+    )
+    return args
+
+
+def remove_episode_cache(output_dir: Path, episode: int) -> None:
+    cache = output_dir / ".cache" / f"episode{episode}"
+    if cache.is_dir():
+        shutil.rmtree(cache)
+
+
+def write_collection_summary(path: Path, payload: dict[str, Any]) -> None:
+    """Atomically checkpoint collection progress after every attempt."""
+
+    temporary = path.with_suffix(".json.tmp")
+    with temporary.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, ensure_ascii=False, indent=2)
+    os.replace(temporary, path)
+
+
+def write_standard_dataset_metadata(
+    output_dir: Path, summaries: list[dict[str, Any]]
+) -> None:
+    """Write metadata expected by the repository's training converters.
+
+    The stock collector obtains this information from ``env.info``.  This
+    online collector instead reconstructs the same minimal schema from the
+    accepted episode summaries, which also makes resumed and merged datasets
+    deterministic.
+    """
+
+    scene_info: dict[str, dict[str, dict[str, str]]] = {}
+    seeds: list[str] = []
+    for expected_episode, summary in enumerate(summaries):
+        episode = int(summary.get("episode", -1))
+        if episode != expected_episode:
+            raise RuntimeError(
+                "Cannot write dataset metadata for non-contiguous episodes: "
+                f"expected {expected_episode}, got {episode}"
+            )
+        arm = str(summary["arm"])
+        if arm not in {"left", "right"}:
+            raise ValueError(f"Unsupported arm in episode summary: {arm}")
+        model_id = int(summary["object_model_id"])
+        if model_id not in {13, 16}:
+            raise ValueError(
+                f"Unsupported adjust_bottle model id in summary: {model_id}"
+            )
+        scene_info[f"episode_{episode}"] = {
+            "info": {
+                "{A}": f"001_bottle/base{model_id}",
+                "{a}": arm,
+            }
+        }
+        seeds.append(str(int(summary["seed"])))
+
+    scene_path = output_dir / "scene_info.json"
+    scene_temporary = scene_path.with_suffix(".json.tmp")
+    with scene_temporary.open("w", encoding="utf-8") as handle:
+        json.dump(scene_info, handle, ensure_ascii=False, indent=2)
+    os.replace(scene_temporary, scene_path)
+
+    seed_path = output_dir / "seed.txt"
+    seed_temporary = seed_path.with_suffix(".txt.tmp")
+    seed_temporary.write_text(" ".join(seeds) + "\n", encoding="utf-8")
+    os.replace(seed_temporary, seed_path)
+
+
+def collect(
+    args: dict[str, Any],
+    episodes: int,
+    seed_start: int,
+    resume: bool = False,
+) -> Path:
+    output_dir = Path(args["save_path"])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "metrics").mkdir(parents=True, exist_ok=True)
+    base_settings = FollowSettings.from_dict(args.get("dynamic_follow"))
+    distribution = FollowDistributionSettings.from_dict(
+        args.get("dynamic_follow_distribution")
+    )
+    schedule = build_follow_schedule(base_settings, distribution)
+    if distribution.enabled and episodes > len(schedule):
+        raise ValueError(
+            f"Requested {episodes} episodes but the distribution schedule has "
+            f"only {len(schedule)} entries"
+        )
+    max_attempts = int(args.get("max_attempts", max(episodes * 8, 10)))
+
+    summary_path = output_dir / "summary.json"
+    summaries: list[dict[str, Any]] = []
+    failures: list[dict[str, Any]] = []
+    attempted_seeds: list[int] = []
+    collection_phases: list[dict[str, Any]] = []
+    settings_phases: list[dict[str, Any]] = []
+    attempts = 0
+    if resume and summary_path.is_file():
+        with summary_path.open("r", encoding="utf-8") as handle:
+            checkpoint = json.load(handle)
+        summaries = list(checkpoint.get("episodes", []))
+        failures = list(checkpoint.get("failures", []))
+        attempted_seeds = [
+            int(seed) for seed in checkpoint.get("attempted_seeds", [])
+        ]
+        attempts = int(checkpoint.get("attempts", len(attempted_seeds)))
+        collection_phases = list(checkpoint.get("collection_phases", []))
+        settings_phases = list(checkpoint.get("settings_phases", []))
+        if attempts != len(attempted_seeds):
+            raise RuntimeError(
+                "Resume checkpoint has inconsistent attempts/attempted_seeds"
+            )
+        for expected_episode, summary in enumerate(summaries):
+            if int(summary.get("episode", -1)) != expected_episode:
+                raise RuntimeError("Resume checkpoint episodes are not contiguous")
+            for relative in (
+                Path("data") / f"episode{expected_episode}.hdf5",
+                Path("video") / f"episode{expected_episode}.mp4",
+                Path("metrics") / f"episode{expected_episode}.npz",
+            ):
+                if not (output_dir / relative).is_file():
+                    raise RuntimeError(
+                        f"Resume checkpoint references missing file: {relative}"
+                    )
+        print(
+            f"[dynamic-follow] resume {len(summaries)}/{episodes} episodes, "
+            f"{attempts} attempts already consumed"
+        )
+
+        # Older checkpoints predate explicit phase provenance.  Preserve the
+        # distribution that produced their already-written episodes before a
+        # resumed run switches to a different (for example faster) profile.
+        if summaries and not collection_phases:
+            collection_phases.append(
+                {
+                    "start_episode": 0,
+                    "start_attempt": 0,
+                    "distribution": checkpoint.get("distribution", {}),
+                }
+            )
+        if summaries and not settings_phases:
+            settings_phases.append(
+                {
+                    "start_episode": 0,
+                    "start_attempt": 0,
+                    "settings": checkpoint.get("base_settings", {}),
+                }
+            )
+
+    current_distribution = dict(distribution.__dict__)
+    if (
+        not collection_phases
+        or collection_phases[-1].get("distribution") != current_distribution
+    ):
+        collection_phases.append(
+            {
+                "start_episode": len(summaries),
+                "start_attempt": attempts,
+                "distribution": current_distribution,
+            }
+        )
+    current_settings = dict(base_settings.__dict__)
+    if (
+        not settings_phases
+        or settings_phases[-1].get("settings") != current_settings
+    ):
+        settings_phases.append(
+            {
+                "start_episode": len(summaries),
+                "start_attempt": attempts,
+                "settings": current_settings,
+            }
+        )
+
+    successful = len(summaries)
+    configured_seeds = [int(value) for value in args.get("seed_list", [])]
+    fallback_seed_start = max([int(seed_start), *configured_seeds]) + 1
+    session_attempts = 0
+    env = adjust_bottle()
+
+    def checkpoint_payload() -> dict[str, Any]:
+        return {
+            "method": "online approach-follow-grasp (DynamicVLA-style teacher)",
+            "method_version": 2,
+            "uses_precomputed_intercept": False,
+            "uses_future_object_path": False,
+            "complete": successful == episodes,
+            "episodes_requested": episodes,
+            "episodes_successful": successful,
+            "attempts": attempts,
+            "attempted_seeds": attempted_seeds,
+            "base_settings": base_settings.__dict__,
+            # Keep the historical field name for readers of preview summaries.
+            "settings": base_settings.__dict__,
+            "distribution": distribution.__dict__,
+            "collection_phases": collection_phases,
+            "settings_phases": settings_phases,
+            "episodes": summaries,
+            "failures": failures,
+        }
+
+    write_collection_summary(summary_path, checkpoint_payload())
+    write_standard_dataset_metadata(output_dir, summaries)
+    while successful < episodes and attempts < max_attempts:
+        if attempts < len(configured_seeds):
+            seed = configured_seeds[attempts]
+        else:
+            seed = fallback_seed_start + attempts - len(configured_seeds)
+        settings, sampling = schedule[successful] if distribution.enabled else schedule[0]
+        controller: OnlineFollowEpisode | None = None
+        episode_wall_start = time.perf_counter()
+        print(
+            f"\n[dynamic-follow] episode={successful} seed={seed} "
+            f"attempt={attempts + 1}/{max_attempts} "
+            f"speed={sampling['target_speed_mps']:.3f}m/s "
+            f"angle={sampling['entry_angle_degrees']:+.1f}deg"
+        )
+        try:
+            episode_args = dict(args)
+            # CuRobo is robot-model based here and can be reused across scenes.
+            # Base_Task would otherwise rebuild and warm it up for every seed.
+            # Robot.reset keeps the existing CuRobo planners when skip_planner
+            # is true, while still loading fresh articulation entities.
+            planners_ready = (
+                hasattr(getattr(env, "robot", None), "left_planner")
+                and hasattr(getattr(env, "robot", None), "right_planner")
+            )
+            if session_attempts > 0 and planners_ready:
+                episode_args["skip_planner"] = True
+            env.setup_demo(now_ep_num=successful, seed=seed, **episode_args)
+            controller = OnlineFollowEpisode(env, settings)
+            summary = controller.run()
+            summary.update(
+                seed=seed,
+                episode=successful,
+                sampling=sampling,
+            )
+            if not summary["success"]:
+                raise RuntimeError(f"trajectory quality check failed: {summary}")
+
+            trace_path = output_dir / "metrics" / f"episode{successful}.npz"
+            controller.save_trace(trace_path)
+            env.merge_pkl_to_hdf5_video()
+            env.remove_data_cache()
+            summary["collection_wall_seconds"] = (
+                time.perf_counter() - episode_wall_start
+            )
+            summaries.append(summary)
+            print("[dynamic-follow] success", json.dumps(summary, ensure_ascii=False))
+            successful += 1
+        except Exception as exc:
+            if is_fatal_infrastructure_error(exc):
+                print(
+                    "[dynamic-follow] fatal infrastructure error; aborting "
+                    f"without consuming seed={seed}: {type(exc).__name__}: {exc}"
+                )
+                remove_episode_cache(output_dir, successful)
+                raise
+            print(f"[dynamic-follow] failed seed={seed}: {type(exc).__name__}: {exc}")
+            failures.append(
+                {
+                    "attempt": attempts,
+                    "episode": successful,
+                    "seed": seed,
+                    "error_type": type(exc).__name__,
+                    "error": str(exc),
+                }
+            )
+            remove_episode_cache(output_dir, successful)
+        finally:
+            if controller is not None:
+                controller.restore_materials()
+            try:
+                env.close_env(clear_cache=True)
+            except Exception:
+                pass
+        attempted_seeds.append(seed)
+        attempts += 1
+        session_attempts += 1
+        write_collection_summary(summary_path, checkpoint_payload())
+        write_standard_dataset_metadata(output_dir, summaries)
+        time.sleep(0.2)
+
+    if successful != episodes:
+        raise RuntimeError(
+            f"Collected only {successful}/{episodes} successful episodes after {attempts} attempts"
+        )
+    return output_dir
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--config",
+        type=Path,
+        default=REPO_ROOT / "task_config" / "demo_dynamicvla_follow.yml",
+    )
+    parser.add_argument(
+        "--episodes",
+        type=int,
+        default=None,
+        help="Target total episode count (defaults to episode_num in the config)",
+    )
+    parser.add_argument("--seed-start", type=int, default=0)
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help="Resume a checkpointed dataset until --episodes total examples exist",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    cli = parse_args()
+    config = load_config(cli.config.resolve())
+    episodes = int(cli.episodes if cli.episodes is not None else config["episode_num"])
+    if episodes <= 0:
+        raise ValueError("--episodes must be positive")
+    output = collect(
+        config,
+        episodes=episodes,
+        seed_start=cli.seed_start,
+        resume=cli.resume,
+    )
+    print(f"\nGenerated {episodes} examples in {output}")
+
+
+if __name__ == "__main__":
+    main()

provenance/demo_dynamicvla_follow_dataset.yml

@@ -0,0 +1,137 @@
+# Dataset-scale clean split for causal approach-follow-grasp demonstrations.
+# The exact merged-dataset episode/source mapping and all historical collection
+# phases are recorded in the final summary.json.  The seed prefix below records
+# the attempts made in the original formal shard and remains useful for resume
+# compatibility; new expansion runs use the harder distribution below.
+# New entries first run a three-example high-speed pilot on known-stable scenes,
+# then cover previously unused clean-level1 seeds before falling back to fresh
+# integer seeds.  Motion parameters remain different even when a scene seed is
+# deliberately reused for a controller-limit check.
+render_freq: 0
+# CUDA_VISIBLE_DEVICES selects the physical GPU; inside the process it is cuda:0.
+render_device: cuda:0
+episode_num: 50
+seed_start: 0
+seed_list: [1, 15, 23, 5, 6, 36, 40, 7, 10, 43, 45, 17, 13, 48, 61, 24, 21, 53, 70, 44, 37, 60, 79, 62, 39, 69, 86, 68, 42, 74, 87, 85, 47, 77, 94, 83, 96, 105, 15, 7, 48, 105, 40, 83, 92, 65, 67, 71, 84, 100, 102, 103, 88, 51, 90, 58]
+# High-speed online following is intentionally harder than the original
+# precomputed-intercept demonstrations, so leave enough attempts for strict
+# rejection instead of weakening the quality gate.
+max_attempts: 200
+save_freq: 8
+embodiment: [aloha-agilex]
+planner_backend: curobo
+# Match the standard training splits: generate 100 seen and 100 unseen
+# language variants per accepted scene after collection/finalization.
+language_num: 100
+
+# Match the old clean split first.  Visual randomization will be collected as
+# a separate split so appearance shift is not entangled with motion coverage.
+domain_randomization:
+  random_background: false
+  cluttered_table: false
+  clean_background_rate: 1
+  random_head_camera_dis: 0
+  random_table_height: 0
+  random_light: false
+  crazy_random_light_rate: 0
+
+camera:
+  head_camera_type: D435
+  wrist_camera_type: D435
+  collect_head_camera: true
+  collect_wrist_camera: true
+
+data_type:
+  rgb: true
+  third_view: false
+  depth: false
+  pointcloud: false
+  observer: false
+  endpose: true
+  qpos: true
+  mesh_segmentation: false
+  actor_segmentation: false
+
+pcd_down_sample_num: 1024
+pcd_crop: true
+save_path: data
+clear_cache_freq: 1
+collect_data: true
+eval_video_log: true
+
+dynamic_follow:
+  controller_mode: smooth_joint_servo
+  # These values are replaced episode-by-episode by the distribution below.
+  speed_x: 0.075
+  speed_y: 0.0
+  offscreen_start_x: 0.56
+  object_only_seconds: 1.45
+  prediction_horizon_seconds: 0.23
+  replanning_horizon_steps: 40
+  medium_horizon_steps: 80
+  catchup_horizon_steps: 160
+  frame_stride_steps: 8
+  pre_grasp_distance: 0.10
+  approach_tolerance: 0.025
+  grasp_tolerance: 0.018
+  follow_hold_seconds: 0.60
+  close_seconds: 0.90
+  release_fraction: 0.85
+  # Match the original adjust_bottle demonstration's 10-cm withdrawal.
+  lift_height: 0.10
+  settle_seconds: 0.40
+  max_approach_cycles: 35
+  max_descend_cycles: 24
+  velocity_ema: 0.65
+  servo_replan_steps: 50
+  servo_position_gain: 5.0
+  servo_max_joint_velocity: 1.4
+  servo_max_joint_acceleration: 3.0
+  servo_max_position_lead: 0.08
+  complete_original_task: true
+  # Allow one extra second for near-converged placements; the controller exits
+  # early as soon as the unchanged position/orientation tolerances are met.
+  place_max_seconds: 5.5
+  # The repository's task check only requires a clearly correct side/upright
+  # placement.  A 25-mm metric gate remains strict visually without rejecting
+  # otherwise successful demonstrations for millimetre-scale servo residuals.
+  place_position_tolerance: 0.025
+  # Keep the online servo's early-stop criterion tighter than the final
+  # object-level quality gate above.
+  place_control_position_tolerance: 0.015
+  place_orientation_tolerance_degrees: 3.0
+  upright_axis_tolerance_degrees: 12.0
+  place_max_joint_velocity: 0.8
+  place_max_joint_acceleration: 1.2
+  # Match the original dynamic adjust_bottle contact physics during carrying.
+  object_mass_kg: 0.01
+  held_linear_damping: 10.0
+  held_angular_damping: 10.0
+  grasp_settle_seconds: 0.25
+  # Created only after both physical fingers contact the bottle.  It preserves
+  # that measured relative pose and never snaps to a computed future pose.
+  stabilize_grasp_with_drive: true
+  grasp_drive_stiffness: 100000.0
+  grasp_drive_damping: 1000.0
+  grasp_drive_force_limit: 1000000.0
+  grasp_drive_limit_epsilon: 0.000001
+
+dynamic_follow_distribution:
+  enabled: true
+  schedule_size: 50
+  # The finalized 50-example split retains a small slow tail for coverage but
+  # has mean/median 0.0964/0.1010 m/s and 34/50 examples at >=0.10 m/s (versus
+  # 0.0479 m/s mean in the old clean split).  Further collection deliberately
+  # stays in this validated high-speed band; 0.12+ m/s online-follow pilots
+  # were too failure-prone to be useful production data.
+  speed_mean: 0.105
+  speed_sigma: 0.004
+  speed_min: 0.10
+  speed_max: 0.11
+  entry_angle_max_degrees: 8.0
+  offscreen_start_min: 0.56
+  offscreen_start_max: 0.60
+  action_start_abs_x_min: 0.44
+  action_start_abs_x_max: 0.47
+  follow_hold_min: 0.50
+  follow_hold_max: 0.70