yubi-mujoco 0.1.0__tar.gz

yubi_mujoco-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

yubi_mujoco-0.1.0/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+## Unreleased
+
+### Changed
+
+- Jaw angle zero is now the closed pose of yubi-sw's `yubi_hand.urdf.xacro`
+  (7.5° closed from the CAD parallel jaws), so recorded glove `joint_states`
+  map 1:1 onto jaw angles; the default open command is 0.68 rad
+- Jaw hinges stop at 0.03 rad (pads touch) and 0.80 rad (CAD opening
+  interference); commands up to the 0.94 rad glove range are still accepted
+- Body masses and full inertias come from the pinned STEP via the new
+  `cad/mass_properties.py` and `mass_properties.json` asset
+- Gripper defaults follow the DYNAMIXEL XM430-W350: 4.1 N m stall torque and a
+  4.8 rad/s no-load torque-speed line (`gripper_speed`); gain raised to 20
+- Wrist camera moved to the CAD lens center with its 10° downward pitch
+- Palm collision box extended to the servo bracket's underside
+
+### Removed
+
+- Keyboard `teleop` command; teleoperation belongs in a separate repository
+
+## 0.1.0 — initial release candidate
+
+This version is prepared for an initial release. Availability on PyPI depends
+on a successful publication; this entry alone does not indicate it is published.
+
+### Added
+
+- Installable `yubi_mujoco` package with `yubi-mujoco` and
+  `python -m yubi_mujoco` entry points
+- Arm-free, finite-stiffness mocap-driven YUBI hands with contact-based object
+  manipulation and one coupled-jaw actuator per hand
+- Toyota CAD-derived black/red grippers from 97 source solids, distributed as
+  13 active material meshes with provenance, hashes, and hardware-license notices
+- Seeded pick/place, dual pick/place, lift, and push scripted regressions
+- Absolute hand-root pose/motor API and delta-pose policy adapter
+- Local `Policy(checkpoint_dir).infer(obs)` evaluation with wrist images,
+  configurable chunk adoption, explicit timing, and JSON diagnostics
+- PNG scene rendering, optional MP4 recording, portable MJCF export
+- Real-time MuJoCo viewer for `demo` and `evaluate` (`--viewer`), with automatic
+  `mjpython` relaunch on macOS for the viewer
+- Minimal base dependencies: MuJoCo, NumPy, and SciPy; video dependencies in
+  the optional `video` extra
+- English usage, model-limit, validation, contributor, and release documentation
+- Source-only CAD regeneration inputs/tools, separate from the runtime wheel
+- uv project workflow with a cross-platform lockfile, a local development
+  dependency group, pinned build tools, and locked CI installs
+
+### Scope
+
+The included demos use privileged simulator state. Motor mapping, dynamics,
+contact, and camera models remain uncalibrated. This is an independent simulation,
+not an official UMI Arena benchmark or evidence of real-robot policy performance.

