verifiers 0.2.2.dev112__tar.gz → 0.3.1__tar.gz

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: verifiers
-Version: 0.2.2.dev112
+Version: 0.3.1
 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
@@ -34,12 +34,12 @@ Requires-Dist: msgpack>=1.1.2
 Requires-Dist: numpy>=2.1.0
 Requires-Dist: openai-agents>=0.8.2
 Requires-Dist: openai>=2.9.0
-Requires-Dist: prime-pydantic-config[toml]>=0.4.2
-Requires-Dist: prime-sandboxes>=0.2.35
+Requires-Dist: prime-pydantic-config[toml]>=0.4.3
+Requires-Dist: prime-sandboxes>=0.2.39
 Requires-Dist: prime-tunnel>=0.1.8
 Requires-Dist: pydantic>=2.12.3
 Requires-Dist: pyzmq>=27.1.0
-Requires-Dist: renderers>=0.1.9
+Requires-Dist: renderers>=0.1.10
 Requires-Dist: requests
 Requires-Dist: rich>=11.0.0
 Requires-Dist: setproctitle>=1.3.0
@@ -51,7 +51,7 @@ Provides-Extra: browser
 Requires-Dist: python-dotenv>=1.0.0; extra == 'browser'
 Requires-Dist: stagehand>=3.4.0; extra == 'browser'
 Provides-Extra: harbor
-Requires-Dist: harbor==0.20.0; (python_version >= '3.12') and extra == 'harbor'
+Requires-Dist: harbor==0.21.0; (python_full_version >= '3.12') and extra == 'harbor'
 Provides-Extra: modal
 Requires-Dist: modal>=1.4.0; extra == 'modal'
 Provides-Extra: nemo-gym

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/pyproject.toml

