[Task Clean-up][Benchmark] Dexterous Part 7/8: Add success-rate support to the benchmark utilities

docs/source/overview/environments.rst

@@ -1054,7 +1054,7 @@ inferencing, including reading from an already trained checkpoint and disabling
       - Isaac-Reorient-Cube-Allegro-Play
       - Manager Based
       - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO)
-      -
+      - **physics=** ``newton_mjwarp``, ``ovphysx``, ``physx``
     * - Isaac-Reorient-Cube-Allegro-Direct
       -
       - Direct
@@ -1065,28 +1065,50 @@ inferencing, including reading from an already trained checkpoint and disabling
       - Direct
       - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO)
       -
+    * - Isaac-Reorient-Cube-Shadow
+      -
+      - Manager Based
+      - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO)
+      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
+    * - Isaac-Reorient-Cube-Shadow-Camera
+      - Isaac-Reorient-Cube-Shadow-Camera-Play
+      - Manager Based
+      - **rl_games** (PPO), **rsl_rl** (PPO)
+      - | **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
+          | **renderer=** ``isaacsim_rtx``, ``newton_renderer``, ``ovrtx``, ``rtx``
+          | **presets=** ``albedo``, ``depth``, ``full``, ``rgb``, ``rgb_depth``, ``semantic_segmentation``, ``simple_shading_constant_diffuse``, ``simple_shading_diffuse_mdl``, ``simple_shading_full_mdl``
     * - Isaac-Reorient-Cube-Shadow-Camera-Direct
       - Isaac-Reorient-Cube-Shadow-Camera-Direct-Play
       - Direct
       - **rl_games** (PPO), **rsl_rl** (PPO)
-      - | **physics=** ``newton_kamino``, ``newton_mjwarp``, ``physx``
+      - | **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
           | **renderer=** ``isaacsim_rtx``, ``newton_renderer``, ``ovrtx``, ``rtx``
-          | **presets=** ``albedo``, ``depth``, ``full``, ``rgb``, ``semantic_segmentation``, ``simple_shading_constant_diffuse``, ``simple_shading_diffuse_mdl``, ``simple_shading_full_mdl``
+          | **presets=** ``albedo``, ``depth``, ``full``, ``rgb``, ``rgb_depth``, ``semantic_segmentation``, ``simple_shading_constant_diffuse``, ``simple_shading_diffuse_mdl``, ``simple_shading_full_mdl``
     * - Isaac-Reorient-Cube-Shadow-Direct
       -
       - Direct
       - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO)
-      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``physx``
+      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
+    * - Isaac-Reorient-Cube-Shadow-OpenAI-FF
+      -
+      - Manager Based
+      - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO)
+      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
     * - Isaac-Reorient-Cube-Shadow-OpenAI-FF-Direct
       -
       - Direct
       - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO)
-      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``physx``
+      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
+    * - Isaac-Reorient-Cube-Shadow-OpenAI-LSTM
+      -
+      - Manager Based
+      - **rl_games** (PPO), **rsl_rl** (PPO)
+      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
     * - Isaac-Reorient-Cube-Shadow-OpenAI-LSTM-Direct
       -
       - Direct
-      - **rl_games** (PPO)
-      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``physx``
+      - **rl_games** (PPO), **rsl_rl** (PPO)
+      - **physics=** ``newton_kamino``, ``newton_mjwarp``, ``ovphysx``, ``physx``
     * - Isaac-Reorient-Franka
       - Isaac-Reorient-Franka-Play
       - Manager Based
@@ -1106,11 +1128,16 @@ inferencing, including reading from an already trained checkpoint and disabling
       - | **physics=** ``newton_mjwarp``, ``physx``
           | **renderer=** ``isaacsim_rtx``, ``newton_renderer``, ``ovrtx``, ``rtx``
           | **presets=** ``albedo128``, ``albedo256``, ``albedo64``, ``cube``, ``depth128``, ``depth256``, ``depth64``, ``duo_camera``, ``raycaster_depth128``, ``raycaster_depth256``, ``raycaster_depth64``, ``rgb128``, ``rgb256``, ``rgb64``, ``semantic_segmentation128``, ``semantic_segmentation256``, ``semantic_segmentation64``, ``shapes``, ``simple_shading_constant_diffuse128``, ``simple_shading_constant_diffuse256``, ``simple_shading_constant_diffuse64``, ``simple_shading_diffuse_mdl128``, ``simple_shading_diffuse_mdl256``, ``simple_shading_diffuse_mdl64``, ``simple_shading_full_mdl128``, ``simple_shading_full_mdl256``, ``simple_shading_full_mdl64``, ``single_camera``