yubi_mujoco-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,133 @@
+# Contributing
+
+Keep installation small, behavior reproducible, and physical assumptions
+explicit. Useful contributions include regression tests, clearer API boundaries,
+measured calibration data with provenance, and improved collision models.
+
+## Development setup
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and use the
+committed lockfile. The checkout defaults to Python 3.12; Python 3.10+ remains
+supported. uv creates `.venv` automatically, without shell activation:
+
+```bash
+uv sync --locked --extra video
+uv lock --check
+uv run --locked --extra video ruff check .
+uv run --locked --extra video ruff format --check .
+uv run --locked --extra video pytest -q
+```
+
+Development tools live in `[dependency-groups].dev` and are included by default;
+`video` remains a published optional extra. Use `uv add` for runtime dependencies,
+`uv add --dev` for development tools, and `uv add --optional video` for video
+requirements. Commit `pyproject.toml` and the generated `uv.lock` together. To
+refresh a specific dependency intentionally, use `uv lock --upgrade-package NAME`,
+then run the checks. Do not hand-edit the lockfile. CI rejects a stale lockfile.
+
+Rendering tests need system OpenGL support. On headless Linux with EGL configured,
+use `MUJOCO_GL=egl uv run --locked --extra video pytest -q`. See [usage](docs/usage.md) for backend and
+viewer notes. Keep generated rollouts, build products, virtual environments,
+checkpoints, credentials, and local caches out of commits.
+
+## Changes and tests
+
+Keep a change focused and explain the behavior it changes. Include a regression
+test for bug fixes. Before opening a pull request:
+
+1. Run lint and the relevant tests, then the complete test suite.
+2. Run a base-install demo and reload a portable MJCF export if model/assets changed.
+3. Check rendered overview and wrist images for visual changes.
+4. Update the API/model documentation and changelog when behavior changes.
+5. Report exact commands, platform, Python/MuJoCo versions, and anything untested.
+
+For policy changes, preserve left/right ordering, hand-root frames, xyzw
+quaternions, absolute motor radians, and the distinction between observations
+and privileged `info`. Never make the scripted baseline appear to be a learned
+policy. Preserve the 10 Hz versus 30 Hz distinction when changing timing.
+
+For physics changes, do not directly move object free-joint state during actions
+or introduce hidden grasp attachments. Maintain the open-hand negative control.
+If a deliberate alternative model needs different behavior, expose and document
+it rather than silently changing the meaning of existing results.
+
+## CAD and third-party assets
+
+Read [CAD provenance](docs/CAD_PROVENANCE.md) before regenerating geometry.
+Runtime users should not need FreeCAD. Keep source STEP inputs and regeneration
+tools in `cad/`, and keep only the 13 active material meshes in the installed
+package. If topology changes intentionally, update the count, manifests, tests,
+and documentation together.
+
+Verify source hashes, unique solid membership, units, pivots, and local frames.
+Do not replace geometry from memory or infer physical calibration from appearance.
+Record exporter/tool versions and inspect articulation after regeneration.
+
+Original simulation software is MIT; hardware-derived geometry and transform
+data remain CERN-OHL-W-2.0. Preserve Toyota attribution, modification notices,
+source access, and license texts. Upstream software references use Apache-2.0.
+Do not label the complete distribution “MIT-only” or imply Toyota/AIRoA endorsement.
+
+## Build and inspect distributions
+
+```bash
+uv build
+uv run --locked --no-sync twine check --strict dist/*
+uv run --locked --no-sync python scripts/check_dist.py dist
+```
+
+`uv build` builds the source archive first, then builds the wheel from that
+archive. Isolated build dependencies are pinned separately in
+`[tool.uv].build-constraint-dependencies`; `uv.lock` locks runtime and development
+dependencies. Review and test updates to both when updating the build tools.
+
+Check both wheel and source archive contents. The wheel must contain the active
+meshes, JSON manifests, source/attribution notices, and relevant licenses. The
+source archive must retain `uv.lock`, `.python-version`, and the CAD regeneration
+inputs and tools. Neither should
+contain local environments, credentials, experiment outputs, or caches.
+
+Install the wheel into a clean environment outside the checkout. Test
+`yubi-mujoco --version`, `demo`, `render`, and `export-mjcf` without the video
+extra. Then install the video extra and test MP4 output. Follow the broader
+[validation guide](docs/validation.md). A source-tree test pass does not prove
+that the built wheel is complete.
+
+## Releasing to PyPI
+
+The release workflow is triggered by publishing a GitHub release. Preparing a
+checkout, pushing a tag, or running a build alone does not establish that the
+package has been published. Check the workflow result and the PyPI project
+before announcing installation from PyPI.
+
+Maintainer steps:
+
+1. Choose the version and update `pyproject.toml`, the package version, and
+   `CHANGELOG.md` together. Update the same-version sdist filename and PyPI URL
+   in `src/yubi_mujoco/assets/SOURCE.md`; archive checks reject stale source links.
+   Run `uv lock` to refresh the locked project version, then run the complete
+   release checks on that exact commit.
+2. In PyPI, create an upload token yourself. Store it in the GitHub repository's
+   Actions secret named `PYPI_API_TOKEN`; never commit it or paste it into an
+   issue, log, or chat. This workflow uses a token, not OIDC trusted publishing.
+3. If the PyPI project does not exist yet, initial upload requires a token whose
+   scope permits creating it. After the first successful publication, replace
+   that credential with a project-scoped `yubi-mujoco` token and revoke the
+   initial broader token. Follow [PyPI's API-token guidance](https://pypi.org/help/#apitoken).
+4. Tag the validated commit with `v` plus the exact package version, for example
+   `v0.1.0` for version `0.1.0`. Publish the corresponding GitHub release to
+   trigger the release workflow.
+5. Inspect the workflow's test, build, distribution-check, and upload results.
+   Verify the expected version and files on PyPI, then install that version in a
+   clean environment and run the public CLI smoke checks.
+
+The configured workflow needs the repository secret; it does not require a
+GitHub Environment. If maintainers want an additional manual approval boundary,
+configure a protected `pypi` Environment and have the publishing job use it.
+That is a separate repository/workflow configuration change, not provided by the
+secret alone. Package publication and those settings remain maintainer actions.
+
+PyPI normalizes underscores and hyphens in project names: `yubi_mujoco` is the
+installation/import spelling used here, `yubi-mujoco` is the normalized project
+name and console command. Do not upload a different artifact under an already
+published version. Fix an error with a new version and document the change.

yubi_mujoco-0.1.0/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 YUBI simulation contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+EXCEPTION: Toyota-derived CAD, STEP and STL assets and transformation metadata
+retain their original CERN-OHL-W-2.0 license, Copyright 2026 Toyota Motor
+Corporation. See src/yubi_mujoco/assets/licenses/CERN-OHL-W-2.0.txt and docs/CAD_PROVENANCE.md. This MIT
+license does not relicense those assets.

yubi_mujoco-0.1.0/MANIFEST.in

@@ -0,0 +1,15 @@
+include LICENSE README.md CHANGELOG.md CONTRIBUTING.md pyproject.toml uv.lock .python-version
+recursive-include src/yubi_mujoco *.py *.json *.md *.stl *.txt py.typed
+recursive-include tests *.py
+recursive-include examples *.py *.json
+recursive-include docs *.md
+recursive-include cad *.py *.md *.STEP LICENSE
+recursive-include scripts *.py
+prune .github
+prune build
+prune dist
+prune yubi-output
+prune .venv
+prune .pytest_cache
+prune .ruff_cache
+global-exclude __pycache__ *.py[cod] .DS_Store

yubi_mujoco-0.1.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: yubi_mujoco
+Version: 0.1.0
+Summary: CAD-based, arm-free YUBI gripper simulation for MuJoCo
+Author: YUBI MuJoCo contributors
+License-Expression: MIT AND CERN-OHL-W-2.0 AND Apache-2.0
+Project-URL: Repository, https://github.com/k1000dai/yubi_mujoco
+Project-URL: Issues, https://github.com/k1000dai/yubi_mujoco/issues
+Project-URL: Changelog, https://github.com/k1000dai/yubi_mujoco/blob/main/CHANGELOG.md
+Keywords: mujoco,robotics,gripper,yubi,simulation,mjcf
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: src/yubi_mujoco/assets/licenses/Apache-2.0.txt
+License-File: src/yubi_mujoco/assets/licenses/CERN-OHL-W-2.0.txt
+License-File: src/yubi_mujoco/assets/licenses/MIT.txt
+License-File: src/yubi_mujoco/assets/NOTICE.md
+Requires-Dist: mujoco<4,>=3.2
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.12
+Provides-Extra: video
+Requires-Dist: imageio>=2.34; extra == "video"
+Requires-Dist: imageio-ffmpeg>=0.5; extra == "video"
+Dynamic: license-file
+
+# yubi_mujoco
+
+Arm-free YUBI gripper simulation in MuJoCo. Command two end-effector poses and
+absolute gripper angles, test contact-based manipulation, and connect a local
+`Policy.infer(obs)` implementation.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/k1000dai/yubi_mujoco/main/docs/images/scene.png" alt="Two YUBI grippers above a table with a red cube and a goal marker" width="49%">
+  <img src="https://raw.githubusercontent.com/k1000dai/yubi_mujoco/main/docs/images/dual_pick_place.png" alt="Both YUBI grippers carrying cubes toward their goals in the dual pick-and-place task" width="49%">
+</p>
+
+The black/red grippers use Toyota's actual robot-gripper CAD: 97 source solids,
+partitioned into 13 material meshes. Dynamic hands follow finite-stiffness mocap
+targets; objects are moved by contact, without grasp attachments or teleporting.
+
+**Independent, unofficial simulation.** This is for interface checks, synthetic
+experiments, and regression tests. It is not a calibrated robot model or an
+UMI Arena benchmark. The bundled scripted demos use privileged object positions;
+their success is not a learned-policy result.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/getting-started/installation/):
+
+```bash
+git clone https://github.com/k1000dai/yubi_mujoco.git
+cd yubi_mujoco
+uv sync
+uv run yubi-mujoco --version
+```
+
+Or with pip, from the checkout: `python -m pip install .`
+
+Python 3.10+ is supported. The only runtime dependencies are MuJoCo, NumPy, and
+SciPy; no GPU, ROS, FreeCAD, or robot is needed for physics. Images and the
+viewer need a working OpenGL backend; see
+[rendering setup](docs/usage.md#rendering-and-platform-notes).
+
+## Quick start
+
+### Watch it in the MuJoCo viewer
+
+```bash
+uv run yubi-mujoco demo --viewer
+uv run yubi-mujoco demo --viewer --task dual_pick_place --episodes 3
+```
+
+`--viewer` opens the interactive MuJoCo window and plays the rollout in real
+time. It works for `demo` and `evaluate`; closing the window stops the run.
+On macOS the CLI relaunches itself under `mjpython` automatically.
+
+### Run headless
+
+```bash
+# A contact-based pick-and-place demo; writes JSON results to yubi-output/demo
+uv run yubi-mujoco demo
+
+# Other tasks and repeatable seed batches
+uv run yubi-mujoco demo --task dual_pick_place --episodes 5 --seed 0
+uv run yubi-mujoco demo --task lift --hz 10 --output yubi-output/lift
+uv run yubi-mujoco demo --task push --output yubi-output/push
+
+# A scene image, and a portable MJCF bundle
+uv run yubi-mujoco render --output scene.png --camera overview
+uv run yubi-mujoco export-mjcf --output yubi-output/mjcf
+```
+
+Tasks are `pick_place` (default), `dual_pick_place`, `lift`, and `push`. See
+`uv run yubi-mujoco <command> --help` for all options. After a pip install, call
+`yubi-mujoco` directly.
+
+For MP4 video, add the optional `video` extra:
+
+```bash
+uv run --extra video yubi-mujoco demo --task dual_pick_place --video --output yubi-output/video
+```
+
+## Python API
+
+```python
+from yubi_mujoco import SimConfig, YubiEnv
+
+with YubiEnv(SimConfig(task="pick_place", control_hz=30)) as env:
+    obs, info = env.reset(seed=42)
+    target = env.eef_poses.copy()  # (2, 7), left then right
+    target[0, 0] += 0.03  # world +X, in metres
+    motor = env.motor_for_jaw([0.4, 0.55])
+    obs, reward, terminated, truncated, info = env.step_absolute(target, motor)
+```
+
+Poses are hand-root `[x, y, z, qx, qy, qz, qw]`, in metres and world coordinates.
+Gripper commands are two **absolute motor positions in radians**, not normalized
+openness, finger width, or deltas. Motor-to-jaw calibration is nominal. Image
+observations are opt-in for direct API use; `info` contains privileged state.
+See the complete [API and policy contract](docs/usage.md).
+
+## Evaluate a local policy
+
+```bash
+# Interface smoke test; an idle hold policy is not expected to solve the task
+uv run yubi-mujoco evaluate --policy hold --horizon 64 --output yubi-output/hold
+
+uv run yubi-mujoco evaluate --policy /path/to/policy.py \
+  --checkpoint /path/to/checkpoint --hz 30 --adopt-rows 16 \
+  --output yubi-output/policy
+```
+
+Add `--viewer` to watch the policy act. Evaluation renders two wrist images,
+even without `--video`, and needs OpenGL. Only load trusted Python policy files.
+See [examples/policy.py](examples/policy.py) and the
+[UMI Arena submission contract](https://umi-arena.airoa.io/submission-format).
+Dataset/replay timing is 30 Hz; the published robot execution description uses
+10 Hz. Select the intended rate explicitly. This package does not download
+checkpoints or gated datasets, and does not replace the official checker.
+
+## Model, validation, and development
+
+- [Usage, controls, rendering, and policy timing](docs/usage.md)
+- [Model assumptions and calibration limits](docs/model.md)
+- [Validation and reproducible checks](docs/validation.md)
+- [CAD provenance and regeneration](docs/CAD_PROVENANCE.md)
+- [Contributing and releases](CONTRIBUTING.md) · [Changelog](CHANGELOG.md)
+
+Source geometry is pinned to [Toyota/yubi-hw at dd8bd13](https://github.com/Toyota/yubi-hw/tree/dd8bd13d2fd8e5003057243576f88be333d95fc5).
+The source STEP and regeneration tools are in `cad/`; they are not runtime
+requirements. The installed package contains the active meshes and manifests.
+
+## Licenses
+
+Original simulation software: [MIT](LICENSE). Toyota-derived CAD, meshes, and
+transformation data: [CERN-OHL-W-2.0](src/yubi_mujoco/assets/licenses/CERN-OHL-W-2.0.txt),
+Copyright 2026 Toyota Motor Corporation. Upstream software references use
+Apache-2.0; see the [attribution notice](src/yubi_mujoco/assets/NOTICE.md).
+Hardware-derived assets are not relicensed under MIT. Toyota and AIRoA do not
+endorse or certify this project.

yubi_mujoco-0.1.0/README.md

@@ -0,0 +1,135 @@
+# yubi_mujoco
+
+Arm-free YUBI gripper simulation in MuJoCo. Command two end-effector poses and
+absolute gripper angles, test contact-based manipulation, and connect a local
+`Policy.infer(obs)` implementation.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/k1000dai/yubi_mujoco/main/docs/images/scene.png" alt="Two YUBI grippers above a table with a red cube and a goal marker" width="49%">
+  <img src="https://raw.githubusercontent.com/k1000dai/yubi_mujoco/main/docs/images/dual_pick_place.png" alt="Both YUBI grippers carrying cubes toward their goals in the dual pick-and-place task" width="49%">
+</p>
+
+The black/red grippers use Toyota's actual robot-gripper CAD: 97 source solids,
+partitioned into 13 material meshes. Dynamic hands follow finite-stiffness mocap
+targets; objects are moved by contact, without grasp attachments or teleporting.
+
+**Independent, unofficial simulation.** This is for interface checks, synthetic
+experiments, and regression tests. It is not a calibrated robot model or an
+UMI Arena benchmark. The bundled scripted demos use privileged object positions;
+their success is not a learned-policy result.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/getting-started/installation/):
+
+```bash
+git clone https://github.com/k1000dai/yubi_mujoco.git
+cd yubi_mujoco
+uv sync
+uv run yubi-mujoco --version
+```
+
+Or with pip, from the checkout: `python -m pip install .`
+
+Python 3.10+ is supported. The only runtime dependencies are MuJoCo, NumPy, and
+SciPy; no GPU, ROS, FreeCAD, or robot is needed for physics. Images and the
+viewer need a working OpenGL backend; see
+[rendering setup](docs/usage.md#rendering-and-platform-notes).
+
+## Quick start
+
+### Watch it in the MuJoCo viewer
+
+```bash
+uv run yubi-mujoco demo --viewer
+uv run yubi-mujoco demo --viewer --task dual_pick_place --episodes 3
+```
+
+`--viewer` opens the interactive MuJoCo window and plays the rollout in real
+time. It works for `demo` and `evaluate`; closing the window stops the run.
+On macOS the CLI relaunches itself under `mjpython` automatically.
+
+### Run headless
+
+```bash
+# A contact-based pick-and-place demo; writes JSON results to yubi-output/demo
+uv run yubi-mujoco demo
+
+# Other tasks and repeatable seed batches
+uv run yubi-mujoco demo --task dual_pick_place --episodes 5 --seed 0
+uv run yubi-mujoco demo --task lift --hz 10 --output yubi-output/lift
+uv run yubi-mujoco demo --task push --output yubi-output/push
+
+# A scene image, and a portable MJCF bundle
+uv run yubi-mujoco render --output scene.png --camera overview
+uv run yubi-mujoco export-mjcf --output yubi-output/mjcf
+```
+
+Tasks are `pick_place` (default), `dual_pick_place`, `lift`, and `push`. See
+`uv run yubi-mujoco <command> --help` for all options. After a pip install, call
+`yubi-mujoco` directly.
+
+For MP4 video, add the optional `video` extra:
+
+```bash
+uv run --extra video yubi-mujoco demo --task dual_pick_place --video --output yubi-output/video
+```
+
+## Python API
+
+```python
+from yubi_mujoco import SimConfig, YubiEnv
+
+with YubiEnv(SimConfig(task="pick_place", control_hz=30)) as env:
+    obs, info = env.reset(seed=42)
+    target = env.eef_poses.copy()  # (2, 7), left then right
+    target[0, 0] += 0.03  # world +X, in metres
+    motor = env.motor_for_jaw([0.4, 0.55])
+    obs, reward, terminated, truncated, info = env.step_absolute(target, motor)
+```
+
+Poses are hand-root `[x, y, z, qx, qy, qz, qw]`, in metres and world coordinates.
+Gripper commands are two **absolute motor positions in radians**, not normalized
+openness, finger width, or deltas. Motor-to-jaw calibration is nominal. Image
+observations are opt-in for direct API use; `info` contains privileged state.
+See the complete [API and policy contract](docs/usage.md).
+
+## Evaluate a local policy
+
+```bash
+# Interface smoke test; an idle hold policy is not expected to solve the task
+uv run yubi-mujoco evaluate --policy hold --horizon 64 --output yubi-output/hold
+
+uv run yubi-mujoco evaluate --policy /path/to/policy.py \
+  --checkpoint /path/to/checkpoint --hz 30 --adopt-rows 16 \
+  --output yubi-output/policy
+```
+
+Add `--viewer` to watch the policy act. Evaluation renders two wrist images,
+even without `--video`, and needs OpenGL. Only load trusted Python policy files.
+See [examples/policy.py](examples/policy.py) and the
+[UMI Arena submission contract](https://umi-arena.airoa.io/submission-format).
+Dataset/replay timing is 30 Hz; the published robot execution description uses
+10 Hz. Select the intended rate explicitly. This package does not download
+checkpoints or gated datasets, and does not replace the official checker.
+
+## Model, validation, and development
+
+- [Usage, controls, rendering, and policy timing](docs/usage.md)
+- [Model assumptions and calibration limits](docs/model.md)
+- [Validation and reproducible checks](docs/validation.md)
+- [CAD provenance and regeneration](docs/CAD_PROVENANCE.md)
+- [Contributing and releases](CONTRIBUTING.md) · [Changelog](CHANGELOG.md)
+
+Source geometry is pinned to [Toyota/yubi-hw at dd8bd13](https://github.com/Toyota/yubi-hw/tree/dd8bd13d2fd8e5003057243576f88be333d95fc5).
+The source STEP and regeneration tools are in `cad/`; they are not runtime
+requirements. The installed package contains the active meshes and manifests.
+
+## Licenses
+
+Original simulation software: [MIT](LICENSE). Toyota-derived CAD, meshes, and
+transformation data: [CERN-OHL-W-2.0](src/yubi_mujoco/assets/licenses/CERN-OHL-W-2.0.txt),
+Copyright 2026 Toyota Motor Corporation. Upstream software references use
+Apache-2.0; see the [attribution notice](src/yubi_mujoco/assets/NOTICE.md).
+Hardware-derived assets are not relicensed under MIT. Toyota and AIRoA do not
+endorse or certify this project.