verifiers 0.1.15.dev5__tar.gz → 0.1.15.dev6__tar.gz

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev5
+Version: 0.1.15.dev6
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers
@@ -174,6 +174,10 @@ Environments built with Verifiers are self-contained Python modules. To initiali
 ```bash
 prime env init my-env # creates a new template in ./environments/my_env
 ```
+Add an explicit harness loader when the environment owns harness behavior:
+```bash
+prime env init my-env --with-harness
+```
 For OpenEnv integration, use:
 ```bash
 prime env init my-openenv --openenv
@@ -191,7 +195,9 @@ environments/my_env/
 └── README.md           # Documentation
 ```
 
-Environment modules should expose a `load_environment` function which returns an instance of the Environment object, and which can accept custom arguments. For example: 
+Environment modules should expose a `load_environment` function which returns an
+environment object. For simple legacy environments, this can still be a direct
+constructor:
 ```python
 # my_env.py
 import verifiers as vf
@@ -223,7 +229,7 @@ def source():
 async def contains_answer(task, state) -> float:
     return float(task["answer"] in str(state.get("completion") or ""))
 
-def load_taskset(config: vf.TasksetConfig | None = None):
+def load_taskset(config: vf.TasksetConfig):
     return vf.Taskset(source=source, rewards=[contains_answer], config=config)
 
 def load_environment(config: vf.EnvConfig) -> vf.Env:
@@ -244,8 +250,8 @@ env = vf.Env(
 ```
 
 The same environment package is the unit used by evals and `prime-rl`. The
-trainer owns model, endpoint, sampling, and rollout count; v1-specific taskset
-and harness options stay under `env.taskset` and `env.harness`:
+trainer owns model, endpoint, sampling, and rollout count; v1-specific options
+stay on the taskset or harness config that owns them:
 
 ```toml
 # configs/rl/my-v1-env.toml
@@ -260,12 +266,12 @@ max_tokens = 4096
 [[env]]
 id = "my-env"
 
-[env.args]
-arg1 = "non-th-arg"
-
 [env.harness]
 max_turns = 1
 
+[env.taskset]
+split = "train"
+
 [env.taskset.scoring.contains_answer]
 weight = 1.0
 ```

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/README.md

@@ -99,6 +99,10 @@ Environments built with Verifiers are self-contained Python modules. To initiali
 ```bash
 prime env init my-env # creates a new template in ./environments/my_env
 ```
+Add an explicit harness loader when the environment owns harness behavior:
+```bash
+prime env init my-env --with-harness
+```
 For OpenEnv integration, use:
 ```bash
 prime env init my-openenv --openenv
@@ -116,7 +120,9 @@ environments/my_env/
 └── README.md           # Documentation
 ```
 
-Environment modules should expose a `load_environment` function which returns an instance of the Environment object, and which can accept custom arguments. For example: 
+Environment modules should expose a `load_environment` function which returns an
+environment object. For simple legacy environments, this can still be a direct
+constructor:
 ```python
 # my_env.py
 import verifiers as vf
@@ -148,7 +154,7 @@ def source():
 async def contains_answer(task, state) -> float:
     return float(task["answer"] in str(state.get("completion") or ""))
 
-def load_taskset(config: vf.TasksetConfig | None = None):
+def load_taskset(config: vf.TasksetConfig):
     return vf.Taskset(source=source, rewards=[contains_answer], config=config)
 
 def load_environment(config: vf.EnvConfig) -> vf.Env:
@@ -169,8 +175,8 @@ env = vf.Env(
 ```
 
 The same environment package is the unit used by evals and `prime-rl`. The
-trainer owns model, endpoint, sampling, and rollout count; v1-specific taskset
-and harness options stay under `env.taskset` and `env.harness`:
+trainer owns model, endpoint, sampling, and rollout count; v1-specific options
+stay on the taskset or harness config that owns them:
 
 ```toml
 # configs/rl/my-v1-env.toml
@@ -185,12 +191,12 @@ max_tokens = 4096
 [[env]]
 id = "my-env"
 
-[env.args]
-arg1 = "non-th-arg"
-
 [env.harness]
 max_turns = 1
 
+[env.taskset]
+split = "train"
+
 [env.taskset.scoring.contains_answer]
 weight = 1.0
 ```

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/tests/test_langchain_deep_agents_wikispeedia.py

@@ -57,7 +57,7 @@ def test_wikispeedia_loads_as_v1_taskset_harness(
 ) -> None:
     module = load_module(monkeypatch)
 
