fix(mjlab): go1 Newton can finally stand (PD actuators + init pose + action order)

Three stacked bugs kept go1 collapsed on the Newton path (so 'go1 walks'
was never real):
- go1.xml has NO <actuator> elements (mjlab adds them at runtime). The Newton
  RobotCfg path loaded the raw XML -> mj nu=0 -> zero position-control torque
  -> free-fall. Now patch_mjcf_with_pd_actuators(go1.xml, GO1_KP) on the Newton
  path too (nu=12), matching the mujoco scene path.
- init height 0.42 -> 0.278 (mjlab INIT_STATE) + hip 0.0 -> ±0.1 (R/L).
- action target was emitted in cfg joint order but Newton applies tensor
  actions in get_joint_names(sort=True) order -> PD targets scrambled to wrong
  joints. Reorder cfg->sorted in _apply_action.

Verified: go1 holds z~0.30 stable under zero action (was collapsing to 0.05);
12/12 mujoco + 12/12 Newton smoke still passes (no regression). Depends on the
MetaSim bare-joint-name alias fix. Retraining in progress to verify walking.

Author: geng-haoran

roboverse_pack/robots/mjlab_go1_cfg.py

@@ -26,14 +26,22 @@
     "RL_calf_joint",
 )
 
-# Default stance (matches velocity_go1_v2._GO1_DEFAULT_POSE_NP)
-_GO1_DEFAULTS = {
-    name: val
-    for name, val in zip(
-        _GO1_JOINTS,
-        [0.0, 0.9, -1.8] * 4,
-    )
-}
+# Default stance — MUST match mjlab INIT_STATE (go1_constants.py): thigh=0.9,
+# calf=-1.8, and asymmetric hips R_hip=+0.1 / L_hip=-0.1. The earlier symmetric
+# hip=0.0 here (Newton path never got the r7 ±0.1 fix) gave an unstable stance
+# that, together with the wrong 0.42 init height, made go1 collapse under PD on
+# Newton (couldn't even stand). FR/RR are the "R" legs, FL/RL the "L" legs.
+def _go1_default(name: str) -> float:
+    if "thigh" in name:
+        return 0.9
+    if "calf" in name:
+        return -1.8
+    if "hip" in name:
+        return 0.1 if name[1] == "R" else -0.1
+    return 0.0
+
+
+_GO1_DEFAULTS = {name: _go1_default(name) for name in _GO1_JOINTS}
 
 
 @configclass
@@ -72,5 +80,5 @@ class MjlabGo1Cfg(RobotCfg):
     default_joint_positions: dict[str, float] = _GO1_DEFAULTS
     default_joint_velocities: dict[str, float] = {n: 0.0 for n in _GO1_JOINTS}
     control_type: dict[str, Literal["position", "effort"]] = {n: "position" for n in _GO1_JOINTS}
-    default_pos: tuple[float, float, float] = (0.0, 0.0, 0.42)
+    default_pos: tuple[float, float, float] = (0.0, 0.0, 0.278)  # mjlab INIT_STATE height (was 0.42 -> 14cm drop -> collapse)
     default_rot: tuple[float, float, float, float] = (1.0, 0.0, 0.0, 0.0)

roboverse_pack/tasks/mjlab/velocity_go1_v2.py

@@ -26,6 +26,7 @@
 from __future__ import annotations
 
 import math
+import os
 
 import mujoco
 import numpy as np
@@ -491,6 +492,23 @@ def __init__(self, scenario: ScenarioCfg | None = None, device: str | torch.devi
         sim = getattr(scenario, "simulator", None) if scenario else None
         if scenario is not None and sim == "mujoco":
             scenario.robots = []
+        elif scenario is not None and sim == "newton":
+            # CRITICAL: go1.xml has NO <actuator> elements (mjlab adds them at
+            # runtime). Without actuators (mj nu=0) the Newton SolverMuJoCo
+            # applies ZERO position-control torque -> go1 free-falls. The mujoco
+            # scene path patches PD actuators in; the Newton RobotCfg path must
+            # do the same. Point the go1 robot at an actuator-patched MJCF so
+            # nu=12 and the PD (kp=GO1_KP) actually holds the stance.
+            for r in scenario.robots:
+                mjcf = getattr(r, "mjcf_path", None)
+                if getattr(r, "name", None) == "go1" and mjcf:
+                    src = mjcf if os.path.isabs(mjcf) else os.path.abspath(mjcf)
+                    try:
+                        r.mjcf_path = patch_mjcf_with_pd_actuators(src, GO1_KP)
+                    except Exception as e:  # noqa: BLE001
+                        import warnings
+
+                        warnings.warn(f"go1 Newton actuator patch failed ({e}); go1 will not stand", RuntimeWarning)
         self.num_actions = 12
         # Cache joint qpos/qvel indices for fast write in _apply_action
         # (lazy — set on first call, since handler isn't constructed yet)
@@ -643,7 +661,18 @@ def _apply_action(self, processed_action: torch.Tensor) -> None:
         """
         target = self.action_manager.process(processed_action)
         if not hasattr(self.handler, "physics"):
-            self.handler.set_dof_targets(target)
+            # The action_manager produces targets in cfg (_GO1_JOINTS) order, but
+            # the Newton handler's tensor set_dof_targets applies them in
+            # get_joint_names(sort=True) (alphabetical) order. Without reordering,
+            # PD targets land on the WRONG joints -> go1 collapses. Build the
+            # cfg->sorted permutation once and reorder.
+            if getattr(self, "_cfg_to_sorted", None) is None:
+                sorted_bare = [n.split("/")[-1] for n in self.handler.get_joint_names("go1", sort=True)]
+                cfg_order = list(_GO1_JOINTS.joint_names)
+                self._cfg_to_sorted = torch.tensor(
+                    [cfg_order.index(b) for b in sorted_bare], device=target.device, dtype=torch.long
+                )
+            self.handler.set_dof_targets(target[..., self._cfg_to_sorted])
             return
         target_np = target.detach().cpu().numpy().reshape(-1)
         self.handler.physics.data.ctrl[:12] = target_np