verifiers 0.3.2.dev46__py3-none-any.whl → 0.3.2.dev49__py3-none-any.whl

verifiers/cli/commands/init.py

@@ -0,0 +1,6 @@
+"""Environment initialization command module for external hosts."""
+
+from verifiers.v1.cli.init import main
+
+if __name__ == "__main__":
+    main()

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/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/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/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/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/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/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/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/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/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/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/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/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."""
 
 

verifiers/v1/harnesses/utils/install.py

@@ -0,0 +1,65 @@
+"""Host-side helpers for installing a harness's program into a runtime."""
+
+import shlex
+
+from verifiers.v1.runtimes import Runtime
+
+
+async def ensure_installed(
+    runtime: Runtime,
+    *,
+    directory: str,
+    install: str,
+    env: dict[str, str],
+    label: str,
+    ready: str | None = None,
+    lock: str | None = None,
+    shell: tuple[str, ...] = ("sh", "-c"),
+) -> None:
+    """Run `install` in `runtime` under a lock, so concurrent rollouts sharing the runtime
+    install once and the rest wait. `ready` is a shell test that skips the install when it
+    already holds. The lock is `directory/install.lock` unless the install replaces
+    `directory` itself, in which case pass a `lock` path beside it. `shell` runs the script
+    (e.g. `bash -o pipefail -c` for pipelines).
+
+    The lock is `flock` (Linux, busybox) or `lockf` (macOS/BSD), both released when the holder
+    dies; an image with neither falls back to a symlink spinlock whose owner is recorded as
+    `pid:starttime` so a dead holder is reaped even if its pid was reused."""
+    lock = shlex.quote(lock or f"{directory}/install.lock")
+    script = f"{ready} || ({install})" if ready else install
+    run = f"{shlex.join(shell)} {shlex.quote(script)}"
+    # The owner token is pid:starttime (starttime from /proc where readable), so a reused pid
+    # does not pass as the live holder. A lock that is not a symlink (left behind by
+    # flock/lockf) or whose owner is gone is stale and reaped; `kill -0 ""` succeeds under
+    # busybox ash, hence the explicit -z.
+    ident = (
+        'ident() { if [ -r "/proc/$1/stat" ] && s=$(sed "s/^.*) //" "/proc/$1/stat" '
+        '| cut -d" " -f20) && [ -n "$s" ]; then echo "$1:$s"; else echo "$1"; fi; }; '
+        "me=$(ident $$); "
+    )
+    spinlock = (
+        f"{ident}"
+        f'until ln -s "$me" {lock} 2>/dev/null; do owner=$(readlink {lock} 2>/dev/null); '
+        f'pid=${{owner%%:*}}; if [ -z "$owner" ] || ! kill -0 "$pid" 2>/dev/null '
+        f'|| [ "$(ident "$pid")" != "$owner" ]; then '
+        f'[ "$(readlink {lock} 2>/dev/null)" != "$owner" ] || rm -f {lock}; fi; '
+        f"sleep 0.1; done; "
+        f'trap \'[ "$(readlink {lock} 2>/dev/null)" != "$me" ] || rm -f {lock}\' EXIT; {run}'
+    )
+    guarded = (
+        f"mkdir -p {shlex.quote(directory)} && "
+        f'if l=$(command -v flock || command -v lockf); then "$l" {lock} {run}; else {spinlock}; fi'
+    )
+    result = await runtime.run(["sh", "-c", guarded], env)
+    if result.exit_code != 0:
+        detail = (result.stderr.strip() or result.stdout.strip())[-500:]
+        raise RuntimeError(f"{label} install failed: {detail}")
+
+
+async def remove_dir(runtime: Runtime, path: str, label: str) -> None:
+    """Delete `path` in `runtime`; a failure names `label` (what the path held)."""
+    result = await runtime.run(["rm", "-rf", path], {})
+    if result.exit_code != 0:
+        raise RuntimeError(
+            f"failed to clean up {label}: {result.stderr.strip()[-500:]}"
+        )

{verifiers-0.3.2.dev46.dist-info → verifiers-0.3.2.dev49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev46
+Version: 0.3.2.dev49
 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.dist-info → verifiers-0.3.2.dev49.dist-info}/RECORD

@@ -1,4 +1,5 @@
 verifiers/__init__.py,sha256=yDYsckVQbUkwoh9mU_hBeCLGvS_aWgAxuoNm5LxQpDI,517