-    env = module.load_environment(config=vf.EnvConfig(), train_size=1, eval_size=1)
+    env = module.load_environment(config=module.WikispeediaEnvConfig())
 
     assert isinstance(env, vf.Env)
     assert isinstance(env.taskset, vf.Taskset)
@@ -65,6 +65,43 @@ def test_wikispeedia_loads_as_v1_taskset_harness(
     assert env.taskset.taskset_id == "langchain-deep-agents-wikispeedia"
 
 
+def test_wikispeedia_env_config_reaches_taskset_and_harness(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module = load_module(monkeypatch)
+    wiki = make_small_wiki(module)
+    monkeypatch.setattr(module, "load_wiki_graph", lambda cache_dir=None: wiki)
+
+    env = module.load_environment(
+        config=module.WikispeediaEnvConfig(
+            taskset={
+                "train_size": 2,
+                "eval_size": 1,
+                "min_path_length": 1,
+                "max_path_length": 1,
+                "eval_target_fraction": 0.5,
+                "allow_go_back": False,
+                "links_only": True,
+                "max_turns": 7,
+            },
+            harness={
+                "max_turns": 8,
+                "timeout_seconds": 9.0,
+            },
+        )
+    )
+
+    train_rows = list(env.taskset.source())
+    eval_rows = list(env.taskset.eval_source())
+
+    assert len(train_rows) == 2
+    assert len(eval_rows) == 1
+    assert train_rows[0]["max_turns"] == 7
+    assert env.harness.config.max_turns == 8
+    assert env.harness.config.timeout_seconds == 9.0
+    assert [tool.__name__ for tool in env.taskset.toolsets[0].tools] == ["click_link"]
+
+
 def test_wikispeedia_rows_use_v1_task_shape(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -90,11 +127,13 @@ def test_wikispeedia_taskset_sources_use_disjoint_target_split(
     wiki = make_small_wiki(module)
     monkeypatch.setattr(module, "load_wiki_graph", lambda cache_dir=None: wiki)
     taskset = module.load_taskset(
-        train_size=2,
-        eval_size=1,
-        min_path_length=1,
-        max_path_length=1,
-        eval_target_fraction=0.5,
+        config=module.WikispeediaTasksetConfig(
+            train_size=2,
+            eval_size=1,
+            min_path_length=1,
+            max_path_length=1,
+            eval_target_fraction=0.5,
+        )
     )
 
     train_rows = list(taskset.source())
@@ -114,8 +153,12 @@ def test_wikispeedia_efficiency_weight_uses_fresh_reward_wrapper(
     wiki = make_small_wiki(module)
     monkeypatch.setattr(module, "load_wiki_graph", lambda cache_dir=None: wiki)
 
-    weighted = module.load_taskset(efficiency_weight=0.5)
-    plain = module.load_taskset(efficiency_weight=0.0)
+    weighted = module.load_taskset(
+        config=module.WikispeediaTasksetConfig(efficiency_weight=0.5)
+    )
+    plain = module.load_taskset(
+        config=module.WikispeediaTasksetConfig(efficiency_weight=0.0)
+    )
 
     assert any(fn.__name__ == "path_efficiency" for fn in weighted.rewards)
     assert any(fn is module.path_efficiency for fn in plain.metrics)
@@ -127,13 +170,17 @@ def test_wikispeedia_taskset_owns_navigation_tools(
 ) -> None:
     module = load_module(monkeypatch)
 
-    taskset = module.load_taskset(allow_go_back=True)
+    taskset = module.load_taskset(
+        config=module.WikispeediaTasksetConfig(allow_go_back=True)
+    )
     names = [tool.__name__ for tool in taskset.toolsets[0].tools]
-    no_back = module.load_taskset(allow_go_back=False)
+    no_back = module.load_taskset(
+        config=module.WikispeediaTasksetConfig(allow_go_back=False)
+    )
 
     assert names == ["click_link", "go_back"]
     assert [tool.__name__ for tool in no_back.toolsets[0].tools] == ["click_link"]
-    assert module.load_harness().toolsets == []
+    assert module.load_harness(config=module.WikispeediaHarnessConfig()).toolsets == []
 
 
 def test_wikispeedia_system_prompt_matches_available_tools(
@@ -141,8 +188,12 @@ def test_wikispeedia_system_prompt_matches_available_tools(
 ) -> None:
     module = load_module(monkeypatch)
 
-    with_back = module.load_taskset(allow_go_back=True)
-    without_back = module.load_taskset(allow_go_back=False)
+    with_back = module.load_taskset(
+        config=module.WikispeediaTasksetConfig(allow_go_back=True)
+    )
+    without_back = module.load_taskset(
+        config=module.WikispeediaTasksetConfig(allow_go_back=False)
+    )
 
     assert "go_back" in with_back.system_prompt[0]["content"]
     assert "go_back" not in without_back.system_prompt[0]["content"]
@@ -156,12 +207,16 @@ async def test_wikispeedia_tools_resolve_through_v1_runtime(
     module = load_module(monkeypatch)
     wiki = make_small_wiki(module)
     monkeypatch.setattr(module, "load_wiki_graph", lambda cache_dir=None: wiki)
-    env = module.load_environment(
-        config=vf.EnvConfig(),
-        train_size=2,
-        eval_size=1,
-        min_path_length=1,
-        max_path_length=1,
+    env = vf.Env(
+        taskset=module.load_taskset(
+            config=module.WikispeediaTasksetConfig(
+                train_size=2,
+                eval_size=1,
+                min_path_length=1,
+                max_path_length=1,
+            )
+        ),
+        harness=module.load_harness(config=module.WikispeediaHarnessConfig()),
     )
     task = module.vf.Task(list(env.taskset.source())[0]).freeze()
     state = module.vf.State.for_task(task)

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/tests/test_mcp_search_env.py

@@ -26,7 +26,9 @@ def _load_mcp_search_module() -> Any:
 def test_mcp_search_env_is_v1_only() -> None:
     module = _load_mcp_search_module()
 
-    env = module.load_environment(config=vf.EnvConfig(), max_turns=4)
+    env = module.load_environment(
+        config=module.MCPSearchEnvConfig(taskset={"max_turns": 4})
+    )
 
     assert isinstance(env, vf.Env)
     assert isinstance(env.taskset, vf.Taskset)
@@ -40,7 +42,7 @@ def test_mcp_search_env_is_v1_only() -> None:
 def test_mcp_search_default_taskset_has_stable_non_doc_fixture() -> None:
     module = _load_mcp_search_module()
 
-    rows = module.load_taskset().rows()
+    rows = module.load_taskset(config=module.MCPSearchTasksetConfig()).rows()
 
     assert len(rows) >= 10
     assert len({row["answer"] for row in rows}) == len(rows)
@@ -52,7 +54,7 @@ def test_mcp_search_taskset_accepts_v1_taskset_config() -> None:
     module = _load_mcp_search_module()
 
     env = module.load_environment(
-        config=vf.EnvConfig(taskset={"max_turns": 3}),
+        config=module.MCPSearchEnvConfig(taskset={"max_turns": 3}),
     )
     rows = env.taskset.rows()
 

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/tests/test_opencode_harbor.py

@@ -28,7 +28,7 @@ def _load_opencode_module() -> Any:
 def test_load_environment_uses_v1_taskset_and_harness() -> None:
     module = _load_opencode_module()
 
-    env = module.load_environment(config=vf.EnvConfig())
+    env = module.load_environment(config=module.OpenCodeHarborEnvConfig())
 
     assert isinstance(env, vf.Env)
     assert isinstance(env.taskset, vf.HarborTaskset)
@@ -52,7 +52,7 @@ def test_load_environment_accepts_v1_taskset_and_harness_config() -> None:
     module = _load_opencode_module()
 
     env = module.load_environment(
-        config=vf.EnvConfig(
+        config=module.OpenCodeHarborEnvConfig(
             taskset={
                 "task_names": ["task-a"],
                 "cpu_cores": 1.5,

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/tests/test_save_utils.py

@@ -32,6 +32,7 @@ from verifiers.utils.save_utils import (
     make_serializable,
     save_new_outputs,
     states_to_outputs,
+    truncate_malformed_trailing_line,
     validate_resume_metadata,
 )
 from verifiers.utils.usage_utils import StateUsageTracker, response_usage_tokens
@@ -488,6 +489,9 @@ class TestSaveNewOutputs:
             "\n".join(lines + [malformed_trailing_line]), encoding="utf-8"
         )
 
+        # Caller drops the partial trailing row before appending so the new
+        # row lands on a valid JSONL boundary.
+        truncate_malformed_trailing_line(outputs_path)
         save_new_outputs(
             [{"example_id": 3, "label": "row-3"}],
             results_path,

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/tests/test_v1_bfcl.py

@@ -75,12 +75,12 @@ def test_bfcl_public_loader_is_v1_only(monkeypatch: pytest.MonkeyPatch) -> None:
     seen_taskset_config: vf.TasksetConfig | None = None
     seen_harness_config: vf.HarnessConfig | None = None
 
-    def fake_taskset(config: vf.TasksetConfig | None = None) -> vf.Taskset:
+    def fake_taskset(config: vf.TasksetConfig) -> vf.Taskset:
         nonlocal seen_taskset_config
         seen_taskset_config = config
         return vf.Taskset(source=[], config=config)
 
-    def fake_harness(config: vf.HarnessConfig | None = None) -> vf.Harness:
+    def fake_harness(config: vf.HarnessConfig) -> vf.Harness:
         nonlocal seen_harness_config
         seen_harness_config = config
         return vf.Harness(config=config)
@@ -89,9 +89,13 @@ def test_bfcl_public_loader_is_v1_only(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(bfcl, "load_harness", fake_harness)
 
     env = bfcl.load_environment(
-        config=vf.EnvConfig(),
-        test_category="simple_python",
-        examples_per_category=0,
+        config=bfcl.BFCLEnvConfig(
+            taskset=bfcl.BFCLTasksetConfig(
+                test_category="simple_python",
+                examples_per_category=0,
+            ),
+            harness=bfcl.BFCLHarnessConfig(),
+        )
     )
 
     assert isinstance(env, vf.Env)
@@ -110,12 +114,12 @@ def test_bfcl_loader_supports_category_groups(
     seen_taskset_categories = []
     seen_harness_categories = []
 
-    def fake_taskset(config: vf.TasksetConfig | None = None) -> vf.Taskset:
+    def fake_taskset(config: vf.TasksetConfig) -> vf.Taskset:
         assert isinstance(config, bfcl.BFCLTasksetConfig)
         seen_taskset_categories.append(config.test_category)
         return vf.Taskset(source=[{"question": "q", "answer": "a"}], config=config)
 
-    def fake_harness(config: vf.HarnessConfig | None = None) -> vf.Harness:
+    def fake_harness(config: vf.HarnessConfig) -> vf.Harness:
         assert isinstance(config, bfcl.BFCLHarnessConfig)
         seen_harness_categories.append(config.test_category)
         return vf.Harness(config=config)
@@ -124,9 +128,13 @@ def test_bfcl_loader_supports_category_groups(
     monkeypatch.setattr(bfcl, "load_harness", fake_harness)
 
     env = bfcl.load_environment(
-        config=vf.EnvConfig(),
-        test_categories=["simple_python", "simple_java"],
-        examples_per_category=0,
+        config=bfcl.BFCLEnvConfig(
+            taskset=bfcl.BFCLTasksetConfig(
+                test_categories=["simple_python", "simple_java"],
+                examples_per_category=0,
+            ),
+            harness=bfcl.BFCLHarnessConfig(),
+        )
     )
 
     assert isinstance(env, root_vf.EnvGroup)

{verifiers-0.1.15.dev5 → verifiers-0.1.15.dev6}/tests/test_v1_config_extension.py

@@ -1185,6 +1185,29 @@ def test_config_schema_is_visible_from_primary_types() -> None:
     assert "bindings" in vf.ToolsetConfig.schema_text()
 
 
+def test_config_annotation_only_nested_config_defaults_recursively() -> None:
+    class LeafConfig(Config):
+        value: int = 1
+
+    class ChildConfig(Config):
+        leaf: LeafConfig
+
+    class ParentConfig(Config):
+        child: ChildConfig
+
+    first = ParentConfig()
+    second = ParentConfig()
+    configured = ParentConfig({"child": {"leaf": {"value": 3}}})
+
+    assert isinstance(first.child, ChildConfig)
+    assert isinstance(first.child.leaf, LeafConfig)
+    assert first.child.leaf.value == 1
+    assert first.child is not second.child
+    assert first.child.leaf is not second.child.leaf
+    assert configured.child.leaf.value == 3
+    assert "child: ChildConfig = <factory>" in ParentConfig.schema_text()
+
+
 def test_env_config_normalizes_mapping_config_to_attributes() -> None:
     config = EnvConfig(
         {
@@ -1193,8 +1216,17 @@ def test_env_config_normalizes_mapping_config_to_attributes() -> None:
         }
     )
 
-    assert config.taskset == {"taskset_id": "dict"}
-    assert config.harness == {"model": "configured-model"}
+    assert isinstance(config.taskset, TasksetConfig)
+    assert isinstance(config.harness, HarnessConfig)
+    assert config.taskset.taskset_id == "dict"
+    assert config.harness.model == "configured-model"
+
+
+def test_env_config_defaults_taskset_and_harness_to_base_configs() -> None:
+    config = EnvConfig()
+
+    assert isinstance(config.taskset, TasksetConfig)
+    assert isinstance(config.harness, HarnessConfig)
 
 
 def test_env_config_rejects_unknown_top_level_sections() -> None:
@@ -1205,6 +1237,34 @@ def test_env_config_rejects_unknown_top_level_sections() -> None:
 def test_env_config_requires_child_sections_to_be_configs() -> None:
     with pytest.raises(ValueError):
         EnvConfig({"taskset": 1})
+    with pytest.raises(ValueError, match="EnvConfig.taskset cannot be None"):
+        EnvConfig({"taskset": None})
+    with pytest.raises(ValueError, match="EnvConfig.harness cannot be None"):
+        EnvConfig(harness=None)
+
+
+def test_env_config_child_config_objects_must_match_domain() -> None:
+    class LocalTasksetConfig(TasksetConfig):
+        split: str = "train"
+
+    class LocalHarnessConfig(HarnessConfig):
+        mode: str = "default"
+
+    config = EnvConfig(
+        taskset=LocalTasksetConfig(split="test"),
+        harness=LocalHarnessConfig(mode="custom"),
+    )
+
+    assert isinstance(config.taskset, LocalTasksetConfig)
+    assert isinstance(config.harness, LocalHarnessConfig)
+
+    class LocalConfig(Config):
+        split: str = "train"
+
+    with pytest.raises(ValueError):
+        EnvConfig(taskset=LocalConfig())
+    with pytest.raises(ValueError):
+        EnvConfig(harness=LocalConfig())
 
 
 def test_env_config_merges_child_config_defaults_with_nested_sections() -> None:
@@ -1234,25 +1294,53 @@ def test_env_config_merges_child_config_defaults_with_nested_sections() -> None:
     assert default_config.taskset.split == "kwarg"
 
 
-def test_env_config_args_supplies_typed_top_level_args() -> None:
-    class LocalArgsConfig(Config):
-        split: str = "train"
-        max_turns: int = 4
-
-    config = EnvConfig(
-        {"args": {"max_turns": 7}},
-        args=LocalArgsConfig(split="args"),
+def test_config_object_merge_omits_nested_none_values() -> None:
+    base = HarnessConfig(
+        sampling_args={
+            "temperature": 0.7,
+            "extra_body": {
+                "top_k": 40,
+                "top_p": 0.9,
+            },
+        }
     )
+    override = HarnessConfig(
+        sampling_args={
+            "extra_body": {
+                "top_p": None,
+                "min_p": 0.05,
+            },
+            "stop": [None, "DONE"],
+        }
+    )
+    config = EnvConfig(EnvConfig(harness=override), harness=base)
+
+    assert config.harness.sampling_args == {
+        "temperature": 0.7,
+        "extra_body": {
+            "top_k": 40,
+            "top_p": 0.9,
+            "min_p": 0.05,
+        },
+        "stop": [None, "DONE"],
+    }
 
-    assert isinstance(config.args, LocalArgsConfig)
-    assert config.args.split == "args"
-    assert config.args.max_turns == 7
 
+def test_env_config_subclasses_cannot_define_root_fields() -> None:
+    with pytest.raises(TypeError, match="unsupported root env config fields"):
 
-def test_env_config_args_accepts_arbitrary_user_args() -> None:
-    config = EnvConfig(args={"k1": "v1", "k2": "v2"})
+        class LocalEnvConfig(EnvConfig):
+            split: str = "train"
 
-    assert config.args == {"k1": "v1", "k2": "v2"}
+
+def test_env_config_subclasses_must_use_domain_child_configs() -> None:
+    class LocalConfig(Config):
+        split: str = "train"
+
+    with pytest.raises(TypeError, match="taskset must be typed"):
+
+        class LocalEnvConfig(EnvConfig):
+            taskset: LocalConfig
 
 
 def test_env_config_harness_section_extends_imported_config() -> None:
@@ -1335,6 +1423,56 @@ def test_load_environment_coerces_typed_env_config_arg(
     }
 
 
+def test_load_environment_coerces_env_config_subclass_sections(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    module_name = "typed_env_config_subclass"
+    module = types.ModuleType(module_name)
+    seen: dict[str, object] = {}
+
+    class LocalTasksetConfig(TasksetConfig):
+        split: str = "train"
+
+    class LocalHarnessConfig(HarnessConfig):
+        mode: str = "default"
+
+    class LocalEnvConfig(EnvConfig):
+        taskset: LocalTasksetConfig
+        harness: LocalHarnessConfig
+
+    class LocalTaskset(Taskset):
+        config_type = LocalTasksetConfig
+
+    class LocalHarness(Harness):
+        config_type = LocalHarnessConfig
+
+    def load_environment(config: LocalEnvConfig) -> Env:
+        seen["config"] = config
+        return Env(
+            taskset=LocalTaskset(source=source_loader, config=config.taskset),
+            harness=LocalHarness(config=config.harness),
+        )
+
+    module.load_environment = load_environment
+    monkeypatch.setitem(sys.modules, module_name, module)
+
+    env = vf.load_environment(
+        "typed-env-config-subclass",
+        config={
+            "taskset": {"taskset_id": "typed", "split": "test"},
+            "harness": {"mode": "custom"},
+        },
+    )
+    config = seen["config"]
+
+    assert isinstance(config, LocalEnvConfig)
+    assert isinstance(config.taskset, LocalTasksetConfig)
+    assert isinstance(config.harness, LocalHarnessConfig)
+    assert env.taskset.config.taskset_id == "typed"
+    assert env.taskset.config.split == "test"
+    assert env.harness.config.mode == "custom"
+
+
 def test_load_environment_supplies_default_typed_env_config(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -1457,9 +1595,24 @@ def test_reference_v1_harness_loaders_preserve_child_defaults() -> None:
         "environments.hello_self_judge_v1.hello_self_judge_v1"
     )
 
-    assert group_reward.load_harness().config.max_turns == 1
-    assert parallel_sandbox.load_harness().config.max_turns == 4
-    assert self_judge.load_harness().config.max_turns == 8
+    assert (
+        group_reward.load_harness(
+            config=group_reward.GroupRewardHarnessConfig()
+        ).config.max_turns
+        == 1
+    )
+    assert (
+        parallel_sandbox.load_harness(
+            config=parallel_sandbox.ParallelSandboxHarnessConfig()
+        ).config.max_turns
+        == 4
+    )
+    assert (
+        self_judge.load_harness(
+            config=self_judge.SelfJudgeHarnessConfig()
+        ).config.max_turns
+        == 8
+    )
 
 
 def test_bfcl_loader_preserves_mapping_config_sections(
@@ -1482,7 +1635,7 @@ def test_bfcl_loader_preserves_mapping_config_sections(
     monkeypatch.setattr(module, "load_harness", fake_harness)
 
     env = module.load_environment(
-        config=EnvConfig(
+        config=module.BFCLEnvConfig(
             taskset={"taskset_id": "bfcl-env-args"},
             harness={"model": "bfcl-model"},
         )
@@ -1508,7 +1661,7 @@ def test_tau2_loader_forwards_mapping_harness_config(
     monkeypatch.setattr(module, "load_taskset", fake_taskset)
 
     env = module.load_environment(
-        config=EnvConfig(
+        config=module.Tau2EnvConfig(
             taskset={"max_turns": 7},
             harness={"model": "configured-model", "max_turns": 3},
         )
@@ -1623,17 +1776,16 @@ def test_self_judge_loader_projects_shortcuts_to_child_configs() -> None:
         "environments.hello_self_judge_v1.hello_self_judge_v1"
     )
 
-    taskset = module.load_taskset(num_examples=2)
-    harness = module.load_harness(max_turns=3)
+    taskset = module.load_taskset(config=module.SelfJudgeTasksetConfig(num_examples=2))
+    harness = module.load_harness(config=module.SelfJudgeHarnessConfig(max_turns=3))
     shortcut_env = module.load_environment(
-        num_examples=2,
-        max_turns=3,
-        config=EnvConfig(),
+        config=module.SelfJudgeEnvConfig(
+            taskset={"num_examples": 2},
+            harness={"max_turns": 3},
+        ),
     )
     override_env = module.load_environment(
-        num_examples=2,
-        max_turns=3,
-        config=EnvConfig(
+        config=module.SelfJudgeEnvConfig(
             taskset={"num_examples": 1},
             harness={"max_turns": 5},
         ),