+    * - Isaac-Shadow-Handover
+      -
+      - Manager Based
+      - **rsl_rl** (PPO)
+      - **physics=** ``newton_mjwarp``, ``ovphysx``, ``physx``
     * - Isaac-Shadow-Handover-Direct
       -
       - Direct
-      - **rl_games** (PPO), **skrl** (PPO, IPPO, MAPPO)
-      - **physics=** ``newton_mjwarp``, ``physx``
+      - **rl_games** (PPO), **rsl_rl** (PPO), **skrl** (PPO, IPPO, MAPPO)
+      - **physics=** ``newton_mjwarp``, ``ovphysx``, ``physx``
     * - Isaac-Velocity-Flat-AnymalB-Warp-v0
       - Isaac-Velocity-Flat-AnymalB-Warp-Play-v0
       - Manager Based

source/isaaclab/changelog.d/dexterous-env-convergence.rst

@@ -0,0 +1,7 @@
+Fixed
+^^^^^
+
+* Fixed :meth:`~isaaclab.envs.DirectRLEnv.reset` to store the observation buffer
+  like :meth:`~isaaclab.envs.DirectRLEnv.step` already does, and exposed the
+  latest observations on the multi-agent-to-single-agent adapter through the
+  same public buffer.

source/isaaclab/isaaclab/envs/direct_rl_env.py

@@ -382,7 +382,9 @@ def reset(self, seed: int | None = None, options: dict[str, Any] | None = None)
                     self.sim.render()
 
         # return observations