+verifiers/cli/commands/init.py,sha256=DaT1NGrK2lnQWvHlrLkZ1D2Te49ll2Eh-DyOAhmCzfU,147
 verifiers/v1/__init__.py,sha256=qJKOsiUADKX4C1tMKsAPQXiJMo9-80FNeyPpAyRVshY,8352
 verifiers/v1/agent.py,sha256=h4zI924A-tLgezoGQaus9msogj1fSoC1Ugty01RFqU4,32206
 verifiers/v1/env.py,sha256=CEhzjojhg5jqbOYruUnc5U7TtgDHDSx8NiiFA0qfbt8,18234
@@ -44,7 +45,7 @@ verifiers/v1/configs/__init__.py,sha256=X7u6X7B3ieD1HZl79Tv1kg-yPHbT0QLvAebaGqxV
 verifiers/v1/configs/agent.py,sha256=L5P6ombAi4U5wwsspMHAuM8111sB9AVdm8q6B5iV1lw,3251
 verifiers/v1/configs/client.py,sha256=E7ZxeWBFV_AP8MyfxXncTZs-Yn-QKdDS57HCAzqVTrQ,4437
 verifiers/v1/configs/env.py,sha256=-Bcdd4MEPfekVc_fnpiwsb9UDwCNdNCKrAHGoQuuXu8,7784
-verifiers/v1/configs/harness.py,sha256=nk046YBXjSv_cNQJQeOSDddbwbH9BI4GXylixFvL4I4,1640
+verifiers/v1/configs/harness.py,sha256=Ks5fQD-8DYoDKokw2ejxUFwB9iWpOWDL0o89bd2ipxo,1798
 verifiers/v1/configs/judge.py,sha256=CBmGgyHXVpcBctvrFD5GlW75wpeFXVFajq_xiMaAVDk,2142
 verifiers/v1/configs/retries.py,sha256=-nPlgmz7J_NZ4GOYG6oCc3thXo4La2SufBmvQGvvPGo,821
 verifiers/v1/configs/runtime.py,sha256=IBX3FxiJ2RJaiX2aKghQ15clFHvJpPUXy8GWQOpNhYM,2967
@@ -82,42 +83,43 @@ verifiers/v1/gepa/dataset.py,sha256=hFuR7dou4VSKa0ujb8sFmGm9a19mjrsmTa1MMW1Kv7I,
 verifiers/v1/gepa/reflection.py,sha256=ptHhx0lcDLcWhWhXuslh9T8gPVNpnX5XLPtXoneW1yA,1054
 verifiers/v1/gepa/runner.py,sha256=fGEyFzejdQKBzBbvdiTDHV3JtRhXMXMGSBU5y8C8i3w,6054
 verifiers/v1/harnesses/__init__.py,sha256=0FVi-mPF36fF0vpLY4H2vbK3U_om1Svz3KgJ3i-phs0,1918
-verifiers/v1/harnesses/node.py,sha256=_-7NofTl-TNuwgEg8qxrD28shlQuyBWgiVHwCCwbdVo,2410
+verifiers/v1/harnesses/node.py,sha256=-lDPh30p65IETPVLkKn4yhEK49rtEGVQf9TNs7MVQYE,2133
 verifiers/v1/harnesses/bash/__init__.py,sha256=IAV4eMMqDHSl-9ANb0Q3kxmBZ22SeHZFBM448X4gQio,140
 verifiers/v1/harnesses/bash/harness.py,sha256=22c2Pn4TX-ftbqeFO1tOTbAij3RT19V2R88ph098jjE,5315
 verifiers/v1/harnesses/browser_use/__init__.py,sha256=yxm2IG5TDLadxZEkX8SL26XWbcPcODXcrJfPfm1GqwU,171
 verifiers/v1/harnesses/browser_use/harness.py,sha256=eGdLDRbTF8hg4NUwU1jVJcsUei0Y-gTqbGcj3eFJ7XI,4926
 verifiers/v1/harnesses/browser_use/program.py,sha256=3dSFHSDIW3R5ZejV23sXReEKnGQjvPAAdzU-N2RrHpw,9822
 verifiers/v1/harnesses/claude_code/__init__.py,sha256=JkZQylMSA3o1fvBx_NM41y_umuahmOSqFjTrJ2hryTw,171
-verifiers/v1/harnesses/claude_code/harness.py,sha256=bkYbQe0tih9tIGTUp-keSjUlx4DFGXYjX7Lisd212do,4620
+verifiers/v1/harnesses/claude_code/harness.py,sha256=Racxbs1EAH3gRwSeUptAIa3kB-EUm_nreUnHMwRUHuE,4119
 verifiers/v1/harnesses/codex/__init__.py,sha256=ocyBvlpSO8c3pT6D1ebrQohoXYESQcCyPT5kN3j1-N4,132
