verifiers 0.3.2.dev46__tar.gz → 0.3.2.dev47__tar.gz

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev46
+Version: 0.3.2.dev47
 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

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/configs/harness.py

@@ -4,12 +4,16 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
+from typing import Annotated
 
 from pydantic import ConfigDict, Field, FiniteFloat
 from pydantic_config import BaseConfig
 
 from verifiers.v1.types import ID
 
+PinnedVersion = Annotated[str, Field(pattern=r"^[A-Za-z0-9._+-]+$")]
+"""A release/tag a harness pins its program install to."""
+
 
 class HarnessConfig(BaseConfig):
     id: ID = "bash"

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/claude_code/harness.py

@@ -1,13 +1,10 @@
 """Run Claude Code through the Claude Agent SDK ACP adapter."""
 
-import shlex
-
-from pydantic import Field
-
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
+from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -32,7 +29,7 @@ touch {ready}
 
 
 class ClaudeCodeHarnessConfig(HarnessConfig):
-    version: str = Field(default="2.1.232", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "2.1.232"
     """Claude Code release to install, pinned for reproducibility."""
 
 
@@ -51,25 +48,18 @@ class ClaudeCodeHarness(ACPHarness[ClaudeCodeHarnessConfig]):
         acp_bin = ACP_BIN.format(**versions)
         ready = f"{directory}/.ready"
         script = ACP_INSTALL.replace("{packages}", packages).replace("{ready}", ready)
-        ensure = shlex.quote(
-            f"[ -f {ready} ] && [ -x {claude_bin} ] && [ -x {acp_bin} ] || ({script})"
-        )
-        acp_guarded = (
-            f"mkdir -p {directory} && "
-            f'"$(command -v flock || command -v lockf)" {directory}/install.lock '
-            f"sh -c {ensure}"
-        )
-        acp_result = await runtime.run(
-            ["sh", "-c", acp_guarded],
-            {
+        await ensure_installed(
+            runtime,
+            directory=directory,
+            ready=f"[ -f {ready} ] && [ -x {claude_bin} ] && [ -x {acp_bin} ]",
+            install=script,
+            env={
                 **self.config.resolved_env,
                 "VF_CLAUDE_CODE_VERSION": self.config.version,
                 "VF_CLAUDE_ACP_VERSION": ACP_VERSION,
             },
+            label="Claude Agent ACP",
         )
-        if acp_result.exit_code != 0:
-            detail = (acp_result.stderr or acp_result.stdout).strip()[-500:]
-            raise RuntimeError(f"Claude Agent ACP install failed: {detail}")
         await super().setup(runtime)
 
     async def prepare_acp(
@@ -113,11 +103,7 @@ class ClaudeCodeHarness(ACPHarness[ClaudeCodeHarnessConfig]):
         )
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
-        result = await runtime.run(["rm", "-rf", self.config_dir(trace)], {})
-        if result.exit_code != 0:
-            raise RuntimeError(
-                f"failed to clean up Claude config: {result.stderr.strip()[-500:]}"
-            )
+        await remove_dir(runtime, self.config_dir(trace), "Claude config")
 
     @staticmethod
     def config_dir(trace: Trace) -> str:

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/codex/harness.py

@@ -4,15 +4,13 @@ import hashlib
 import json
 import logging
 import re
-import shlex
 from collections import Counter
 
-from pydantic import Field
-
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
+from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -38,7 +36,7 @@ touch {ready}
 
 
 class CodexHarnessConfig(HarnessConfig):
-    version: str = Field(default="0.147.0", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "0.147.0"
     """Codex release to install, pinned for reproducibility."""
     multi_agent: bool = False
     """Enable Codex's native multi-agent v2 tools."""
@@ -64,24 +62,18 @@ class CodexHarness(ACPHarness[CodexHarnessConfig]):
         acp_bin = ACP_BIN.format(**versions)
         ready = f"{directory}/.ready"
         script = INSTALL.replace("{packages}", packages).replace("{ready}", ready)
-        ensure = shlex.quote(
-            f"[ -f {ready} ] && [ -x {codex_bin} ] && [ -x {acp_bin} ] || ({script})"
-        )
-        guarded = (
-            f"mkdir -p {directory} && "
-            f'"$(command -v flock || command -v lockf)" {directory}/install.lock '
-            f"sh -c {ensure}"
-        )
-        install = await runtime.run(
-            ["sh", "-c", guarded],
-            {
+        await ensure_installed(
+            runtime,
+            directory=directory,
+            ready=f"[ -f {ready} ] && [ -x {codex_bin} ] && [ -x {acp_bin} ]",
+            install=script,
+            env={
                 **self.config.resolved_env,
                 "VF_CODEX_VERSION": self.config.version,
                 "VF_CODEX_ACP_VERSION": ACP_VERSION,
             },
+            label="codex",
         )
-        if install.exit_code != 0:
-            raise RuntimeError(f"codex install failed: {install.stderr.strip()[-500:]}")
         await super().setup(runtime)
 
     async def prepare_acp(
@@ -112,11 +104,7 @@ class CodexHarness(ACPHarness[CodexHarnessConfig]):
         )
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
-        result = await runtime.run(["rm", "-rf", self.trace_home(trace)], {})
-        if result.exit_code != 0:
-            raise RuntimeError(
-                f"failed to clean up Codex home: {result.stderr.strip()[-500:]}"
-            )
+        await remove_dir(runtime, self.trace_home(trace), "Codex home")
 
     @staticmethod
     def trace_home(trace: Trace) -> str:

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/hermes_agent/harness.py

@@ -3,11 +3,10 @@
 import json
 from pathlib import Path
 
-from pydantic import Field
-
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
+from verifiers.v1.harnesses.utils.install import remove_dir
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -16,7 +15,7 @@ PROGRAM_SOURCE = (Path(__file__).resolve().parent / "program.py").read_text()
 
 
 class HermesAgentHarnessConfig(HarnessConfig):
-    version: str = Field(default="0.19.0", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "0.19.0"
     """Hermes Agent release to install, pinned for reproducibility."""
     use_bundled_skill: bool = False
     """Enable Hermes Agent's bundled skill catalog in addition to uploaded skills."""
@@ -96,8 +95,4 @@ class HermesAgentHarness(ACPHarness[HermesAgentHarnessConfig]):
         )
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
-        result = await runtime.run(["rm", "-rf", f"/tmp/vf-hermes/{trace.id}"], {})
-        if result.exit_code:
-            raise RuntimeError(
-                f"failed to clean up Hermes home: {result.stderr.strip()[-500:]}"
-            )
+        await remove_dir(runtime, f"/tmp/vf-hermes/{trace.id}", "Hermes home")

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/kimi_code/harness.py

@@ -1,15 +1,14 @@
 """Run Kimi Code's native ACP server against interception."""
 
 import logging
-import shlex
 from typing import Literal
 
 import tomli_w
-from pydantic import Field
 
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
+from verifiers.v1.harnesses.utils.install import ensure_installed
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -39,7 +38,7 @@ env \
 
 
 class KimiCodeHarnessConfig(HarnessConfig):
-    version: str = Field(default="0.36.0", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "0.36.0"
     """Kimi Code release to install, pinned for reproducibility."""
     transport: Literal["chat_completions", "responses", "anthropic_messages"] = (
         "chat_completions"
@@ -58,16 +57,13 @@ class KimiCodeHarness(ACPHarness[KimiCodeHarnessConfig]):
             "kimi-code: ensuring Kimi Code %s is installed", self.config.version
         )
         script = INSTALL.replace("{version}", self.config.version)
-        guarded = (
-            "mkdir -p /tmp/vf-kimi-code && "
-            '"$(command -v flock || command -v lockf)" '
-            f"/tmp/vf-kimi-code/install.lock sh -c {shlex.quote(script)}"
+        await ensure_installed(
+            runtime,
+            directory="/tmp/vf-kimi-code",
+            install=script,
+            env={},
+            label="Kimi Code",
         )
-        install = await runtime.run(["sh", "-c", guarded], {})
-        if install.exit_code != 0:
-            raise RuntimeError(
-                f"Kimi Code install failed: {install.stderr.strip()[-500:]}"
-            )
         await super().setup(runtime)
 
     async def prepare_acp(

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/mini_swe_agent/harness.py

@@ -1,9 +1,7 @@
 from pathlib import Path
 
-from pydantic import Field
-
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harness import Harness
 from verifiers.v1.runtimes import ProgramResult, Runtime
 from verifiers.v1.task import TaskData
@@ -13,7 +11,7 @@ PROGRAM_SOURCE = (Path(__file__).resolve().parent / "program.py").read_text()
 
 
 class MiniSWEAgentHarnessConfig(HarnessConfig):
-    version: str = Field(default="2.4.6", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "2.4.6"
     """mini-swe-agent release to install, pinned for reproducibility."""
 
 

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/node.py

@@ -1,5 +1,4 @@
-import shlex
-
+from verifiers.v1.harnesses.utils.install import ensure_installed
 from verifiers.v1.runtimes import Runtime
 
 NODE_DIR = "/var/tmp/vf-node"
@@ -39,16 +38,12 @@ node_ok || { echo "ACP adapters require Node.js 22.19 or newer" >&2; exit 1; }
 
 async def ensure_node(runtime: Runtime) -> None:
     """Install the shared Node runtime used by ACP adapter harnesses."""
-    lock = f"{NODE_DIR}.install.lock"
-    guarded = (
-        f'until ln -s "$$" {lock} 2>/dev/null; do '
-        f"owner=$(readlink {lock}); "
-        f'if ! kill -0 "$owner" 2>/dev/null; then '
-        f'[ "$(readlink {lock})" != "$owner" ] || rm -f {lock}; fi; '
-        f"sleep 0.1; done; "
-        f'trap \'[ "$(readlink {lock})" != "$$" ] || rm -f {lock}\' EXIT; '
-        f"sh -c {shlex.quote(INSTALL)}"
+    # The install replaces NODE_DIR wholesale, so the lock lives beside it.
+    await ensure_installed(
+        runtime,
+        directory=NODE_DIR,
+        lock=f"{NODE_DIR}.install.lock",
+        install=INSTALL,
+        env={"VF_NODE_VERSION": NODE_VERSION},
+        label="Node.js",
     )
-    result = await runtime.run(["sh", "-c", guarded], {"VF_NODE_VERSION": NODE_VERSION})
-    if result.exit_code != 0:
-        raise RuntimeError(f"Node.js install failed: {result.stderr.strip()[-500:]}")

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/openclaw/harness.py

@@ -4,13 +4,11 @@ import asyncio
 import json
 import logging
 import secrets
-import shlex
-
-from pydantic import Field
 
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
+from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -120,7 +118,7 @@ wait "$acp_pid"
 
 
 class OpenClawHarnessConfig(HarnessConfig):
-    version: str = Field(default="2026.8.1", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "2026.8.1"
     """OpenClaw release to install, pinned for reproducibility."""
     use_bundled_skill: bool = True
     """Enable OpenClaw's bundled skill catalog in addition to uploaded harness skills."""
@@ -143,39 +141,29 @@ class OpenClawHarness(ACPHarness[OpenClawHarnessConfig]):
                 ready_path = f"{self._staged_skills_dir}/.ready"
                 ready = await runtime.run(["test", "-f", ready_path], {})
                 if ready.exit_code != 0:
-                    cleared = await runtime.run(
-                        ["rm", "-rf", self._staged_skills_dir], {}
+                    await remove_dir(
+                        runtime, self._staged_skills_dir, "OpenClaw skills"
                     )
-                    if cleared.exit_code != 0:
-                        raise RuntimeError(
-                            "failed to clear OpenClaw skills: "
-                            f"{cleared.stderr.strip()[-500:]}"
-                        )
                     await self.install_skills(runtime, self._staged_skills_dir)
                     await runtime.write(ready_path, b"")
         directory = OPENCLAW_DIR.format(version=self.config.version)
         binary = OPENCLAW_BIN.format(version=self.config.version)
+        logger.info("openclaw: ensuring OpenClaw %s is installed", self.config.version)
         # Borrowed runtimes can share this cache, so one filesystem lock owns both
         # installation and the transcript adjustment.
-        guarded = (
-            f"mkdir -p {shlex.quote(directory)} && "
-            f'"$(command -v flock || command -v lockf)" '
-            f"{shlex.quote(f'{directory}/install.lock')} "
-            f"bash -o pipefail -c {shlex.quote(SETUP)}"
-        )
-        logger.info("openclaw: ensuring OpenClaw %s is installed", self.config.version)
-        result = await runtime.run(
-            ["sh", "-c", guarded],
-            {
+        await ensure_installed(
+            runtime,
+            directory=directory,
+            install=SETUP,
+            env={
                 **self.config.resolved_env,
                 "VF_OPENCLAW_BIN": binary,
                 "VF_OPENCLAW_DIR": directory,
                 "VF_OPENCLAW_VERSION": self.config.version,
             },
+            label="OpenClaw",
+            shell=("bash", "-o", "pipefail", "-c"),
         )
-        if result.exit_code != 0:
-            detail = (result.stderr or result.stdout).strip()[-500:]
-            raise RuntimeError(f"OpenClaw setup failed: {detail}")
         await super().setup(runtime)
 
     async def prepare_acp(
@@ -277,8 +265,4 @@ class OpenClawHarness(ACPHarness[OpenClawHarnessConfig]):
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
         state_dir = f".vf-openclaw/{trace.id}"
-        result = await runtime.run(["rm", "-rf", state_dir], {})
-        if result.exit_code != 0:
-            raise RuntimeError(
-                f"failed to clean up OpenClaw state: {result.stderr.strip()[-500:]}"
-            )
+        await remove_dir(runtime, state_dir, "OpenClaw state")

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/pi/harness.py

@@ -5,12 +5,11 @@ import logging
 import shlex
 from typing import Literal
 
-from pydantic import Field
-
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
+from verifiers.v1.harnesses.utils.install import ensure_installed
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -46,7 +45,7 @@ fi
 
 
 class PiHarnessConfig(HarnessConfig):
-    version: str = Field(default="0.84.1", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "0.84.1"
     """Pi release to install, pinned for reproducibility."""
     transport: Literal["chat_completions", "responses", "anthropic_messages"] = (
         "chat_completions"
@@ -69,27 +68,17 @@ class PiHarness(ACPHarness[PiHarnessConfig]):
             self.config.version,
             ACP_VERSION,
         )
-        lock = f"{PI_DIR}/install.lock"
-        guarded = (
-            f"mkdir -p {PI_DIR} && "
-            f'until ln -s "$$" {lock} 2>/dev/null; do '
-            f"owner=$(readlink {lock}); "
-            f'if ! kill -0 "$owner" 2>/dev/null; then '
-            f'[ "$(readlink {lock})" != "$owner" ] || rm -f {lock}; fi; '
-            f"sleep 0.1; done; "
-            f'trap \'[ "$(readlink {lock})" != "$$" ] || rm -f {lock}\' EXIT; '
-            f"sh -c {shlex.quote(INSTALL)}"
-        )
-        install = await runtime.run(
-            ["sh", "-c", guarded],
-            {
+        await ensure_installed(
+            runtime,
+            directory=PI_DIR,
+            install=INSTALL,
+            env={
                 "VF_PI_VERSION": self.config.version,
                 "VF_PI_MCP_VERSION": MCP_VERSION,
                 "VF_PI_ACP_VERSION": ACP_VERSION,
             },
+            label="pi",
         )
-        if install.exit_code != 0:
-            raise RuntimeError(f"pi install failed: {install.stderr.strip()[-500:]}")
         await super().setup(runtime)
 
     async def prepare_acp(

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/pool/harness.py

@@ -3,11 +3,10 @@
 import json
 import shlex
 
-from pydantic import Field
-
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
+from verifiers.v1.harnesses.utils.install import ensure_installed
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -28,7 +27,7 @@ chmod +x "{dir}/pool"
 
 
 class PoolHarnessConfig(HarnessConfig):
-    version: str = Field(default="1.0.15", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "1.0.15"
     """Pool release to install, pinned for reproducibility."""
 
 
@@ -44,17 +43,15 @@ class PoolHarness(ACPHarness[PoolHarnessConfig]):
         script = INSTALL.replace("{version}", self.config.version).replace(
             "{dir}", directory
         )
-        ensure = shlex.quote(f"[ -x {binary} ] || ({script})")
-        # Cache the pinned binary across local rollouts; Linux has flock, macOS has lockf.
-        guarded = (
-            f"mkdir -p {directory} && "
-            f'"$(command -v flock || command -v lockf)" {directory}/install.lock '
-            f"bash -o pipefail -c {ensure}"
+        await ensure_installed(
+            runtime,
+            directory=directory,
+            ready=f"[ -x {binary} ]",
+            install=script,
+            env=self.config.resolved_env,
+            label="Pool",
+            shell=("bash", "-o", "pipefail", "-c"),
         )
-        result = await runtime.run(["sh", "-c", guarded], self.config.resolved_env)
-        if result.exit_code != 0:
-            detail = (result.stderr or result.stdout).strip()[-500:]
-            raise RuntimeError(f"Pool install failed: {detail}")
         await super().setup(runtime)
 
     async def prepare_acp(

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/prime_agent/harness.py

@@ -10,6 +10,7 @@ from verifiers.v1.acp import ACPConfig, ACPHarness, ACPTurn
 from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig
 from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
+from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -157,26 +158,19 @@ class PrimeAgentHarness(ACPHarness[PrimeAgentHarnessConfig]):
         await self.install_skills(runtime, SKILLS_DIR)
         await ensure_node(runtime)
         logger.info("prime-agent: ensuring commit %s is installed", self.config.commit)
-        lock = f"{PRIME_AGENT_DIR}/install.lock"
-        guarded = (
-            f"mkdir -p {PRIME_AGENT_DIR} && "
-            f'"$(command -v flock || command -v lockf)" {lock} '
-            f"sh -c {shlex.quote(INSTALL)}"
-        )
-        result = await runtime.run(
-            ["sh", "-c", guarded],
-            {
+        await ensure_installed(
+            runtime,
+            directory=PRIME_AGENT_DIR,
+            install=INSTALL,
+            env={
                 **self.config.resolved_env,
                 "VF_PRIME_AGENT_DIR": PRIME_AGENT_DIR,
                 "VF_PRIME_AGENT_GITHUB_RELEASE_URL": GITHUB_RELEASE_URL,
                 "PRIME_AGENT_COMMIT": self.config.commit,
                 "PRIME_AGENT_RELEASE_VERSION": PRIME_AGENT_VERSION,
             },
+            label="prime-agent",
         )
-        if result.exit_code != 0:
-            raise RuntimeError(
-                f"prime-agent install failed: {result.stderr.strip()[-500:]}"
-            )
         await super().setup(runtime)
 
     async def prepare_acp(
@@ -285,11 +279,7 @@ class PrimeAgentHarness(ACPHarness[PrimeAgentHarnessConfig]):
 
     async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
         root = self._root(trace)
-        removed = await runtime.run(["rm", "-rf", root], {})
-        if removed.exit_code != 0:
-            raise RuntimeError(
-                f"prime-agent state cleanup failed: {removed.stderr.strip()[-500:]}"
-            )
+        await remove_dir(runtime, root, "prime-agent state")
 
     def _bin(self) -> str:
         return f"{PRIME_AGENT_DIR}/{self.config.commit}/bin/prime-agent"

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/rlm/harness.py

@@ -18,6 +18,7 @@ from pydantic_config import BaseConfig
 from verifiers.v1.acp import ACPConfig, ACPHarness, ACPTurn, JsonObject
 from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.harnesses.utils.install import ensure_installed
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
@@ -130,16 +131,17 @@ class RLMHarness(ACPHarness[RLMHarnessConfig]):
             f"touch {ready})"
         )
         logger.info("rlm: ensuring rlm is installed (version=%s)", self.config.version)
-        ensure = shlex.quote(f"[ -f {ready} ] && [ -x {binary} ] || ({install})")
-        guarded = (
-            f"mkdir -p {directory} && flock {directory}/install.lock sh -c {ensure}"
-        )
         env = self.config.resolved_env.copy()
         extra_uv_args = env.get("RLM_EXTRA_UV_ARGS", "")
         env["RLM_EXTRA_UV_ARGS"] = f"{extra_uv_args} --with mcp~=1.28".strip()
-        result = await runtime.run(["sh", "-c", guarded], env)
-        if result.exit_code != 0:
-            raise RuntimeError(f"rlm install failed: {result.stderr.strip()[-500:]}")
+        await ensure_installed(
+            runtime,
+            directory=directory,
+            ready=f"[ -f {ready} ] && [ -x {binary} ]",
+            install=install,
+            env=env,
+            label="rlm",
+        )
         await super().setup(runtime)
 
     def _runtime_metadata(

{verifiers-0.3.2.dev46 → verifiers-0.3.2.dev47}/verifiers/v1/harnesses/terminus_2/harness.py

@@ -1,10 +1,8 @@
 import logging
 from pathlib import Path
 
-from pydantic import Field
-
 from verifiers.v1.clients import ModelContext
-from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harness import Harness
 from verifiers.v1.runtimes import ProgramResult, Runtime
 from verifiers.v1.task import TaskData
@@ -15,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 
 class Terminus2HarnessConfig(HarnessConfig):
-    version: str = Field(default="0.21.0", pattern=r"^[A-Za-z0-9._+-]+$")
+    version: PinnedVersion = "0.21.0"
     """Harbor release to install, pinned for reproducibility."""