@@ -35,7 +35,7 @@ dependencies = [
     "openai>=2.9.0",
     "openai-agents>=0.8.2",
     "prime-tunnel>=0.1.8",
-    "prime-sandboxes>=0.2.35",
+    "prime-sandboxes>=0.2.39",
     "pydantic>=2.12.3",
     "requests",
     "rich>=11.0.0",
@@ -47,11 +47,11 @@ dependencies = [
     "setproctitle>=1.3.0",
     "httpx>=0.27.0",
     "aiohttp>=3.9.0",
-    "prime-pydantic-config[toml]>=0.4.2",
+    "prime-pydantic-config[toml]>=0.4.3",
     "uvloop>=0.21.0; sys_platform != 'win32' and sys_platform != 'cygwin' and platform_python_implementation != 'PyPy'",
     "loguru>=0.7.0",
     "tomli-w>=1.0.0",
-    "renderers>=0.1.9",
+    "renderers>=0.1.10",
     "typing_extensions>=4.12.2",
 ]
 
@@ -76,10 +76,23 @@ dev = [
 # from this repo. The built-in tasksets/harnesses ship inside verifiers (verifiers/v1/...).
 examples = [
     "compact",
-    "gsm8k-v1", "glossary-v1", "deepwiki-v1", "wiki-search-v1", "code-golf-v1",
-    "proposer-solver-v1", "reverse-text-v1", "color-codeword-v1",
-    "wordle-v1", "openenv-wordle-v1", "alphabet-sort-v1", "scratchpad-v1",
-    "kuhn-poker-v1",
+    "gsm8k",
+    "glossary",
+    "deepwiki",
+    "wiki-search",
+    "code-golf",
+    "proposer-solver",
+    "reverse-text",
+    "color-codeword",
+    "wordle",
+    "openenv-wordle",
+    "alphabet-sort",
+    "scratchpad",
+    "kuhn-poker",
+    "interception",
+    "grayscale-interception",
+    "bash-interception",
+    "web-search-interception",
 ]
 
 [project.optional-dependencies]
@@ -96,7 +109,7 @@ browser = [
 ]
 harbor = [
     # Harbor currently publishes Python 3.12+ packages; keep core verifiers installable on 3.11.
-    "harbor==0.20.0; python_version >= '3.12'",
+    "harbor==0.21.0 ; python_full_version >= '3.12'",
 ]
 modal = [
     "modal>=1.4.0",
@@ -151,24 +164,29 @@ default = true
 
 [tool.uv.sources]
 compact = { path = "environments/compact", editable = true }
-glossary-v1 = { path = "environments/glossary_v1", editable = true }
-deepwiki-v1 = { path = "environments/deepwiki_v1", editable = true }
-wiki-search-v1 = { path = "environments/wiki_search_v1", editable = true }
-gsm8k-v1 = { path = "environments/gsm8k_v1", editable = true }
-code-golf-v1 = { path = "environments/code_golf_v1", editable = true }
-proposer-solver-v1 = { path = "environments/proposer_solver_v1", editable = true }
-reverse-text-v1 = { path = "environments/reverse_text_v1", editable = true }
-wordle-v1 = { path = "environments/wordle_v1", editable = true }
-openenv-wordle-v1 = { path = "environments/openenv_wordle_v1", editable = true }
-color-codeword-v1 = { path = "environments/color_codeword_v1", editable = true }
-alphabet-sort-v1 = { path = "environments/alphabet_sort_v1", editable = true }
-scratchpad-v1 = { path = "environments/scratchpad_v1", editable = true }
-kuhn-poker-v1 = { path = "environments/kuhn_poker_v1", editable = true }
+glossary = { path = "environments/glossary", editable = true }
+deepwiki = { path = "environments/deepwiki", editable = true }
+wiki-search = { path = "environments/wiki_search", editable = true }
+gsm8k = { path = "environments/gsm8k", editable = true }
+code-golf = { path = "environments/code_golf", editable = true }
+proposer-solver = { path = "environments/proposer_solver", editable = true }
+reverse-text = { path = "environments/reverse_text", editable = true }
+wordle = { path = "environments/wordle", editable = true }
+openenv-wordle = { path = "environments/openenv_wordle", editable = true }
+color-codeword = { path = "environments/color_codeword", editable = true }
+alphabet-sort = { path = "environments/alphabet_sort", editable = true }
+scratchpad = { path = "environments/scratchpad", editable = true }
+kuhn-poker = { path = "environments/kuhn_poker", editable = true }
+interception = { path = "environments/interception", editable = true }
+grayscale-interception = { path = "environments/grayscale_interception", editable = true }
+bash-interception = { path = "environments/bash_interception", editable = true }
+web-search-interception = { path = "environments/web_search_interception", editable = true }
 
 [tool.uv.exclude-newer-package]
 # Bounded cutoffs for the explicitly requested tool upgrades.
 # Full UTC timestamps: bare dates resolve to local-tz midnight and churn the
 # lockfile across timezones.
+harbor = "2026-08-11T00:00:00Z"
 ruff = "2026-07-28T00:00:00Z"
 ty = "2026-07-28T00:00:00Z"
 # PrimeIntellect-published on PyPI (trusted publisher)
@@ -178,19 +196,19 @@ prime-pydantic-config = false
 renderers = false
 
 [project.scripts]
-vf-eval = "verifiers.scripts.eval:main"
 eval = "verifiers.v1.cli.eval.main:main"
 validate = "verifiers.v1.cli.validate:main"
 debug = "verifiers.v1.cli.debug:main"
 replay = "verifiers.v1.cli.replay:main"
 init = "verifiers.v1.cli.init:main"
 gepa = "verifiers.v1.cli.gepa:main"
-vf-gepa = "verifiers.scripts.gepa:main"
-vf-init = "verifiers.scripts.init:main"
-vf-install = "verifiers.scripts.install:main"
-vf-setup = "verifiers.scripts.setup:main"
-vf-build = "verifiers.scripts.build:main"
-vf-tui = "verifiers.scripts.tui:main"
+vf-eval = "verifiers.legacy.scripts.eval:main"
+vf-gepa = "verifiers.legacy.scripts.gepa:main"
+vf-init = "verifiers.legacy.scripts.init:main"
+vf-install = "verifiers.legacy.scripts.install:main"
+vf-setup = "verifiers.legacy.scripts.setup:main"
+vf-build = "verifiers.legacy.scripts.build:main"
+vf-tui = "verifiers.legacy.scripts.tui:main"
 
 # hatchling configuration
 [tool.hatch.version]
@@ -238,6 +256,12 @@ Documentation = "https://github.com/primeintellect-ai/verifiers"
 Repository = "https://github.com/primeintellect-ai/verifiers.git"
 Issues = "https://github.com/primeintellect-ai/verifiers/issues"
 
+[tool.ruff.lint.isort]
+# The legacy tree answers at both verifiers.* and verifiers.legacy.* (the
+# package-root alias); path probing would classify the moved submodules as
+# third-party, so pin the whole namespace first-party.
+known-first-party = ["verifiers"]
+
 [tool.pytest.ini_options]
 minversion = "7.0"
 testpaths = ["tests"]
@@ -300,7 +324,7 @@ redundant-cast = "ignore"
 exclude = ["environments", "verifiers/v1"]
 
 [[tool.ty.overrides]]
-include = ["verifiers/envs/experimental/composable/tasksets/**"]
+include = ["verifiers/legacy/envs/experimental/composable/tasksets/**"]
 
 [tool.ty.overrides.rules]
 unresolved-import = "ignore"

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/test_imports.py

@@ -50,8 +50,9 @@ class TestImports:
 
     def test_lazy_imports_work(self):
         """Test that lazy imports work correctly."""
-        # Dynamically detect lazy imports by checking verifiers module
-        lazy_imports = getattr(verifiers, "_LAZY_IMPORTS", {})
+        # The lazy table lives on the legacy package; the root forwards its names.
+        lazy_imports = verifiers.legacy._LAZY_IMPORTS
+        assert lazy_imports, "legacy lazy-import table is empty"
 
         for name in lazy_imports.keys():
             assert name in verifiers.__all__, f"Lazy import {name} not in __all__"

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/conftest.py

@@ -5,8 +5,7 @@ settings that still exercise the path, then assert on the resulting `Trace`(s)
 not unit tests of individual components. They need a model API key (`PRIME_API_KEY`);
 without one the `e2e`-marked tests skip (config parsing still runs).
 
-`run_v1` / `run_v0` mirror the eval CLI's two paths (`run_eval` for a v1 taskset,
-`run_legacy_eval` for a v0 env). Placement coverage (harness x harness runtime x tool
+`run_v1` mirrors the eval CLI's in-process path (`run_eval` with `--no-serve`). Placement coverage (harness x harness runtime x tool
 server runtime) is PAIRWISE, not a full cross product: each test carries a curated list of
 combinations (in test_e2e.py) that hits every axis value and the cross-boundary pairs with
 distinct networking. The full cross bought flake exposure and CI minutes, not coverage — add
@@ -41,14 +40,14 @@ import pytest
 import verifiers.v1 as vf
 from verifiers.v1.cli.eval.runner import run_eval
 from verifiers.v1.configs.cli.eval import EvalConfig
+from verifiers.v1.configs.harness import HarnessConfig
 from verifiers.v1.trace import Trace
-from verifiers.v1.utils.loaders import load_environment
+from verifiers.v1.utils.loaders import harness_config_type
 
 CI_MODEL = "openai/gpt-5.6-luna"
 
-# Fixture tasksets/envs (echo-v1, echo-agentic-v1, echo-v0, echo-multi-v0) live in
-# tests/v1/fixtures, added to the path via `pythonpath` in pyproject so the v1 loader and the
-# v0 legacy bridge both resolve them by id (no install).
+# Fixture tasksets (echo-v1, echo-agentic-v1) live in tests/v1/fixtures, added to the
+# path via `pythonpath` in pyproject so the loader resolves them by id (no install).
 
 # The placement fixtures translate one parametrized value each; the combinations live on
 # the tests (`indirect=True`), so coverage is a visible, curated list — never an implicit
@@ -76,15 +75,16 @@ def tool_runtime(request) -> dict:
 # dependencies at rollout.
 # `compact` (an example harness) and `terminus-2` (drives the host tmux) are excluded from e2e.
 @pytest.fixture
-def harness(request) -> str:
-    return request.param
+def harness(request) -> HarnessConfig:
+    config = {"id": request.param} if isinstance(request.param, str) else request.param
+    return harness_config_type(config["id"]).model_validate(config)
 
 
 def pytest_configure(config) -> None:
     """Self-launching tool servers run `python -m <module>` in a fresh subprocess, which
     inherits `PYTHONPATH` but not pytest's in-process `pythonpath`. Put the fixture dir on
     `PYTHONPATH` so a fixture server module (e.g. `tool_response_image_v1`)
-    resolves there too — an installed example package (e.g. `glossary_v1`) already would."""
+    resolves there too — an installed example package (e.g. `glossary`) already would."""
     fixtures = str(Path(__file__).parent / "fixtures")
     existing = os.environ.get("PYTHONPATH", "")
     if fixtures not in existing.split(os.pathsep):
@@ -121,7 +121,7 @@ def _eval_config(
     taskset: str,
     *,
     output_dir: Path,
-    harness: str | None = "null",
+    harness: str | HarnessConfig | None = "null",
     n: int = 1,
     num_tasks: int = 1,
     max_tokens: int = 2048,
@@ -132,6 +132,7 @@ def _eval_config(
     env: dict | None = None,
     pool: dict | None = None,
     reasoning_effort: str | None = None,
+    server: bool = False,
 ) -> EvalConfig:
     """Build the smallest `EvalConfig` that still exercises the path, shared by the in-process
     (`run_v1`) and env-server (`run_v1_server`) fixtures. `taskset_overrides` merges onto the
@@ -145,11 +146,17 @@ def _eval_config(
     env_cfg = dict(env or {})
     _configure_prime_runtimes(taskset_cfg)
     if harness:
-        env_cfg.setdefault("agent", {})["harness"] = {"id": harness}
+        env_cfg.setdefault("agent", {})["harness"] = (
+            harness_config_type(harness)(id=harness)
+            if isinstance(harness, str)
+            else harness
+        )
     if runtime:
         runtime_cfg = dict(runtime)
         _configure_prime_runtimes(runtime_cfg)
         env_cfg.setdefault("agent", {})["runtime"] = runtime_cfg
+    retries = {"max_retries": 2, "include": ["ProviderError", "HarnessError"]}
+    env_cfg.setdefault("retries", retries)
     # Per-run caps live on the seats: resolve the env's declared roles and cap
     # each one (a test's own seat dict wins over the shared defaults).
     config_cls = vf.env_config_type(taskset, env_cfg.get("id", ""))
@@ -163,11 +170,8 @@ def _eval_config(
         seat_cfg.setdefault("max_turns", max_turns)
         seat_cfg.setdefault("max_output_tokens", max_tokens)
         seat_cfg.setdefault("timeout", {"rollout": rollout_timeout, "scoring": 60})
-        # Flake resilience: retries are per-agent now (flat RetryConfig).
-        seat_cfg.setdefault(
-            "retries",
-            {"max_retries": 2, "include": ["ProviderError", "HarnessError"]},
-        )
+        # Agent runs retry locally; interactions retry with their whole episode.
+        seat_cfg.setdefault("retries", retries)
     return EvalConfig(
         env={
             "taskset": taskset_cfg,
@@ -179,21 +183,22 @@ def _eval_config(
             "max_tokens": max_tokens,
             "reasoning_effort": reasoning_effort,
         },
-        rich=False,
-        output_dir=output_dir,
-        **({"serve": {"pool": pool}} if pool else {}),
+        rich=None,
+        serve=({"pool": pool} if pool else {}) if server else None,
+        output_dir=output_dir.parent,
+        run={"dir": output_dir.name},
         model=CI_MODEL,
     )
 
 
 @pytest.fixture
 def run_v1():
-    """Run a v1 taskset end-to-end in-process (`run_eval`, the `--rich` CLI path) and return
+    """Run a v1 taskset end-to-end in-process (`run_eval` with `--no-serve`) and return
     its traces."""
 
     async def _run(taskset: str, **kwargs) -> list[Trace]:
         config = _eval_config(taskset, **kwargs)
-        records = await run_eval(load_environment(config.env), config)
+        records = await run_eval(config)
         # The runner answers durability envelopes; the tests assert on traces.
         return [t for r in records for t in r.traces]
 
@@ -202,17 +207,16 @@ def run_v1():
 
 @pytest.fixture
 def run_v1_server():
-    """Run a v1 taskset through the env-server worker pool (`run_eval_server`) — the path a
-    `--server` CLI run and prime-rl training both take. Spawns the broker + a worker, so it's
-    the only fixture that exercises serving resources (shared tool servers, interception pool)
-    being stood up by the *server* rather than the in-process runner. Pinned to a single static
-    worker for determinism."""
-    from verifiers.v1.cli.eval.runner import run_eval_server
+    """Run a v1 taskset through the env-server worker pool (`run_eval`'s default path) —
+    the path a CLI run and prime-rl training both take. Spawns the broker + a worker, so
+    it's the only fixture that exercises serving resources (shared tool servers,
+    interception pool) being stood up by the *server* rather than the in-process runner.
+    Pinned to a single static worker for determinism."""
 
     async def _run(taskset: str, **kwargs) -> list[Trace]:
         kwargs.setdefault("pool", {"type": "static", "num_workers": 1})
-        config = _eval_config(taskset, **kwargs)
-        records = await run_eval_server(config)
+        config = _eval_config(taskset, server=True, **kwargs)
+        records = await run_eval(config)
         return [t for r in records for t in r.traces]
 
     return _run
@@ -231,31 +235,3 @@ async def live_ctx():
         client=EvalClientConfig(),
         sampling=SamplingConfig(max_tokens=2048),
     )
-
-
-@pytest.fixture
-def run_v0():
-    """Run a legacy v0 env through the v1 bridge (the eval CLI's `--legacy.id` path)."""
-    from verifiers.v1.legacy import run_legacy_eval
-
-    async def _run(
-        env_id: str,
-        *,
-        output_dir: Path,
-        n: int = 1,
-        max_tokens: int = 2048,
-        args: dict | None = None,
-    ) -> list[Trace]:
-        config = EvalConfig(
-            legacy={"id": env_id, "args": args or {}},
-            model=CI_MODEL,
-            num_tasks=1,
-            num_rollouts=n,
-            sampling={"max_tokens": max_tokens},
-            rich=False,
-            output_dir=output_dir,
-        )
-        records = await run_legacy_eval(config)
-        return [t for r in records for t in r.traces]
-
-    return _run

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/fixtures/counter_tool_v1.py

@@ -44,9 +44,9 @@ class CounterTaskset(vf.Taskset[CounterTask, CounterConfig]):
                 vf.TaskData(
                     idx=0,
                     prompt=(
-                        f"Call the `counter_bump` tool {TARGET} times, one call per turn — wait "
-                        "for each result before the next. After the last result, reply with "
-                        "<answer>done</answer>."
+                        f"Call the `bump` tool from the `counter` MCP server {TARGET} times, "
+                        "one call per turn — wait for each result before the next. After the "
+                        "last result, reply with <answer>done</answer>."
                     ),
                 ),
                 self.config.task,

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/fixtures/echo_acp_resume_v1.py

@@ -59,8 +59,9 @@ class ACPResumeEnv(vf.SingleAgentEnv):
             if not first.terminated:
                 segments.append(
                     await interaction.turn(
-                        "Call `resume_recall` with the codeword from my previous "
-                        "message, then reply with exactly the tool result."
+                        "Call the `recall` tool from the `resume` MCP server with the "
+                        "codeword from my previous message, then reply with exactly the "
+                        "tool result."
                     )
                 )
             interaction.trace.info["acp_segments"] = [

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/fixtures/echo_tool_v1.py

@@ -18,7 +18,7 @@ ECHO_TOKEN = "ok-7f3"  # the tool stamps this; only a real tool call can surface
 
 
 class EchoToolset(vf.Toolset[vf.ToolsetConfig]):
-    TOOL_PREFIX = "echo"  # the model sees `echo_back` (matches the prompt)
+    TOOL_PREFIX = "echo"
 
     @vf.tool
     def back(self, message: str) -> str:
@@ -53,7 +53,8 @@ class EchoToolTaskset(vf.Taskset[EchoToolTask, EchoToolConfig]):
                 vf.TaskData(
                     idx=0,
                     prompt=(
-                        f'Call the `echo_back` tool with the message "{PHRASE}", then reply '
+                        f"Call the `back` tool from the `echo` MCP server with the message "
+                        f'"{PHRASE}", then reply '
                         "with exactly what it returns inside <answer></answer> tags."
                     ),
                 ),

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/fixtures/echo_v1.py

@@ -30,6 +30,10 @@ class EchoData(vf.TaskData):
 
 
 class EchoTask(vf.Task[EchoData]):
+    @property
+    def key(self) -> str:
+        return f"echo:{self.data.answer}"
+
     @vf.stop
     async def single_turn(self, trace: vf.Trace) -> bool:
         return trace.num_turns >= 1

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/fixtures/tool_response_image_v1.py

@@ -13,7 +13,7 @@ SYSTEM = "Call the requested tool before answering."
 
 
 class VisionToolset(vf.Toolset[vf.ToolsetConfig]):
-    TOOL_PREFIX = "vision"  # the model sees `vision_snapshot`
+    TOOL_PREFIX = "vision"
 
     @vf.tool
     def snapshot(self) -> list:
@@ -60,8 +60,8 @@ class ToolResponseImageTaskset(
                 vf.TaskData(
                     idx=0,
                     prompt=(
-                        "Call the `vision_snapshot` tool exactly once. After it returns, "
-                        "reply with exactly `done`."
+                        "Call the `snapshot` tool from the `vision` MCP server exactly once. "
+                        "After it returns, reply with exactly `done`."
                     ),
                     system_prompt=SYSTEM,
                 ),

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/test_color_codeword_tasks.py

@@ -1,4 +1,4 @@
-from color_codeword_v1 import taskset
+from color_codeword import taskset
 
 
 def test_color_images_are_rendered_once(monkeypatch) -> None:

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/test_configs.py

@@ -23,5 +23,4 @@ CONFIGS = sorted(
 @pytest.mark.parametrize("path", CONFIGS, ids=lambda p: p.name)
 def test_eval_config_parses(path: Path) -> None:
     config = EvalConfig.model_validate(tomllib.load(path.open("rb")))
-    # resolved to a v1 taskset or a v0 env id
-    assert config.env.taskset.id or config.id
+    assert config.env.taskset.id

{verifiers-0.2.2.dev112 → verifiers-0.3.1}/tests/v1/test_e2e.py

@@ -23,7 +23,12 @@ CHAT_PLACEMENTS = [
     pair("null", "subprocess", "null-harness-in-subprocess"),
     pair("bash", "docker", "bash-harness-in-docker"),
     pair("rlm", "docker", "rlm-harness-in-docker"),
-    pair("kimi-code", "docker", "kimi-code-harness-in-docker"),
+    pytest.param(
+        {"id": "kimi-code", "transport": "responses"},
+        "docker",
+        marks=[mark.kimi_code, mark.docker],
+        id="kimi-code-responses-harness-in-docker",
+    ),
     pair("bash", "prime", "bash-harness-in-prime"),
     pair("bash", "modal", "bash-harness-in-modal"),
 ]
@@ -34,7 +39,12 @@ CHAT_PLACEMENTS = [
 AGENTIC_PLACEMENTS = [
     pair("bash", "subprocess", "bash-harness-in-subprocess"),
     pair("rlm", "docker", "rlm-harness-in-docker"),
-    pair("kimi-code", "docker", "kimi-code-harness-in-docker"),
+    pytest.param(
+        {"id": "kimi-code", "transport": "responses"},
+        "docker",
+        marks=[mark.kimi_code, mark.docker],
+        id="kimi-code-responses-harness-in-docker",
+    ),
     pair("codex", "docker", "codex-harness-in-docker"),
     pair("claude-code", "docker", "claude-code-harness-in-docker"),
     pair("hermes-agent", "docker", "hermes-agent-harness-in-docker"),
@@ -59,8 +69,18 @@ ACP_RESUME_PLACEMENTS = [
     pair("claude-code", "docker", "claude-code-acp-in-docker"),
     pair("hermes-agent", "docker", "hermes-agent-acp-in-docker"),
     pair("rlm", "docker", "rlm-acp-in-docker"),
-    pair("kimi-code", "docker", "kimi-code-acp-in-docker"),
-    pair("pi", "docker", "pi-acp-in-docker"),
+    pytest.param(
+        {"id": "kimi-code", "transport": "responses"},
+        "docker",
+        marks=[mark.kimi_code, mark.docker],
+        id="kimi-code-responses-acp-in-docker",
+    ),
+    pytest.param(
+        {"id": "pi", "transport": "responses"},
+        "docker",
+        marks=[mark.pi, mark.docker],
+        id="pi-responses-acp-in-docker",
+    ),
     pair("pool", "docker", "pool-acp-in-docker"),
     pair("openclaw", "docker", "openclaw-acp-in-docker"),
     pair("pool", "prime", "pool-acp-in-prime"),
@@ -116,6 +136,8 @@ async def test_single_turn(run_v1, harness, harness_runtime, tmp_path):
     assert trace.num_turns == 1
     assert trace.stop_condition == "agent_completed"
     assert trace.reward == 1.0
+    assert trace.task.key == f"echo:{trace.task.data.answer}"
+    assert trace.task.hash is not None
     # The seat's resolved identity rides the trace (policy metadata for trainers).
     assert trace.agent is not None
     assert trace.agent.config.sampling.max_tokens == 2048
@@ -235,11 +257,14 @@ async def test_acp_resume_with_tool(run_v1, harness, harness_runtime, tmp_path):
     assert len(segments) == 2
     assert segments[0]["terminated"] is False
     assert segments[1]["terminated"] is False
+    # Kimi Code is broken upstream: its Responses adapter drops message `phase` on replay.
+    if harness.id != "kimi-code":
+        assert trace.num_branches == 1
     # Native MCP tools need not appear in the intercepted model request that
     # populates trace.tools; the ACP transcript is the source of truth for use.
     assert "tool" in segments[1]["roles"]
     assert segments[1]["tool_outputs"]
-    if harness == "rlm":
+    if harness.id == "rlm":
         assert "turns_since_last_compaction" in trace.metrics
 
 
@@ -263,10 +288,10 @@ async def test_tool(run_v1, harness_runtime, tool_runtime, tmp_path):
     assert trace.ok
     assert trace.num_turns >= 2  # tool call + answer
     assert trace.reward == 1.0
-    # The interception server captured the advertised tools onto the trace (for tool-use SFT):
-    # the null harness offered the task's MCP tool as `echo_back`, schema included.
+    # The interception server captured the harness's advertised name and schema. Harnesses
+    # may qualify the same raw MCP tool differently, so the test checks its stable suffix.
     assert trace.tools
-    (echo_tool,) = [t for t in trace.tools if t.name == "echo_back"]
+    (echo_tool,) = [tool for tool in trace.tools if tool.name.endswith("back")]
     assert "message" in echo_tool.parameters.get("properties", {})
 
 
@@ -301,7 +326,7 @@ async def test_shared_tool_isolation(
 ):
     """A shared writable tool isolates state across concurrent rollouts and runtimes."""
     traces = await run_v1_server(
-        "scratchpad-v1",
+        "scratchpad",
         harness="null",
         runtime={"type": harness_runtime},
         output_dir=tmp_path,
@@ -574,9 +599,9 @@ async def test_env_id_user_sim_with_tools(run_v1, tmp_path):
     assert assistant.task.data.prompt is None  # the scenario stayed off the wire
     assert user.num_turns >= 1  # the modeled user actually drove the exchange
     assert assistant.rewards["echoed"].score == 1.0  # the tool ran, mid-conversation
-    # The tool was advertised to the masked chat exactly as to any run.
+    # The tool was advertised to the masked chat, regardless of harness qualification.
     assert assistant.tools
-    assert any(tool.name == "echo_back" for tool in assistant.tools)
+    assert any(tool.name.endswith("back") for tool in assistant.tools)
 
 
 @pytest.mark.e2e
@@ -584,7 +609,7 @@ async def test_kuhn_poker_self_play(run_v1, tmp_path):
     """The turn-coupled proof env: one Kuhn poker hand, both seats live interactions
     of the run's own model (self-play), refereed host-side, paid out zero-sum."""
     traces = await run_v1(
-        "kuhn-poker-v1",
+        "kuhn-poker",
         harness=None,  # both seats pin the null harness themselves
         output_dir=tmp_path,
         max_turns=8,
@@ -637,16 +662,15 @@ async def test_replay_round_trip(run_v1, tmp_path):
     typed rebuild fails and the trace-only `@reward` silently stops running (the
     wire-narrowing regression). Trace-only rewards are deterministic given the transcript,
     so all three generations must agree."""
-    import tomllib
     from pathlib import Path
 
-    from verifiers.v1.cli.output import CONFIG_FILE
+    from verifiers.v1.cli.output import saved_config_path
     from verifiers.v1.cli.replay import run_replay
     from verifiers.v1.configs.cli.replay import ReplayConfig
 
     run_dir = tmp_path / "run"
     (source,) = await run_v1(
-        "reverse-text-v1",
+        "reverse-text",
         harness="null",
         runtime={"type": "subprocess"},
         output_dir=run_dir,
@@ -658,7 +682,9 @@ async def test_replay_round_trip(run_v1, tmp_path):
     async def replay(source_dir: Path, out: Path):
         # The CLI's layering, minus the argv plumbing: the saved run's config is the base
         # (`ReplayConfig` ignores its eval-only keys), the source's output_dir is dropped.
-        data = tomllib.loads((source_dir / CONFIG_FILE).read_text())
+        import json
+
+        data = json.loads(saved_config_path(source_dir).read_text())
         data.pop("output_dir", None)
         config = ReplayConfig(**{**data, "rich": False})
         (trace,) = await run_replay(config, source_dir, out)