-verifiers/v1/harnesses/codex/harness.py,sha256=BXA1xptf6ilry7i3zgAI7WnUomEbXcD_Ikv8W8xqHI4,7482
+verifiers/v1/harnesses/codex/harness.py,sha256=c8Vht0LOba7xTxCXwFH2W9rRTRdAv8Eypc1e-uSxFvg,7050
 verifiers/v1/harnesses/hermes_agent/__init__.py,sha256=k84Y8UTTf1KOw5LGqPb2dk-hYFagPevDJBOF7qsR_vo,176
-verifiers/v1/harnesses/hermes_agent/harness.py,sha256=AZNjQTwkv7_Dk9P1a20Xoeb-Df7iN60pWWHMw9YJ2eM,3773
+verifiers/v1/harnesses/hermes_agent/harness.py,sha256=dSsE2VZ8jaM-U14QXO3J7P-U6NMpSuOz3DUMtDWpWk0,3622
 verifiers/v1/harnesses/hermes_agent/program.py,sha256=RaIYm6NFD8KLXERGXp6rOE4QrQjlcTnm1Fu33xYsiHw,570
 verifiers/v1/harnesses/kimi_code/__init__.py,sha256=1BEotSfuzmVcE7UrxHeAREM5d7J20cGkonHuowlrzu4,161
-verifiers/v1/harnesses/kimi_code/harness.py,sha256=3SSIty3JtQmvbItutjXJRGrh86KSAnRAK1g9Koa_5mA,4400
+verifiers/v1/harnesses/kimi_code/harness.py,sha256=NCkNIdOFDNiUrEmLYb-r-SjyunR5Cmu1g4F1lwuhGK0,4163
 verifiers/v1/harnesses/mini_swe_agent/__init__.py,sha256=1OBu2Y-XqL72-dGhFdgB6sr5uX_peEEXT9vEjPy1ovU,182
-verifiers/v1/harnesses/mini_swe_agent/harness.py,sha256=7HHismhmfCtahlLtQdQyp_fTKidHfco-MdeWp7B9xCo,2522
+verifiers/v1/harnesses/mini_swe_agent/harness.py,sha256=HKGtlDyhXDJqNtDFeb3D4JYUerIgXK6HAmyqOm1mkRo,2473
 verifiers/v1/harnesses/mini_swe_agent/program.py,sha256=Beej-JLIgSqnqIqB746oKU6kJYcynvppIbmwGa3nJJ0,167
 verifiers/v1/harnesses/null/__init__.py,sha256=XDeKOPeoXUQi9US9_Z3_yH9YaZ4EiOMKJmUtNNdtD7s,127
 verifiers/v1/harnesses/null/harness.py,sha256=RWj2I7auxYe4dJ885DhqH1MN15iUS-TKT7-gEWNrgmM,1412
 verifiers/v1/harnesses/openclaw/__init__.py,sha256=kNyfPB1sGwEf4K3mTfKN0VEyxun3SGvNpvArVKvH-x8,160
-verifiers/v1/harnesses/openclaw/harness.py,sha256=EREEYr3J0Qn8mK_YShnCSHctMtsiIN07rj00kq1Lxoc,11229
+verifiers/v1/harnesses/openclaw/harness.py,sha256=tucrQb_Osi7KAEtpyO4i55IXI5SFtLnyItB8eV4kjng,10534
 verifiers/v1/harnesses/pi/__init__.py,sha256=1mSnzOf-RdEchdeg6IHtcdobG5KIpAhuTdUIgsCIn74,117
-verifiers/v1/harnesses/pi/harness.py,sha256=M0BRsfJxnBNP-KCrp0vT5gHlaJEDnyti5x_3V5Py40M,7024
+verifiers/v1/harnesses/pi/harness.py,sha256=11V9d6_npjE9vEEgIG7y80kfaX1Ilfi3lbYsqGsN1NE,6496
 verifiers/v1/harnesses/pool/__init__.py,sha256=HTYsNiWGdiNEsSHj4xhPmshJSNb7SHjQ7d4yZQ4p3HM,127