-        return self._get_observations(), self.extras
+        # store the buffer like step() does, so consumers can read the latest observations
+        self.obs_buf = self._get_observations()
+        return self.obs_buf, self.extras
 
     def step(self, action: torch.Tensor) -> VecEnvStepReturn:
         """Execute one time-step of the environment's dynamics.

source/isaaclab/isaaclab/envs/utils/marl.py

@@ -81,22 +81,34 @@ def __init__(self, env: DirectMARLEnv) -> None:
             )
             self.action_space = gym.vector.utils.batch_space(self.single_action_space, self.num_envs)
 
-        def reset(self, seed: int | None = None, options: dict[str, Any] | None = None) -> tuple[VecEnvObs, dict]:
-            obs, extras = self.env.reset(seed, options)
+        @property
+        def episode_length_buf(self) -> torch.Tensor:
+            """Episode lengths from the wrapped multi-agent environment."""
+            return self.env.episode_length_buf
 
-            # use environment state as observation
-            if self._state_as_observation:
-                obs = {"policy": self.env.state()}
-            # concatenate agents' observations
+        @episode_length_buf.setter
+        def episode_length_buf(self, value: torch.Tensor) -> None:
+            self.env.episode_length_buf = value
+
+        @property
+        def obs_buf(self) -> VecEnvObs:
+            """Latest observations from the wrapped multi-agent environment."""
+            return self._convert_observations(self.env.obs_dict)
+
+        def _convert_observations(self, obs: dict[AgentID, ObsType]) -> VecEnvObs:
+            """Convert multi-agent observations to the single-agent policy observation."""
             # FIXME: This implementation assumes the spaces are fundamental ones. Fix it to support composite spaces
-            else:
-                obs = {
-                    "policy": torch.cat(
-                        [obs[agent].reshape(self.num_envs, -1) for agent in self.env.possible_agents], dim=-1
-                    )
-                }
+            if self._state_as_observation:
+                return {"policy": self.env.state()}
+            return {
+                "policy": torch.cat(
+                    [obs[agent].reshape(self.num_envs, -1) for agent in self.env.possible_agents], dim=-1
+                )
+            }
 
-            return obs, extras
+        def reset(self, seed: int | None = None, options: dict[str, Any] | None = None) -> tuple[VecEnvObs, dict]:
+            obs, extras = self.env.reset(seed, options)
+            return self._convert_observations(obs), extras
 
         def step(self, action: torch.Tensor) -> VecEnvStepReturn:
             # split single-agent actions to build the multi-agent ones
@@ -111,17 +123,7 @@ def step(self, action: torch.Tensor) -> VecEnvStepReturn:
             # step the environment
             obs, rewards, terminated, time_outs, extras = self.env.step(_actions)
 
-            # use environment state as observation
-            if self._state_as_observation:
-                obs = {"policy": self.env.state()}
-            # concatenate agents' observations
-            # FIXME: This implementation assumes the spaces are fundamental ones. Fix it to support composite spaces
-            else:
-                obs = {
-                    "policy": torch.cat(
-                        [obs[agent].reshape(self.num_envs, -1) for agent in self.env.possible_agents], dim=-1
-                    )
-                }
+            obs = self._convert_observations(obs)
 
             # process environment outputs to return single-agent data
             rewards = sum(rewards.values())

source/isaaclab/test/cli/test_install_command_parsing.py

@@ -106,6 +106,11 @@ def test_core_submodules_starts_with_isaaclab(self):
             "isaaclab must be first so dependents resolve against the local copy"
         )
 
+    def test_core_submodules_install_contrib_before_tasks(self):
+        assert CORE_ISAACLAB_SUBMODULES.index("isaaclab_contrib") < CORE_ISAACLAB_SUBMODULES.index("isaaclab_tasks"), (
+            "isaaclab_contrib must be installed before isaaclab_tasks so its declared local dependency resolves"
+        )
+
     def test_core_submodules_contains_expected_packages(self):
         expected = {
             "isaaclab",

source/isaaclab/test/envs/test_marl_utils.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+from types import SimpleNamespace
+
+import gymnasium as gym
+import torch
+
+from isaaclab.envs.utils.marl import multi_agent_to_single_agent
+
+
+class _FakeMultiAgentEnv:
+    possible_agents = ["agent_0", "agent_1"]
+    observation_spaces = {
+        "agent_0": gym.spaces.Box(low=-1.0, high=1.0, shape=(2,)),
+        "agent_1": gym.spaces.Box(low=-1.0, high=1.0, shape=(1,)),
+    }
+    action_spaces = {
+        "agent_0": gym.spaces.Box(low=-1.0, high=1.0, shape=(1,)),
+        "agent_1": gym.spaces.Box(low=-1.0, high=1.0, shape=(1,)),
+    }
+    render_mode = None
+
+    def __init__(self):
+        self.unwrapped = self
+        self.cfg = SimpleNamespace(state_space=2)
+        self.state_space = gym.spaces.Box(low=-1.0, high=1.0, shape=(2,))
+        self.sim = object()
+        self.scene = SimpleNamespace(num_envs=2)
+        self.episode_length_buf = torch.tensor([1, 2])
+        self.obs_dict = {
+            "agent_0": torch.tensor([[1.0, 2.0], [3.0, 4.0]]),
+            "agent_1": torch.tensor([[5.0], [6.0]]),
+        }
+
+    def reset(self, seed=None, options=None):
+        return self.obs_dict, {}
+
+    def state(self):
+        return torch.tensor([[7.0, 8.0], [9.0, 10.0]])
+
+    def close(self):
+        pass
+
+
+def test_multi_agent_to_single_agent_reset_concatenates_agents():
+    """The adapter reset should concatenate the agents' observations."""
+    env = multi_agent_to_single_agent(_FakeMultiAgentEnv())
+
+    observations, _ = env.reset()
+
+    torch.testing.assert_close(observations["policy"], torch.tensor([[1.0, 2.0, 5.0], [3.0, 4.0, 6.0]]))
+
+
+def test_multi_agent_to_single_agent_reset_can_use_state():
+    """The adapter reset should support the state-as-observation mode."""
+    env = multi_agent_to_single_agent(_FakeMultiAgentEnv(), state_as_observation=True)
+
+    observations, _ = env.reset()
+
+    torch.testing.assert_close(observations["policy"], torch.tensor([[7.0, 8.0], [9.0, 10.0]]))
+
+
+def test_multi_agent_to_single_agent_forwards_episode_lengths():
+    """RSL-RL episode randomization should update the wrapped environment buffer."""
+    source_env = _FakeMultiAgentEnv()
+    env = multi_agent_to_single_agent(source_env)
+    episode_lengths = torch.tensor([3, 4])
+
+    env.episode_length_buf = episode_lengths
+
+    assert env.episode_length_buf is episode_lengths
+    assert source_env.episode_length_buf is episode_lengths
+
+
+def test_multi_agent_to_single_agent_exposes_latest_observations():
+    """The public observation buffer should reflect the wrapped environment's buffer."""
+    env = multi_agent_to_single_agent(_FakeMultiAgentEnv())
+
+    torch.testing.assert_close(env.obs_buf["policy"], torch.tensor([[1.0, 2.0, 5.0], [3.0, 4.0, 6.0]]))

source/isaaclab_experimental/changelog.d/dexterous-env-convergence.rst

@@ -0,0 +1,7 @@
+Fixed
+^^^^^
+
+* Fixed :meth:`~isaaclab_experimental.envs.DirectRLEnvWarp.step` and
+  :meth:`~isaaclab_experimental.envs.DirectRLEnvWarp.reset` to store the returned
+  observation dictionary in ``obs_buf``, which
+  :meth:`~isaaclab_rl.rsl_rl.RslRlVecEnvWrapper.get_observations` now reads.

source/isaaclab_experimental/isaaclab_experimental/envs/direct_rl_env_warp.py

