chore: restore adding_benchmarks + test_dispatch, drop env_processor changes

- Restore docs/source/adding_benchmarks.mdx (belongs in this PR)
- Restore tests/envs/test_dispatch.py (belongs in this PR)
- Revert docs/source/env_processor.mdx to main (out of scope for this PR)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

docs/source/env_processor.mdx

@@ -25,28 +25,31 @@ raw_observation = env.step(action)
 # 2. Convert numpy to torch, normalize images [0,1]
 observation = preprocess_observation(raw_observation)
 
-# 3. ENVIRONMENT-SPECIFIC preprocessing (NEW!)
+# 3. Add task metadata (for multi-task environments)
+observation = add_envs_task(env, observation)
+
+# 4. ENVIRONMENT-SPECIFIC preprocessing (NEW!)
 #    - Flatten robot states
 #    - Rotate images to match dataset conventions
 #    - Handle environment-specific coordinate systems
 observation = env_preprocessor(observation)
 
-# 4. POLICY-SPECIFIC preprocessing
+# 5. POLICY-SPECIFIC preprocessing
 #    - Normalize with dataset statistics
 #    - Add batch dimensions
 #    - Move to GPU
 #    - Tokenize language instructions
 observation = preprocessor(observation)
 
-# 5. Policy inference
+# 6. Policy inference
 action = policy.select_action(observation)
 
-# 6. POLICY-SPECIFIC postprocessing
+# 7. POLICY-SPECIFIC postprocessing
 #    - Unnormalize actions
 #    - Remove batch dimensions
 action = postprocessor(action)
 
-# 7. ENVIRONMENT-SPECIFIC postprocessing (NEW!)
+# 8. ENVIRONMENT-SPECIFIC postprocessing (NEW!)
 #    - Convert action formats if needed
 #    - Apply environment-specific constraints
 action_transition = {"action": action}
@@ -148,7 +151,7 @@ observation = {
 
 ### Factory Function
 
-The `make_env_pre_post_processors` function delegates to `env_cfg.get_env_processors()`:
+The `make_env_pre_post_processors` function follows the same pattern as `make_pre_post_processors` for policies:
 
 ```python
 from lerobot.envs.factory import make_env_pre_post_processors
@@ -156,30 +159,46 @@ from lerobot.envs.configs import LiberoEnv, PushtEnv
 
 # For LIBERO: Returns LiberoProcessorStep in preprocessor
 libero_cfg = LiberoEnv(task="libero_spatial", camera_name=["agentview"])
-env_preprocessor, env_postprocessor = make_env_pre_post_processors(libero_cfg, policy_cfg)
+env_preprocessor, env_postprocessor = make_env_pre_post_processors(libero_cfg)
 
 # For other environments: Returns identity processors (no-op)
 pusht_cfg = PushtEnv()
-env_preprocessor, env_postprocessor = make_env_pre_post_processors(pusht_cfg, policy_cfg)
+env_preprocessor, env_postprocessor = make_env_pre_post_processors(pusht_cfg)
 ```
 
-### How It Works
-
-Each `EnvConfig` subclass can override `get_env_processors()` to return benchmark-specific
-processor pipelines. The base class returns identity (no-op) processors by default.
+### Implementation in `envs/factory.py`
 
 ```python
-# In your EnvConfig subclass:
-def get_env_processors(self):
-    from lerobot.processor.pipeline import PolicyProcessorPipeline
-    return (
-        PolicyProcessorPipeline(steps=[MyProcessorStep()]),
-        PolicyProcessorPipeline(steps=[]),
-    )
-```
+def make_env_pre_post_processors(
+    env_cfg: EnvConfig,
+) -> tuple[
+    PolicyProcessorPipeline[dict[str, Any], dict[str, Any]],
+    PolicyProcessorPipeline[dict[str, Any], dict[str, Any]],
+]:
+    """
+    Create preprocessor and postprocessor pipelines for environment observations.
 
-The factory function `make_env_pre_post_processors` simply delegates to this method,
-with a special case for `XVLAConfig` policies which override the env processors entirely.
+    Args:
+        env_cfg: The configuration of the environment.
+
+    Returns:
+        A tuple containing:
+            - preprocessor: Pipeline that processes environment observations
+            - postprocessor: Pipeline that processes environment outputs
+    """
+    # For LIBERO environments, add the LiberoProcessorStep to preprocessor
+    if isinstance(env_cfg, LiberoEnv) or "libero" in env_cfg.type:
+        preprocessor = PolicyProcessorPipeline(steps=[LiberoProcessorStep()])
+    else:
+        # For all other environments, return an identity preprocessor
+        preprocessor = PolicyProcessorPipeline(steps=[])
+
+    # Postprocessor is currently identity for all environments
+    # Future: Could add environment-specific action transformations
+    postprocessor = PolicyProcessorPipeline(steps=[])
+
+    return preprocessor, postprocessor
+```
 
 ### Integration in Evaluation
 
@@ -200,10 +219,7 @@ def eval_main(cfg: EvalPipelineConfig):
     )
 
     # Create environment processors (NEW!)
-    env_preprocessor, env_postprocessor = make_env_pre_post_processors(
-        env_cfg=cfg.env,
-        policy_cfg=cfg.policy,
-    )
+    env_preprocessor, env_postprocessor = make_env_pre_post_processors(env_cfg=cfg.env)
 
     # Run evaluation with both processor types
     eval_policy_all(
@@ -310,19 +326,18 @@ class MyEnvProcessorStep(ObservationProcessorStep):
 ### 2. Update the Factory
 
 ```python
-# In src/lerobot/envs/configs.py
-@EnvConfig.register_subclass("myenv")
-@dataclass
-class MyEnvConfig(EnvConfig):
-    # ... task/features/gym kwargs ...
+# In src/lerobot/envs/factory.py
 
-    def get_env_processors(self):
-        from lerobot.processor.pipeline import PolicyProcessorPipeline
+def make_env_pre_post_processors(env_cfg: EnvConfig):
+    if isinstance(env_cfg, LiberoEnv) or "libero" in env_cfg.type:
+        preprocessor = PolicyProcessorPipeline(steps=[LiberoProcessorStep()])
+    elif isinstance(env_cfg, MyEnvConfig) or "myenv" in env_cfg.type:
+        preprocessor = PolicyProcessorPipeline(steps=[MyEnvProcessorStep()])
+    else:
+        preprocessor = PolicyProcessorPipeline(steps=[])
 
-        return (
-            PolicyProcessorPipeline(steps=[MyEnvProcessorStep()]),
-            PolicyProcessorPipeline(steps=[]),
-        )
+    postprocessor = PolicyProcessorPipeline(steps=[])
+    return preprocessor, postprocessor
 ```
 
 ### 3. Use in Evaluation