-verifiers/v1/harnesses/pool/harness.py,sha256=HKAogPbyLK5QpvPQ1teHOh_IyRQX-or2JF71nnZ_5Ps,3875
+verifiers/v1/harnesses/pool/harness.py,sha256=TsELYhW4mMOt_laiDN6nAQJxFL3iCcKvckQWYve2XiE,3571
 verifiers/v1/harnesses/prime_agent/__init__.py,sha256=xfPC4RrlnyYWaf38tPAOZq4YL6M55lMpj5BoRLmaK8I,171
-verifiers/v1/harnesses/prime_agent/harness.py,sha256=vswuKVWObWC9rcDBvlCnjjPRq1qCNqCzTknkOTN3cV8,11178
+verifiers/v1/harnesses/prime_agent/harness.py,sha256=VFQ3kOqfR38upCwR8nuBbdc68RYW3EKUjVeOD7cKq1c,10785
 verifiers/v1/harnesses/rlm/__init__.py,sha256=hwx51xTdEWzzYgMj-p4ETNcptoub3IPMDbEdJ4uB8Ns,122
-verifiers/v1/harnesses/rlm/harness.py,sha256=iVdI4dzbuXm5v6Pq28ctLjOmcXWtC2Vmp2aKOniq0ss,10532
+verifiers/v1/harnesses/rlm/harness.py,sha256=DX6xPBdxdXhJz-LClThAj7f1ZJ5tgN03H_WBbYhKce4,10445
 verifiers/v1/harnesses/terminus_2/__init__.py,sha256=l1pwfg1HyVDEqT9efdnFWcXqaZwtKwe7TrplkyxZSA0,166
-verifiers/v1/harnesses/terminus_2/harness.py,sha256=kXKhi-aqqsoXGnvet0Tq_v7LYYpRYEzARyQL2MTEGWs,3101
+verifiers/v1/harnesses/terminus_2/harness.py,sha256=DMTY1bzvydyjHqzmvBSBGKJsmUzYEgxqd215a7cG7tg,3052
 verifiers/v1/harnesses/terminus_2/program.py,sha256=X8MZdyItU3gbXGXnGOlJ9LWcUTnqIDaxlhkZvoRiqKY,2703
 verifiers/v1/harnesses/utils/__init__.py,sha256=eTS-Ft2HwoLiYn5u1t_KueLmaZB_W12cdYmcVsE-G5A,364
 verifiers/v1/harnesses/utils/compaction.py,sha256=DeY6CYLEsv7-vJm26sT2mRaPHu3W2ywiZhvFr_pi6Hg,10495
 verifiers/v1/harnesses/utils/core.py,sha256=_FYeBvp506JWsya0vKYbka9ZYqUwJC7Gm7fnwammwug,14993
+verifiers/v1/harnesses/utils/install.py,sha256=BDkkUVZ1brSzCrbQOvMO5mVIE2DsV2pE7rTC5yROYUw,2992
 verifiers/v1/harnesses/utils/launch.py,sha256=XlQezSmgq6X3F7q9L7UROw74BfF4oHFPgQLVbd-m7SI,3039
 verifiers/v1/harnesses/utils/mcp.py,sha256=Sss-DVMtxdE1eGEfq1ycdi1v7SBsmUU5UcpcIY6dGTY,4572
 verifiers/v1/interception/__init__.py,sha256=5Kvo7tcBUVaa65s9A1NiOH3CPpzw-P5btXwxB4Nbbvs,4251
@@ -187,8 +189,8 @@ verifiers/v1/utils/prime.py,sha256=UTYRjp9cbjNb6CVmBHda-1wWZAIIfxNOmTyNuT7_wL4,9
 verifiers/v1/utils/retries.py,sha256=Y2ZgrAjn-qNkRKZP_RVNL_7EK0iaRcZeCa404lpGYi4,5417
 verifiers/v1/utils/score.py,sha256=493yJVMw8teCu9JxapxMFPFzI0hNUqdo0Y2nGW4kckk,6200
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.3.2.dev46.dist-info/METADATA,sha256=ywadnUcDH-_ti14xITC_YxDyDv2IvcS5wkyYlcJlqDs,4153
-verifiers-0.3.2.dev46.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-verifiers-0.3.2.dev46.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
-verifiers-0.3.2.dev46.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.3.2.dev46.dist-info/RECORD,,
+verifiers-0.3.2.dev49.dist-info/METADATA,sha256=dSm6-ha_O7m2pDfdJZ6jHFqIhau1dqy-avNMf_MguOM,4153
+verifiers-0.3.2.dev49.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+verifiers-0.3.2.dev49.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
+verifiers-0.3.2.dev49.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.3.2.dev49.dist-info/RECORD,,