@@ -377,7 +377,9 @@ def reset(self, seed: int | None = None, options: dict[str, Any] | None = None)
 
         # return observations
         self._get_observations()
-        return {"policy": self.torch_obs_buf.clone()}, self.extras
+        # store the returned buffer so RslRlVecEnvWrapper.get_observations() can read env.obs_buf
+        self.obs_buf = {"policy": self.torch_obs_buf.clone()}
+        return self.obs_buf, self.extras
 
     @Timer(name="env_step", msg="Step took:", enable=DEBUG_TIMER_STEP or DEBUG_TIMERS)
     def step(self, action: torch.Tensor) -> VecEnvStepReturn:
@@ -460,8 +462,10 @@ def step(self, action: torch.Tensor) -> VecEnvStepReturn:
             self._post_step_visualize()
 
         # return observations, rewards, resets and extras
+        # store the returned buffer so RslRlVecEnvWrapper.get_observations() can read env.obs_buf
+        self.obs_buf = {"policy": self.torch_obs_buf.clone()}
         return (
-            {"policy": self.torch_obs_buf.clone()},
+            self.obs_buf,
             self.torch_reward_buf,
             self.torch_reset_terminated,
             self.torch_reset_time_outs,

source/isaaclab_rl/changelog.d/dexterous-env-convergence.minor.rst

@@ -0,0 +1,10 @@
+Changed
+^^^^^^^
+
+* Changed :meth:`~isaaclab_rl.rsl_rl.RslRlVecEnvWrapper.get_observations` to read
+  the environment-owned observation buffer instead of calling private environment
+  methods. The returned observations now match the latest reset/step returns,
+  including observation-noise corruption that the private path skipped, and
+  multi-agent environments converted with
+  :func:`~isaaclab.envs.utils.multi_agent_to_single_agent` train with RSL-RL
+  without environment-side accommodations.

source/isaaclab_rl/isaaclab_rl/rsl_rl/vecenv_wrapper.py

@@ -171,11 +171,7 @@ def reset(self) -> tuple[TensorDict, dict]:  # noqa: D102
 
     def get_observations(self) -> TensorDict:
         """Returns the current observations of the environment."""
-        if hasattr(self.unwrapped, "observation_manager"):
-            obs_dict = self.unwrapped.observation_manager.compute()
-        else:
-            obs_dict = self.unwrapped._get_observations()
-        return TensorDict(obs_dict, batch_size=[self.num_envs])
+        return TensorDict(self.unwrapped.obs_buf, batch_size=[self.num_envs])
 
     def step(self, actions: torch.Tensor) -> tuple[TensorDict, torch.Tensor, torch.Tensor, dict]:
         # clip actions

source/isaaclab_tasks/changelog.d/task-cleanup-dex-part03.minor.rst

@@ -0,0 +1,13 @@
+Added
+^^^^^
+
+* Added behavioral-success metrics and threshold-independent episode-error
+  diagnostics to the dexterous reorientation environments.
+
+Fixed
+^^^^^
+
+* Fixed dexterous hand resets that could initialize joints below their lower
+  position limits. Reset joint positions now sample uniformly across the full
+  joint range; previously the distribution was biased toward the lower half of
+  the range.

source/isaaclab_tasks/changelog.d/task-cleanup-dex-part04.minor.rst

@@ -0,0 +1,25 @@
+Added
+^^^^^
+
+* Added an RSL-RL training configuration and behavioral-success metrics to the
+  Shadow handover Direct task.
+* Added renderer presets and configuration validation to the Shadow camera
+  Direct task, including an RGB-depth preset for training with the Newton Warp
+  renderer.
+* Added OVPhysX physics presets to the handover and camera Direct
+  environments.
+
+Deprecated
+^^^^^^^^^^
+
+* Deprecated ``shadow_hand_camera_env.compute_keypoints`` in favor of
+  :func:`~isaaclab_tasks.core.reorient.mdp.observations.compute_cube_keypoints`.
+* Deprecated the ``Isaac-Reorient-Cube-Shadow-Camera-Benchmark-Direct``
+  registration in favor of the regular camera task with the
+  ``env.feature_extractor.enabled=False`` override.
+
+Fixed
+^^^^^
+
+* Fixed handover construction on Newton, broken by renamed distal joints in
+  the current Shadow Newton asset.

source/isaaclab_tasks/changelog.d/task-cleanup-dex-part05.rst

@@ -0,0 +1,11 @@
+Added
+^^^^^
+
+* Added success-rate reporting to the environment training benchmark
+  utilities, with unit tests for the benchmark discovery helpers.
+
+Fixed
+^^^^^
+
+* Fixed training benchmark discovery to exclude inference-only camera
+  benchmark registrations.